diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/Capnp.Net.Runtime.Tests/CallContext.cs b/Capnp.Net.Runtime.Tests/CallContext.cs new file mode 100644 index 0000000..07d5329 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/CallContext.cs @@ -0,0 +1,24 @@ +using System.Threading; +using System.Threading.Tasks; +using Capnp.Rpc; + +namespace Capnp.Net.Runtime.Tests +{ + class CallContext + { + public CallContext(ulong interfaceId, ushort methodId, DeserializerState args, CancellationToken ct) + { + InterfaceId = interfaceId; + MethodId = methodId; + Args = args; + Ct = ct; + Result = new TaskCompletionSource(); + } + + public ulong InterfaceId { get; } + public ushort MethodId { get; } + public DeserializerState Args { get; } + public CancellationToken Ct { get; } + public TaskCompletionSource Result { get; } + } +} diff --git a/Capnp.Net.Runtime.Tests/Capnp.Net.Runtime.Tests.csproj b/Capnp.Net.Runtime.Tests/Capnp.Net.Runtime.Tests.csproj new file mode 100644 index 0000000..66c9807 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/Capnp.Net.Runtime.Tests.csproj @@ -0,0 +1,26 @@ + + + + netcoreapp2.1 + + false + + 7.1 + + + + DEBUG;TRACE + + + + + + + + + + + + + + diff --git a/Capnp.Net.Runtime.Tests/DeserializationTests.cs b/Capnp.Net.Runtime.Tests/DeserializationTests.cs new file mode 100644 index 0000000..882d4d7 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/DeserializationTests.cs @@ -0,0 +1,357 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class DeserializationTests + { + [TestMethod] + public void ListOfBytesAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(8, 10); + ds.ListWriteValue(1, (byte)0x11); + ds.ListWriteValue(2, (byte)0x22); + ds.ListWriteValue(3, (byte)0x33); + ds.ListWriteValue(4, (byte)0x44); + ds.ListWriteValue(5, (byte)0x55); + ds.ListWriteValue(6, (byte)0x66); + ds.ListWriteValue(7, (byte)0x77); + ds.ListWriteValue(8, (byte)0x88); + ds.ListWriteValue(9, (byte)0x99); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(10, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual((byte)0x00, asListOfStructs[0].ReadDataByte(0)); + Assert.AreEqual((byte)0x11, asListOfStructs[1].ReadDataByte(0)); + Assert.AreEqual((byte)0x22, asListOfStructs[2].ReadDataByte(0)); + Assert.AreEqual((byte)0x33, asListOfStructs[3].ReadDataByte(0)); + Assert.AreEqual((byte)0x44, asListOfStructs[4].ReadDataByte(0)); + Assert.AreEqual((byte)0x55, asListOfStructs[5].ReadDataByte(0)); + Assert.AreEqual((byte)0x66, asListOfStructs[6].ReadDataByte(0)); + Assert.AreEqual((byte)0x77, asListOfStructs[7].ReadDataByte(0)); + Assert.AreEqual((byte)0x88, asListOfStructs[8].ReadDataByte(0)); + Assert.AreEqual((byte)0x99, asListOfStructs[9].ReadDataByte(0)); + } + + [TestMethod] + public void ListOfSBytesAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(8, 10); + ds.ListWriteValue(1, (sbyte)-1); + ds.ListWriteValue(2, (sbyte)-2); + ds.ListWriteValue(3, (sbyte)-3); + ds.ListWriteValue(4, (sbyte)-4); + ds.ListWriteValue(5, (sbyte)-5); + ds.ListWriteValue(6, (sbyte)-6); + ds.ListWriteValue(7, (sbyte)-7); + ds.ListWriteValue(8, (sbyte)-8); + ds.ListWriteValue(9, (sbyte)-9); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(10, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual((sbyte)0, asListOfStructs[0].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-1, asListOfStructs[1].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-2, asListOfStructs[2].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-3, asListOfStructs[3].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-4, asListOfStructs[4].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-5, asListOfStructs[5].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-6, asListOfStructs[6].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-7, asListOfStructs[7].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-8, asListOfStructs[8].ReadDataSByte(0)); + Assert.AreEqual((sbyte)-9, asListOfStructs[9].ReadDataSByte(0)); + } + + [TestMethod] + public void ListOfUShortsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(16, 3); + ds.ListWriteValue(1, (ushort)0x1111); + ds.ListWriteValue(2, (ushort)0x2222); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(3, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual((ushort)0x0000, asListOfStructs[0].ReadDataUShort(0)); + Assert.AreEqual((ushort)0x1111, asListOfStructs[1].ReadDataUShort(0)); + Assert.AreEqual((ushort)0x2222, asListOfStructs[2].ReadDataUShort(0)); + } + + [TestMethod] + public void ListOfShortsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(16, 3); + ds.ListWriteValue(1, (short)-0x1111); + ds.ListWriteValue(2, (short)-0x2222); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(3, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual((short)0, asListOfStructs[0].ReadDataShort(0)); + Assert.AreEqual((short)-0x1111, asListOfStructs[1].ReadDataShort(0)); + Assert.AreEqual((short)-0x2222, asListOfStructs[2].ReadDataShort(0)); + } + + [TestMethod] + public void ListOfUIntsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(32, 2); + ds.ListWriteValue(1, uint.MaxValue); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(2, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual(0u, asListOfStructs[0].ReadDataUInt(0)); + Assert.AreEqual(uint.MaxValue, asListOfStructs[1].ReadDataUInt(0)); + } + + [TestMethod] + public void ListOfIntsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(32, 2); + ds.ListWriteValue(0, int.MinValue); + ds.ListWriteValue(1, int.MaxValue); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(2, asListOfStructs.Count); + Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind); + Assert.AreEqual(int.MinValue, asListOfStructs[0].ReadDataInt(0)); + Assert.AreEqual(int.MaxValue, asListOfStructs[1].ReadDataInt(0)); + } + + [TestMethod] + public void ListOfULongsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(64, 2); + ds.ListWriteValue(1, ulong.MaxValue); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(2, asListOfStructs.Count); + Assert.AreEqual(0ul, asListOfStructs[0].ReadDataULong(0)); + Assert.AreEqual(ulong.MaxValue, asListOfStructs[1].ReadDataULong(0)); + } + + [TestMethod] + public void ListOfLongsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(64, 2); + ds.ListWriteValue(0, long.MinValue); + ds.ListWriteValue(1, long.MaxValue); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(2, asListOfStructs.Count); + Assert.AreEqual(long.MinValue, asListOfStructs[0].ReadDataLong(0)); + Assert.AreEqual(long.MaxValue, asListOfStructs[1].ReadDataLong(0)); + } + + [TestMethod] + public void ListOfFloatsAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(32, 6); + ds.ListWriteValue(0, 1.0f); + ds.ListWriteValue(1, float.MinValue); + ds.ListWriteValue(2, float.MaxValue); + ds.ListWriteValue(3, float.NaN); + ds.ListWriteValue(4, float.NegativeInfinity); + ds.ListWriteValue(5, float.PositiveInfinity); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(6, asListOfStructs.Count); + Assert.AreEqual(1.0f, asListOfStructs[0].ReadDataFloat(0)); + Assert.AreEqual(float.MinValue, asListOfStructs[1].ReadDataFloat(0)); + Assert.AreEqual(float.MaxValue, asListOfStructs[2].ReadDataFloat(0)); + Assert.AreEqual(float.NaN, asListOfStructs[3].ReadDataFloat(0)); + Assert.AreEqual(float.NegativeInfinity, asListOfStructs[4].ReadDataFloat(0)); + Assert.AreEqual(float.PositiveInfinity, asListOfStructs[5].ReadDataFloat(0)); + } + + [TestMethod] + public void ListOfDoublesAsListOfStructs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfValues(64, 6); + ds.ListWriteValue(0, 1.0); + ds.ListWriteValue(1, double.MinValue); + ds.ListWriteValue(2, double.MaxValue); + ds.ListWriteValue(3, double.NaN); + ds.ListWriteValue(4, double.NegativeInfinity); + ds.ListWriteValue(5, double.PositiveInfinity); + + DeserializerState d = ds; + var asListOfStructs = d.RequireList().Cast(_ => _); + Assert.AreEqual(6, asListOfStructs.Count); + Assert.AreEqual(1.0, asListOfStructs[0].ReadDataDouble(0)); + Assert.AreEqual(double.MinValue, asListOfStructs[1].ReadDataDouble(0)); + Assert.AreEqual(double.MaxValue, asListOfStructs[2].ReadDataDouble(0)); + Assert.AreEqual(double.NaN, asListOfStructs[3].ReadDataDouble(0)); + Assert.AreEqual(double.NegativeInfinity, asListOfStructs[4].ReadDataDouble(0)); + Assert.AreEqual(double.PositiveInfinity, asListOfStructs[5].ReadDataDouble(0)); + } + + [TestMethod] + public void ListOfStructsAsListOfBytes() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(3, 1, 0); + ds.ListBuildStruct(1).WriteData(0, (byte)0x11); + ds.ListBuildStruct(2).WriteData(0, (byte)0x22); + + DeserializerState d = ds; + var asListOfBytes = d.RequireList().CastByte(); + Assert.AreEqual(3, asListOfBytes.Count); + Assert.AreEqual(0, asListOfBytes[0]); + Assert.AreEqual((byte)0x11, asListOfBytes[1]); + Assert.AreEqual((byte)0x22, asListOfBytes[2]); + } + + [TestMethod] + public void ListOfStructsAsListOfSBytes() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(1).WriteData(0, sbyte.MinValue); + + DeserializerState d = ds; + var asListOfSBytes = d.RequireList().CastSByte(); + Assert.AreEqual(2, asListOfSBytes.Count); + Assert.AreEqual((sbyte)0, asListOfSBytes[0]); + Assert.AreEqual(sbyte.MinValue, asListOfSBytes[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfUShorts() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(1).WriteData(0, ushort.MaxValue); + + DeserializerState d = ds; + var asListOfUShorts = d.RequireList().CastUShort(); + Assert.AreEqual(2, asListOfUShorts.Count); + Assert.AreEqual((ushort)0, asListOfUShorts[0]); + Assert.AreEqual(ushort.MaxValue, asListOfUShorts[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfShorts() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(0).WriteData(0, short.MinValue); + ds.ListBuildStruct(1).WriteData(0, short.MaxValue); + + DeserializerState d = ds; + var asListOfShorts = d.RequireList().CastShort(); + Assert.AreEqual(2, asListOfShorts.Count); + Assert.AreEqual(short.MinValue, asListOfShorts[0]); + Assert.AreEqual(short.MaxValue, asListOfShorts[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfUInts() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(1).WriteData(0, uint.MaxValue); + + DeserializerState d = ds; + var asListOfUInts = d.RequireList().CastUInt(); + Assert.AreEqual(2, asListOfUInts.Count); + Assert.AreEqual(0u, asListOfUInts[0]); + Assert.AreEqual(uint.MaxValue, asListOfUInts[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfInts() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(0).WriteData(0, int.MinValue); + ds.ListBuildStruct(1).WriteData(0, int.MaxValue); + + DeserializerState d = ds; + var asListOfInts = d.RequireList().CastInt(); + Assert.AreEqual(2, asListOfInts.Count); + Assert.AreEqual(int.MinValue, asListOfInts[0]); + Assert.AreEqual(int.MaxValue, asListOfInts[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfULongs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(1).WriteData(0, ulong.MaxValue); + + DeserializerState d = ds; + var asListOfULongs = d.RequireList().CastULong(); + Assert.AreEqual(2, asListOfULongs.Count); + Assert.AreEqual(0ul, asListOfULongs[0]); + Assert.AreEqual(ulong.MaxValue, asListOfULongs[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfLongs() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(0).WriteData(0, long.MinValue); + ds.ListBuildStruct(1).WriteData(0, long.MaxValue); + + DeserializerState d = ds; + var asListOfLongs = d.RequireList().CastLong(); + Assert.AreEqual(2, asListOfLongs.Count); + Assert.AreEqual(long.MinValue, asListOfLongs[0]); + Assert.AreEqual(long.MaxValue, asListOfLongs[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfFloats() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(0).WriteData(0, float.NaN); + ds.ListBuildStruct(1).WriteData(0, float.PositiveInfinity); + + DeserializerState d = ds; + var asListOfFloats = d.RequireList().CastFloat(); + Assert.AreEqual(2, asListOfFloats.Count); + Assert.AreEqual(float.NaN, asListOfFloats[0]); + Assert.AreEqual(float.PositiveInfinity, asListOfFloats[1]); + } + + [TestMethod] + public void ListOfStructsAsListOfDoubles() + { + var ds = new DynamicSerializerState(MessageBuilder.Create(128)); + ds.SetListOfStructs(2, 1, 0); + ds.ListBuildStruct(0).WriteData(0, double.NegativeInfinity); + ds.ListBuildStruct(1).WriteData(0, double.MaxValue); + + DeserializerState d = ds; + var asListOfDoubles = d.RequireList().CastDouble(); + Assert.AreEqual(2, asListOfDoubles.Count); + Assert.AreEqual(double.NegativeInfinity, asListOfDoubles[0]); + Assert.AreEqual(double.MaxValue, asListOfDoubles[1]); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/DynamicSerializerStateTests.cs b/Capnp.Net.Runtime.Tests/DynamicSerializerStateTests.cs new file mode 100644 index 0000000..5a58ee5 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/DynamicSerializerStateTests.cs @@ -0,0 +1,927 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class DynamicSerializerStateTests + { + [TestMethod] + public void Struct() + { + var mb = MessageBuilder.Create(8); + var ds = new DynamicSerializerState(mb); + var alloc = mb.Allocator; + ds.SetStruct(3, 2); + Assert.IsFalse(ds.IsAllocated); + Assert.ThrowsException(() => ds.SetListOfPointers(1)); + Assert.ThrowsException(() => ds.SetListOfStructs(3, 2, 1)); + Assert.ThrowsException(() => ds.SetListOfValues(8, 3)); + Assert.ThrowsException(() => ds.SetStruct(2, 3)); + ds.SetStruct(3, 2); + ds.Allocate(); + Assert.IsTrue(ds.IsAllocated); + Assert.AreEqual(3, ds.StructDataSection.Length); + ds.StructWriteData(0, 16, 0x4321); + ds.StructWriteData(64, 32, 0x87654321); + ds.StructWriteData(128, 64, 0x1234567812345678); + Assert.ThrowsException(() => ds.StructWriteData(191, 2, 1)); + + var ds2 = ds.BuildPointer(0); + ds2.SetStruct(1, 0); + ds2.WriteData(0, 1.23); + + Assert.ThrowsException(() => ds.Link(2, ds)); + + Assert.AreEqual(1, alloc.Segments.Count); + Assert.AreEqual(7, alloc.Segments[0].Length); + + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.Struct, d.Kind); + Assert.AreEqual(3, d.StructDataCount); + Assert.AreEqual(2, d.StructPtrCount); + Assert.AreEqual(0x4321, d.ReadDataUShort(0)); + Assert.AreEqual(0x87654321, d.ReadDataUInt(64)); + Assert.IsTrue(0x1234567812345678 == d.ReadDataULong(128)); + var p0 = d.StructReadPointer(0); + Assert.AreEqual(ObjectKind.Struct, p0.Kind); + Assert.AreEqual(1.23, p0.ReadDataDouble(0)); + var p1 = d.StructReadPointer(1); + Assert.AreEqual(ObjectKind.Nil, p1.Kind); + } + + [TestMethod] + public void StructWithPrimitives() + { + var mb = MessageBuilder.Create(8); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetStruct(10, 0); + ds.WriteData(0, ulong.MaxValue - 1, ulong.MaxValue); + ds.WriteData(64, long.MaxValue - 1, -123); + ds.WriteData(128, uint.MaxValue - 1, 123); + ds.WriteData(160, int.MaxValue - 1, -123); + ds.WriteData(192, (ushort)(ushort.MaxValue - 1), (ushort)321); + ds.WriteData(208, (short)(short.MaxValue - 1), (short)321); + ds.WriteData(224, (byte)(byte.MaxValue - 1), (byte)111); + ds.WriteData(232, (sbyte)(sbyte.MaxValue - 1), (sbyte)(-111)); + ds.WriteData(240, false, false); + ds.WriteData(241, false, true); + ds.WriteData(242, true, false); + ds.WriteData(243, true, true); + ds.WriteData(256, 12.34, 0.5); + ds.WriteData(320, 1.2f, 0.5f); + + DeserializerState d = ds; + Assert.AreEqual(ulong.MaxValue - 1, d.ReadDataULong(0, ulong.MaxValue)); + Assert.AreEqual(long.MaxValue - 1, d.ReadDataLong(64, -123)); + Assert.AreEqual(uint.MaxValue - 1, d.ReadDataUInt(128, 123)); + Assert.AreEqual(int.MaxValue - 1, d.ReadDataInt(160, -123)); + Assert.AreEqual(ushort.MaxValue - 1, d.ReadDataUShort(192, 321)); + Assert.AreEqual(short.MaxValue - 1, d.ReadDataShort(208, 321)); + Assert.AreEqual(byte.MaxValue - 1, d.ReadDataByte(224, 111)); + Assert.AreEqual(sbyte.MaxValue - 1, d.ReadDataSByte(232, -111)); + Assert.AreEqual(false, d.ReadDataBool(240, false)); + Assert.AreEqual(false, d.ReadDataBool(241, true)); + Assert.AreEqual(true, d.ReadDataBool(242, false)); + Assert.AreEqual(true, d.ReadDataBool(243, true)); + Assert.AreEqual(12.34, d.ReadDataDouble(256, 0.5)); + Assert.AreEqual(1.2f, d.ReadDataFloat(320, 0.5f)); + } + + [TestMethod] + public void StructRecursion() + { + var mb = MessageBuilder.Create(8); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetStruct(1, 1); + ds.WriteData(0, 123); + ds.Link(0, ds, false); + + DeserializerState d = ds; + Assert.AreEqual(123, d.ReadDataInt(0)); + Assert.AreEqual(123, d.StructReadPointer(0).ReadDataInt(0)); + Assert.ThrowsException(() => + { + for (int i = 0; i < 64000000; i++) + { + d = d.StructReadPointer(0); + } + }); + } + + [TestMethod] + public void StructWithLists() + { + var mb = MessageBuilder.Create(8); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + { + ds.SetStruct(0, 2); + ds.WriteText(0, "Lorem ipsum"); + var los = ds.BuildPointer(1); + los.SetListOfStructs(3, 1, 1); + var e0 = los.ListBuildStruct(0); + e0.WriteData(0, long.MinValue); + e0.WriteText(0, long.MinValue.ToString()); + var e1 = los.ListBuildStruct(1); + e1.WriteData(0, 0L); + e1.WriteText(0, 0L.ToString()); + var e2 = los.ListBuildStruct(2); + e2.WriteData(0, long.MaxValue); + e2.WriteText(0, long.MaxValue.ToString()); + } + + { + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.Struct, d.Kind); + Assert.AreEqual("Lorem ipsum", d.ReadText(0)); + var los = d.ReadListOfStructs(1, _ => _); + Assert.AreEqual(3, los.Count); + Assert.AreEqual(long.MinValue, los[0].ReadDataLong(0)); + Assert.AreEqual(long.MinValue.ToString(), los[0].ReadText(0)); + Assert.AreEqual(0L, los[1].ReadDataLong(0)); + Assert.AreEqual(0L.ToString(), los[1].ReadText(0)); + Assert.AreEqual(long.MaxValue, los[2].ReadDataLong(0)); + Assert.AreEqual(long.MaxValue.ToString(), los[2].ReadText(0)); + } + } + + [TestMethod] + public void MultiSegmentStruct() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetStruct(1, 2); + ds.WriteData(0, 815); + string s0 = "Lorem ipsum dolor sit amet"; + ds.WriteText(0, s0); + string s1 = "All men are created equal"; + ds.WriteText(1, s1); + Assert.IsTrue(alloc.Segments.Count >= 3); + + DeserializerState d = ds; + Assert.AreEqual(815, d.ReadDataInt(0)); + Assert.AreEqual(s0, d.ReadText(0)); + Assert.AreEqual(s1, d.ReadText(1)); + } + + [TestMethod] + public void ListOfEmpty() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetListOfValues(0, int.MaxValue); + Assert.ThrowsException( + () => ds.ListWriteValue(0, 1, 0)); + + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.ListOfEmpty, d.Kind); + Assert.AreEqual(int.MaxValue, d.ListElementCount); + } + + [TestMethod] + public void ListOfBits() + { + bool ValueGen(int index) + { + return (index % 3) == 0; + } + + DynamicSerializerState CreateListBulk(int count) + { + var mb = MessageBuilder.Create(8); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetListOfValues(1, count); + var list = new List(); + for (int i = 0; i < count; i++) + { + list.Add(ValueGen(i)); + } + ds.ListWriteValues(list); + + return ds; + } + + DynamicSerializerState CreateListSingle(int count) + { + var mb = MessageBuilder.Create(8); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetListOfValues(1, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, ValueGen(i)); + } + + return ds; + } + + void VerifyList(DeserializerState d, int count) + { + Assert.AreEqual(ObjectKind.ListOfBits, d.Kind); + Assert.AreEqual(count, d.ListElementCount); + var rlist = d.RequireList().CastBool(); + Assert.AreEqual(count, rlist.Count); + for (int i = 0; i < count; i++) + { + bool expected = ValueGen(i); + bool actual = rlist[i]; + Assert.AreEqual(expected, actual); + } + Assert.ThrowsException(() => + { + var dummy = rlist[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = rlist[count]; + }); + } + + int c = 123; + VerifyList(CreateListBulk(c), c); + VerifyList(CreateListSingle(c), c); + } + + [TestMethod] + public void ListOfSBytes() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 100; + ds.SetListOfValues(8, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (sbyte)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var sbytes = d.RequireList().CastSByte(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((sbyte)i, sbytes[i]); + } + + Assert.ThrowsException(() => + { + var dummy = sbytes[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = sbytes[count]; + }); + } + + [TestMethod] + public void ListOfBytes() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 277; + ds.SetListOfValues(8, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (byte)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var bytes = d.RequireList().CastByte(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((byte)i, bytes[i]); + } + + Assert.ThrowsException(() => + { + var dummy = bytes[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = bytes[count]; + }); + } + + [TestMethod] + public void ListOfShorts() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 333; + ds.SetListOfValues(16, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (short)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var shorts = d.RequireList().CastShort(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((short)i, shorts[i]); + } + + Assert.ThrowsException(() => + { + var dummy = shorts[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = shorts[count]; + }); + } + + [TestMethod] + public void ListOfUShorts() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 234; + ds.SetListOfValues(16, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (ushort)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var ushorts = d.RequireList().CastUShort(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((ushort)i, ushorts[i]); + } + + Assert.ThrowsException(() => + { + var dummy = ushorts[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = ushorts[count]; + }); + } + + [TestMethod] + public void ListOfInts() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 1234; + ds.SetListOfValues(32, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var ints = d.RequireList().CastInt(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual(i, ints[i]); + } + + Assert.ThrowsException(() => + { + var dummy = ints[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = ints[count]; + }); + } + + [TestMethod] + public void ListOfUInts() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 321; + ds.SetListOfValues(32, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (uint)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var uints = d.RequireList().CastUInt(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((uint)i, uints[i]); + } + + Assert.ThrowsException(() => + { + var dummy = uints[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = uints[count]; + }); + } + + [TestMethod] + public void ListOfLongs() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 432; + ds.SetListOfValues(64, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (long)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var longs = d.RequireList().CastLong(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((long)i, longs[i]); + } + Assert.ThrowsException(() => + { + var dummy = longs[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = longs[count]; + }); + } + + [TestMethod] + public void ListOfULongs() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 345; + ds.SetListOfValues(64, count); + for (int i = 0; i < count; i++) + { + ds.ListWriteValue(i, (ulong)i); + } + + DeserializerState d = ds; + Assert.AreEqual(count, d.ListElementCount); + var ulongs = d.RequireList().CastULong(); + for (int i = 0; i < count; i++) + { + Assert.AreEqual((ulong)i, ulongs[i]); + } + Assert.ThrowsException(() => + { + var dummy = ulongs[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = ulongs[count]; + }); + } + + [TestMethod] + public void ListOfPointers() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 77; + ds.SetListOfPointers(count); + var dse0 = ds.BuildPointer(0); + dse0.SetStruct(1, 0); + dse0.WriteData(0, 654); + var dse1 = new DynamicSerializerState(mb); + dse1.SetStruct(1, 0); + dse1.WriteData(0, 555); + ds.Link(1, dse1); + ds.Link(2, dse1); + var dse3 = ds.BuildPointer(3); + dse3.SetListOfValues(32, 10); + + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.ListOfPointers, d.Kind); + Assert.AreEqual(count, d.ListElementCount); + var pointers = d.RequireList().Cast(_ => _); + Assert.AreEqual(ObjectKind.Struct, pointers[0].Kind); + Assert.AreEqual(654, pointers[0].ReadDataInt(0)); + Assert.AreEqual(ObjectKind.Struct, pointers[1].Kind); + Assert.AreEqual(555, pointers[1].ReadDataInt(0)); + Assert.AreEqual(ObjectKind.Struct, pointers[2].Kind); + Assert.AreEqual(555, pointers[2].ReadDataInt(0)); + Assert.AreEqual(ObjectKind.ListOfInts, pointers[3].Kind); + Assert.AreEqual(10, pointers[3].ListElementCount); + Assert.AreEqual(ObjectKind.Nil, pointers[4].Kind); + Assert.ThrowsException(() => + { + var dummy = pointers[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = pointers[count]; + }); + } + + [TestMethod] + public void ListOfStructs() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int count = 23; + ds.SetListOfStructs(count, 2, 1); + var dse0 = ds.ListBuildStruct(0); + dse0.WriteData(0, 1); + dse0.WriteData(64, 2); + var dse1 = ds.ListBuildStruct(1); + dse1.WriteData(0, 3); + dse1.WriteData(64, 4); + Assert.ThrowsException( + () => ds.Link(2, ds)); + Assert.ThrowsException( + () => ds.BuildPointer(2)); + + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.ListOfStructs, d.Kind); + Assert.AreEqual(count, d.ListElementCount); + var pointers = d.RequireList().Cast(_ => _); + Assert.AreEqual(ObjectKind.Struct, pointers[0].Kind); + Assert.AreEqual(1, pointers[0].ReadDataInt(0)); + Assert.AreEqual(2, pointers[0].ReadDataInt(64)); + Assert.AreEqual(ObjectKind.Struct, pointers[1].Kind); + Assert.AreEqual(3, pointers[1].ReadDataInt(0)); + Assert.AreEqual(4, pointers[1].ReadDataInt(64)); + Assert.AreEqual(ObjectKind.Struct, pointers[2].Kind); + Assert.AreEqual(0, pointers[2].ReadDataInt(0)); + Assert.AreEqual(0, pointers[2].ReadDataInt(64)); + Assert.ThrowsException(() => + { + var dummy = pointers[-1]; + }); + Assert.ThrowsException(() => + { + var dummy = pointers[count]; + }); + } + + [TestMethod] + public void Capability() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + ds.SetStruct(0, 1); + ds.LinkToCapability(0, 13); + + DeserializerState d = ds; + Assert.AreEqual(ObjectKind.Struct, d.Kind); + var p = d.StructReadPointer(0); + Assert.AreEqual(ObjectKind.Capability, p.Kind); + Assert.AreEqual(13u, p.CapabilityIndex); + } + + [TestMethod] + public void Abuse() + { + var mb = MessageBuilder.Create(1); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + + Assert.ThrowsException(() => + ds.SetListOfPointers(-1)); + Assert.ThrowsException(() => + ds.SetListOfStructs(-10, 100, 200)); + Assert.ThrowsException(() => + ds.SetListOfValues(2, 1)); + Assert.ThrowsException(() => + ds.SetListOfValues(1, -1)); + Assert.ThrowsException(() => + ds.SetListOfValues(65, 1)); + } + + [TestMethod] + public void SharedPointer() + { + var mb = MessageBuilder.Create(128); + var alloc = mb.Allocator; + + var ds0 = new DynamicSerializerState(mb); + ds0.SetStruct(1, 0); + ds0.WriteData(0, 123); + + var ds1 = new DynamicSerializerState(mb); + ds1.SetStruct(0, 1); + ds1.Link(0, ds0); + + var ds2 = new DynamicSerializerState(mb); + ds2.SetStruct(0, 1); + ds2.Link(0, ds0); + + DeserializerState d1 = ds1; + Assert.AreEqual(ObjectKind.Struct, d1.Kind); + var e1 = d1.StructReadPointer(0); + Assert.AreEqual(ObjectKind.Struct, e1.Kind); + Assert.AreEqual(123, e1.ReadDataInt(0)); + + DeserializerState d2 = ds2; + Assert.AreEqual(ObjectKind.Struct, d2.Kind); + var e2 = d2.StructReadPointer(0); + Assert.AreEqual(ObjectKind.Struct, e2.Kind); + Assert.AreEqual(123, e2.ReadDataInt(0)); + } + + [TestMethod] + public void DeepCopy() + { + var mb = MessageBuilder.Create(128); + var alloc1 = mb.Allocator; + var ds1 = new DynamicSerializerState(mb); + ds1.SetStruct(10, 18); + for (int i = 0; i < 10; i++) + { + ds1.WriteData(64 * (ulong)i, i); + var el = ds1.BuildPointer(i); + el.SetStruct(1, 0); + el.WriteData(0, -i); + } + var los1 = ds1.BuildPointer(10); + los1.SetListOfStructs(1, 1, 0); + var el1 = los1.ListBuildStruct(0); + el1.WriteData(0, 111); + var lov1 = ds1.BuildPointer(11); + lov1.SetListOfValues(1, 7); + lov1.ListWriteValue(2, true); + lov1.ListWriteValue(3, true); + lov1.ListWriteValue(5, true); + var lovu8 = ds1.BuildPointer(12); + lovu8.SetListOfValues(8, 5); + lovu8.ListWriteValue(1, (byte)0x55); + lovu8.ListWriteValue(2, (byte)0xaa); + var lovu16 = ds1.BuildPointer(13); + lovu16.SetListOfValues(16, 3); + lovu16.ListWriteValue(0, (ushort)0x1111); + lovu16.ListWriteValue(1, (ushort)0x2222); + lovu16.ListWriteValue(2, (ushort)0x3333); + var lovu32 = ds1.BuildPointer(14); + lovu32.SetListOfValues(32, 9); + lovu32.ListWriteValue(1, 1u); + lovu32.ListWriteValue(2, 4u); + lovu32.ListWriteValue(3, 9u); + lovu32.ListWriteValue(4, 16u); + lovu32.ListWriteValue(5, 25u); + lovu32.ListWriteValue(6, 36u); + lovu32.ListWriteValue(7, 49u); + lovu32.ListWriteValue(8, 64u); + var lov64 = ds1.BuildPointer(15); + lov64.SetListOfValues(64, 2); + lov64.ListWriteValue(0, long.MinValue); + lov64.ListWriteValue(1, long.MaxValue); + var lop1 = ds1.BuildPointer(16); + lop1.SetListOfPointers(1); + lop1.LinkToCapability(0, 19); + var loe1 = ds1.BuildPointer(17); + loe1.SetListOfValues(0, 100); + + var mb2 = MessageBuilder.Create(128); + var alloc2 = mb2.Allocator; + var ds2 = new DynamicSerializerState(mb2); + ds2.SetStruct(0, 3); + Assert.ThrowsException(() => + ds2.Link(0, ds1, false)); + ds2.Link(0, ds1, true); + var lop = ds2.BuildPointer(1); + lop.SetListOfPointers(1); + lop.Link(0, ds1); + ds2.Link(2, el1, true); + + void VerifyBigStruct(DeserializerState ds) + { + Assert.AreEqual(ObjectKind.Struct, ds.Kind); + Assert.AreEqual(10, ds.StructDataCount); + Assert.AreEqual(18, ds.StructPtrCount); + for (int i = 0; i < 10; i++) + { + Assert.AreEqual(i, ds.ReadDataInt(64 * (ulong)i)); + var el = ds.StructReadPointer(i); + Assert.AreEqual(ObjectKind.Struct, el.Kind); + Assert.AreEqual(-i, el.ReadDataInt(0)); + } + var elx = ds.StructReadPointer(10); + Assert.AreEqual(ObjectKind.ListOfStructs, elx.Kind); + Assert.AreEqual(1, elx.ListElementCount); + var el0 = elx.RequireList().Cast(_ => _)[0]; + Assert.AreEqual(111, el0.ReadDataInt(0)); + + var e11 = ds.StructReadPointer(11); + Assert.AreEqual(ObjectKind.ListOfBits, e11.Kind); + Assert.AreEqual(7, e11.ListElementCount); + Assert.IsTrue(e11.RequireList().CastBool()[2]); + Assert.IsTrue(e11.RequireList().CastBool()[3]); + Assert.IsTrue(e11.RequireList().CastBool()[5]); + + var e12 = ds.StructReadPointer(12); + Assert.AreEqual(ObjectKind.ListOfBytes, e12.Kind); + Assert.AreEqual(5, e12.ListElementCount); + Assert.AreEqual((byte)0x55, e12.RequireList().CastByte()[1]); + Assert.AreEqual((byte)0xaa, e12.RequireList().CastByte()[2]); + + var e13 = ds.StructReadPointer(13); + Assert.AreEqual(ObjectKind.ListOfShorts, e13.Kind); + Assert.AreEqual(3, e13.ListElementCount); + Assert.AreEqual((ushort)0x1111, e13.RequireList().CastUShort()[0]); + Assert.AreEqual((ushort)0x2222, e13.RequireList().CastUShort()[1]); + Assert.AreEqual((ushort)0x3333, e13.RequireList().CastUShort()[2]); + + var e14 = ds.StructReadPointer(14); + Assert.AreEqual(ObjectKind.ListOfInts, e14.Kind); + Assert.AreEqual(9, e14.ListElementCount); + Assert.AreEqual((uint)0, e14.RequireList().CastUInt()[0]); + Assert.AreEqual((uint)1, e14.RequireList().CastUInt()[1]); + Assert.AreEqual((uint)4, e14.RequireList().CastUInt()[2]); + Assert.AreEqual((uint)9, e14.RequireList().CastUInt()[3]); + Assert.AreEqual((uint)16, e14.RequireList().CastUInt()[4]); + Assert.AreEqual((uint)25, e14.RequireList().CastUInt()[5]); + Assert.AreEqual((uint)36, e14.RequireList().CastUInt()[6]); + Assert.AreEqual((uint)49, e14.RequireList().CastUInt()[7]); + Assert.AreEqual((uint)64, e14.RequireList().CastUInt()[8]); + + var e15 = ds.StructReadPointer(15); + Assert.AreEqual(ObjectKind.ListOfLongs, e15.Kind); + Assert.AreEqual(2, e15.ListElementCount); + Assert.AreEqual(long.MinValue, e15.RequireList().CastLong()[0]); + Assert.AreEqual(long.MaxValue, e15.RequireList().CastLong()[1]); + + var e16 = ds.StructReadPointer(16); + Assert.AreEqual(ObjectKind.ListOfPointers, e16.Kind); + Assert.AreEqual(1, e16.ListElementCount); + var cap = e16.RequireList().Cast(_ => _)[0]; + Assert.AreEqual(ObjectKind.Capability, cap.Kind); + Assert.AreEqual(19u, cap.CapabilityIndex); + + var e17 = ds.StructReadPointer(17); + Assert.AreEqual(ObjectKind.ListOfEmpty, e17.Kind); + Assert.AreEqual(100, e17.ListElementCount); + } + + DeserializerState d = ds2; + Assert.AreEqual(ObjectKind.Struct, d.Kind); + var p0 = d.StructReadPointer(0); + VerifyBigStruct(p0); + var p1 = d.StructReadPointer(1); + Assert.AreEqual(ObjectKind.ListOfPointers, p1.Kind); + var p1el0 = p1.RequireList().Cast(_ => _)[0]; + VerifyBigStruct(p1el0); + var p2 = d.StructReadPointer(2); + Assert.AreEqual(ObjectKind.Struct, p2.Kind); + Assert.AreEqual(111, p2.ReadDataInt(0)); + } + + [TestMethod] + public void List2D() + { + var mb = MessageBuilder.Create(128); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int w = 4; + int h = 5; + ds.SetListOfPointers(w); + for (int i = 0; i < w; i++) + { + var p = ds.BuildPointer(i); + p.SetListOfValues(32, h); + for (int j = 0; j < h; j++) + { + p.ListWriteValue(j, i - j); + } + } + + DeserializerState d = ds; + var matrix = d.RequireList().Cast2D(); + Assert.AreEqual(matrix.Count, w); + for (int i = 0; i < w; i++) + { + var v = matrix[i]; + Assert.AreEqual(h, v.Count); + for (int j = 0; j < h; j++) + { + Assert.AreEqual(i - j, v[j]); + } + } + } + + [TestMethod] + public void List3D() + { + var mb = MessageBuilder.Create(128); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int d0 = 3; + int d1 = 2; + int d2 = 4; + ds.SetListOfPointers(d0); + for (int i = 0; i < d0; i++) + { + var p = ds.BuildPointer(i); + p.SetListOfPointers(d1); + for (int j = 0; j < d1; j++) + { + var q = p.BuildPointer(j); + q.SetListOfValues(32, d2); + for (int k = 0; k < d2; k++) + { + q.ListWriteValue(k, i ^ j ^ k); + } + } + } + + DeserializerState d = ds; + var qube = d.RequireList().Cast3D(); + Assert.AreEqual(qube.Count, d0); + for (int i = 0; i < d0; i++) + { + var matrix = qube[i]; + Assert.AreEqual(d1, matrix.Count); + for (int j = 0; j < d1; j++) + { + var vector = matrix[j]; + for (int k = 0; k < d2; k++) + { + Assert.AreEqual(i ^ j ^ k, vector[k]); + } + } + } + } + + [TestMethod] + public void List4D() + { + var mb = MessageBuilder.Create(128); + var alloc = mb.Allocator; + var ds = new DynamicSerializerState(mb); + int d0 = 3; + int d1 = 2; + int d2 = 4; + int d3 = 5; + ds.SetListOfPointers(d0); + for (int i = 0; i < d0; i++) + { + var p = ds.BuildPointer(i); + p.SetListOfPointers(d1); + for (int j = 0; j < d1; j++) + { + var q = p.BuildPointer(j); + q.SetListOfPointers(d2); + for (int k = 0; k < d2; k++) + { + var r = q.BuildPointer(k); + r.SetListOfValues(32, d3); + for (int l = 0; l < d3; l++) + { + r.ListWriteValue(l, (float)(i * j + k * l)); + } + } + } + } + + DeserializerState d = ds; + + var hqube = (IReadOnlyList) d.RequireList().CastND(4); + + Assert.AreEqual(hqube.Count, d0); + for (int i = 0; i < d0; i++) + { + var qube = (IReadOnlyList)hqube[i]; + Assert.AreEqual(d1, qube.Count); + for (int j = 0; j < d1; j++) + { + var matrix = (IReadOnlyList)qube[j]; + Assert.AreEqual(d2, matrix.Count); + for (int k = 0; k < d2; k++) + { + var vector = (IReadOnlyList)matrix[k]; + Assert.AreEqual(d3, vector.Count); + for (int l = 0; l < d3; l++) + { + Assert.AreEqual((float)(i * j + k * l), vector[l]); + } + } + } + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/FramePumpTests.cs b/Capnp.Net.Runtime.Tests/FramePumpTests.cs new file mode 100644 index 0000000..0f13efb --- /dev/null +++ b/Capnp.Net.Runtime.Tests/FramePumpTests.cs @@ -0,0 +1,184 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.IO; +using System.IO.Pipes; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class FramePumpTests + { + class MyStruct : SerializerState + { + public MyStruct() + { + SetStruct(0, 1); + } + } + + [TestMethod] + public void PipedFramePump() + { + int UnpackFrame(WireFrame frame) + { + int count = frame.Segments.Count; + + for (int i = 0; i < count; i++) + { + Assert.AreEqual(i + 1, frame.Segments[i].Length); + } + + return count; + } + + WireFrame PackFrame(int value) + { + var segments = new Memory[value]; + + for (int i = 0; i < value; i++) + { + ulong[] a = new ulong[i + 1]; + segments[i] = new Memory(a); + } + + return new WireFrame(segments); + } + + Thread rxRunner = null; + + using (var server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) + using (var client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle)) + using (var bc = new BlockingCollection(8)) + { + server.ReadMode = PipeTransmissionMode.Byte; + client.ReadMode = PipeTransmissionMode.Byte; + + using (var txPump = new FramePump(server)) + using (var rxPump = new FramePump(client)) + { + rxRunner = new Thread(() => + { + rxPump.Run(); + }); + + rxPump.FrameReceived += f => bc.Add(UnpackFrame(f)); + + rxRunner.Start(); + + for (int i = 0; i < 100; i++) + { + txPump.Send(PackFrame(1)); + txPump.Send(PackFrame(8)); + txPump.Send(PackFrame(2)); + txPump.Send(PackFrame(7)); + txPump.Send(PackFrame(3)); + txPump.Send(PackFrame(6)); + txPump.Send(PackFrame(4)); + txPump.Send(PackFrame(5)); + + Assert.IsTrue(SpinWait.SpinUntil(() => bc.Count == 8, 500)); + + Assert.AreEqual(1, bc.Take()); + Assert.AreEqual(8, bc.Take()); + Assert.AreEqual(2, bc.Take()); + Assert.AreEqual(7, bc.Take()); + Assert.AreEqual(3, bc.Take()); + Assert.AreEqual(6, bc.Take()); + Assert.AreEqual(4, bc.Take()); + Assert.AreEqual(5, bc.Take()); + } + } + } + + Assert.IsTrue(rxRunner.Join(500)); + } + + [TestMethod] + public void FramePumpDeferredProcessing() + { + int UnpackAndVerifyFrame(WireFrame frame, int expectedCount) + { + int count = frame.Segments.Count; + Assert.AreEqual(expectedCount, count); + + for (int i = 0; i < count; i++) + { + int length = frame.Segments[i].Length; + Assert.AreEqual(expectedCount - i, length); + for (int j = 0; j < length; j++) + { + Assert.AreEqual((ulong)(length - j), frame.Segments[i].Span[j]); + } + } + + return count; + } + + WireFrame PackFrame(int value) + { + var segments = new Memory[value]; + + for (int i = 0; i < value; i++) + { + ulong[] a = new ulong[value - i]; + segments[i] = new Memory(a); + for (int j = 0; j < a.Length; j++) + { + a[j] = (ulong)(a.Length - j); + } + } + + return new WireFrame(segments); + } + + Thread rxRunner = null; + + using (var server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) + using (var client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle)) + using (var bc = new BlockingCollection(8)) + { + server.ReadMode = PipeTransmissionMode.Byte; + client.ReadMode = PipeTransmissionMode.Byte; + + using (var txPump = new FramePump(server)) + using (var rxPump = new FramePump(client)) + { + rxRunner = new Thread(() => + { + rxPump.Run(); + }); + + rxPump.FrameReceived += bc.Add; + + rxRunner.Start(); + + txPump.Send(PackFrame(1)); + txPump.Send(PackFrame(8)); + txPump.Send(PackFrame(2)); + txPump.Send(PackFrame(7)); + txPump.Send(PackFrame(3)); + txPump.Send(PackFrame(6)); + txPump.Send(PackFrame(4)); + txPump.Send(PackFrame(5)); + + Assert.IsTrue(SpinWait.SpinUntil(() => bc.Count == 8, 500)); + + UnpackAndVerifyFrame(bc.Take(), 1); + UnpackAndVerifyFrame(bc.Take(), 8); + UnpackAndVerifyFrame(bc.Take(), 2); + UnpackAndVerifyFrame(bc.Take(), 7); + UnpackAndVerifyFrame(bc.Take(), 3); + UnpackAndVerifyFrame(bc.Take(), 6); + UnpackAndVerifyFrame(bc.Take(), 4); + UnpackAndVerifyFrame(bc.Take(), 5); + } + } + + Assert.IsTrue(rxRunner.Join(500)); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/General.cs b/Capnp.Net.Runtime.Tests/General.cs new file mode 100644 index 0000000..662b039 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/General.cs @@ -0,0 +1,71 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class General + { + [TestMethod] + public void AwaitOrderTest() + { + // This test verifies an execution order assumption about the .NET environment: + // When I register multiple continuations on the same Task, using the await + // keyword, I expect all continuations be executed in the same order they were + // registered. Despite I could not find any official statement on this behavior, + // the Capnp.Net.Runtime implementation relies on that assumption. Should that + // assumption turn out to be wrong, you might observe RPCs which are executed in + // a different order than they were requested. + + int returnCounter = 0; + + async Task ExpectCount(Task task, int count) + { + await task; + Assert.AreEqual(count, returnCounter++); + } + + var tcs = new TaskCompletionSource(); + + var tasks = + from i in Enumerable.Range(0, 100) + select ExpectCount(tcs.Task, i); + + tcs.SetResult(0); + + Task.WhenAll(tasks).Wait(); + } + + [TestMethod] + public void AwaitOrderTest2() + { + int returnCounter = 0; + + async Task ExpectCount(Task task, int count) + { + await task; + Assert.AreEqual(count, returnCounter++); + } + + var tcs = new TaskCompletionSource(); + var cts = new CancellationTokenSource(); + + var tasks = + from i in Enumerable.Range(0, 100) + select ExpectCount(tcs.Task.ContinueWith( + t => t, + cts.Token, + TaskContinuationOptions.ExecuteSynchronously, + TaskScheduler.Current), i); + + tcs.SetResult(0); + + Task.WhenAll(tasks).Wait(); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/JobUtil.cs b/Capnp.Net.Runtime.Tests/JobUtil.cs new file mode 100644 index 0000000..7e39155 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/JobUtil.cs @@ -0,0 +1,145 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; + +namespace Capnp.Net.Runtime.Tests +{ + public class Job : IDisposable + { + [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] + static extern IntPtr CreateJobObject(IntPtr a, string lpName); + + [DllImport("kernel32.dll")] + static extern bool SetInformationJobObject(IntPtr hJob, JobObjectInfoType infoType, IntPtr lpJobObjectInfo, UInt32 cbJobObjectInfoLength); + + [DllImport("kernel32.dll", SetLastError = true)] + static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process); + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + static extern bool CloseHandle(IntPtr hObject); + + private IntPtr handle; + private bool disposed; + + public Job() + { + handle = CreateJobObject(IntPtr.Zero, null); + + var info = new JOBOBJECT_BASIC_LIMIT_INFORMATION + { + LimitFlags = 0x2000 + }; + + var extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION + { + BasicLimitInformation = info + }; + + int length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION)); + IntPtr extendedInfoPtr = Marshal.AllocHGlobal(length); + Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false); + + if (!SetInformationJobObject(handle, JobObjectInfoType.ExtendedLimitInformation, extendedInfoPtr, (uint)length)) + throw new Exception(string.Format("Unable to set information. Error: {0}", Marshal.GetLastWin32Error())); + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (disposed) + return; + + if (disposing) { } + + Close(); + disposed = true; + } + + public void Close() + { + CloseHandle(handle); + handle = IntPtr.Zero; + } + + public bool AddProcess(IntPtr processHandle) + { + return AssignProcessToJobObject(handle, processHandle); + } + + public bool AddProcess(int processId) + { + return AddProcess(Process.GetProcessById(processId).Handle); + } + + } + + #region Helper classes + + [StructLayout(LayoutKind.Sequential)] + struct IO_COUNTERS + { + public UInt64 ReadOperationCount; + public UInt64 WriteOperationCount; + public UInt64 OtherOperationCount; + public UInt64 ReadTransferCount; + public UInt64 WriteTransferCount; + public UInt64 OtherTransferCount; + } + + + [StructLayout(LayoutKind.Sequential)] + struct JOBOBJECT_BASIC_LIMIT_INFORMATION + { + public Int64 PerProcessUserTimeLimit; + public Int64 PerJobUserTimeLimit; + public UInt32 LimitFlags; + public UIntPtr MinimumWorkingSetSize; + public UIntPtr MaximumWorkingSetSize; + public UInt32 ActiveProcessLimit; + public UIntPtr Affinity; + public UInt32 PriorityClass; + public UInt32 SchedulingClass; + } + + [StructLayout(LayoutKind.Sequential)] + public struct SECURITY_ATTRIBUTES + { + public UInt32 nLength; + public IntPtr lpSecurityDescriptor; + public Int32 bInheritHandle; + } + + [StructLayout(LayoutKind.Sequential)] + struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION + { + public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation; + public IO_COUNTERS IoInfo; + public UIntPtr ProcessMemoryLimit; + public UIntPtr JobMemoryLimit; + public UIntPtr PeakProcessMemoryUsed; + public UIntPtr PeakJobMemoryUsed; + } + + public enum JobObjectInfoType + { + AssociateCompletionPortInformation = 7, + BasicLimitInformation = 2, + BasicUIRestrictions = 4, + EndOfJobTimeInformation = 6, + ExtendedLimitInformation = 9, + SecurityLimitInformation = 5, + GroupInformation = 11 + } + + #endregion +} diff --git a/Capnp.Net.Runtime.Tests/MessageBuilderTests.cs b/Capnp.Net.Runtime.Tests/MessageBuilderTests.cs new file mode 100644 index 0000000..32196a6 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/MessageBuilderTests.cs @@ -0,0 +1,65 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class MessageBuilderTests + { + class Struct2D0P : SerializerState + { + public Struct2D0P() + { + SetStruct(2, 0); + } + } + + class Struct0D1P : SerializerState + { + public Struct0D1P() + { + SetStruct(0, 1); + } + } + + [TestMethod] + public void BuildDynamicMessage() + { + var mb = MessageBuilder.Create(128); + Assert.IsNull(mb.Root); + var root = mb.BuildRoot(); + Assert.IsNotNull(root); + Assert.AreSame(root, mb.Root); + root.WriteData(0, long.MinValue); + root.WriteData(64, long.MaxValue); + var frame = mb.Frame; + + var droot = DeserializerState.CreateRoot(frame); + Assert.AreEqual(ObjectKind.Struct, droot.Kind); + Assert.AreEqual(2, droot.StructDataCount); + Assert.AreEqual(long.MinValue, droot.ReadDataLong(0)); + Assert.AreEqual(long.MaxValue, droot.ReadDataLong(64)); + } + + [TestMethod] + public void SmallSegments() + { + WireFrame frame; + + for (int i = 1; i <= 8; i++) + { + { + var mb = MessageBuilder.Create(128); + var root = mb.BuildRoot(); + var p = root.BuildPointer(0); + p.SetListOfValues(64, i); + frame = mb.Frame; + } + + { + var root = DeserializerState.CreateRoot(frame); + Assert.AreEqual(i, root.StructReadPointer(0).ListElementCount); + } + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/ProvidedCapabilityMock.cs b/Capnp.Net.Runtime.Tests/ProvidedCapabilityMock.cs new file mode 100644 index 0000000..2e987f6 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/ProvidedCapabilityMock.cs @@ -0,0 +1,24 @@ +using System.Threading; +using System.Threading.Tasks; +using Capnp.Rpc; + +namespace Capnp.Net.Runtime.Tests +{ + class ProvidedCapabilityMock : Skeleton + { + readonly TaskCompletionSource<(ulong, ushort, DeserializerState, CancellationToken)> + _call = new TaskCompletionSource<(ulong, ushort, DeserializerState, CancellationToken)>(); + + public override Task Invoke(ulong interfaceId, ushort methodId, + DeserializerState args, CancellationToken cancellationToken = default(CancellationToken)) + { + _call.SetResult((interfaceId, methodId, args, cancellationToken)); + return Return.Task; + } + + public Task<(ulong, ushort, DeserializerState, CancellationToken)> WhenCalled => + _call.Task; + + public TaskCompletionSource Return { get; } = new TaskCompletionSource(); + } +} diff --git a/Capnp.Net.Runtime.Tests/ProvidedCapabilityMultiCallMock.cs b/Capnp.Net.Runtime.Tests/ProvidedCapabilityMultiCallMock.cs new file mode 100644 index 0000000..50cccae --- /dev/null +++ b/Capnp.Net.Runtime.Tests/ProvidedCapabilityMultiCallMock.cs @@ -0,0 +1,23 @@ +using System.Threading; +using System.Threading.Tasks; +using Capnp.Rpc; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading.Tasks.Dataflow; + +namespace Capnp.Net.Runtime.Tests +{ + class ProvidedCapabilityMultiCallMock : Skeleton + { + readonly BufferBlock _ccs = new BufferBlock(); + + public override Task Invoke(ulong interfaceId, ushort methodId, + DeserializerState args, CancellationToken cancellationToken = default(CancellationToken)) + { + var cc = new CallContext(interfaceId, methodId, args, cancellationToken); + Assert.IsTrue(_ccs.Post(cc)); + return cc.Result.Task; + } + + public Task WhenCalled => _ccs.ReceiveAsync(); + } +} diff --git a/Capnp.Net.Runtime.Tests/RpcSchemaTests.cs b/Capnp.Net.Runtime.Tests/RpcSchemaTests.cs new file mode 100644 index 0000000..8032cc3 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/RpcSchemaTests.cs @@ -0,0 +1,369 @@ +using Capnp.Rpc; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class RpcSchemaTests + { + [TestMethod] + public void MessageAbort() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Abort; + Assert.AreEqual(Message.WHICH.Abort, w.which); + w.Abort.Reason = "reason"; + Assert.AreEqual("reason", w.Abort.Reason); + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + Assert.AreEqual(Message.WHICH.Abort, r.which); + Assert.AreEqual("reason", r.Abort.Reason); + } + + [TestMethod] + public void MessageAccept() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Accept; + Assert.AreEqual(Message.WHICH.Accept, w.which); + w.Accept.Embargo = true; + Assert.IsTrue(w.Accept.Embargo); + w.Accept.Provision.SetStruct(2, 0); + w.Accept.Provision.WriteData(0, long.MinValue); + w.Accept.Provision.WriteData(64, long.MaxValue); + Assert.AreEqual(long.MinValue, w.Accept.Provision.ReadDataLong(0)); + Assert.AreEqual(long.MaxValue, w.Accept.Provision.ReadDataLong(64)); + w.Accept.QuestionId = 0x87654321u; + Assert.AreEqual(0x87654321u, w.Accept.QuestionId); + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + Assert.AreEqual(Message.WHICH.Accept, r.which); + Assert.IsTrue(r.Accept.Embargo); + Assert.AreEqual(ObjectKind.Struct, r.Accept.Provision.Kind); + Assert.AreEqual(long.MinValue, r.Accept.Provision.ReadDataLong(0)); + Assert.AreEqual(long.MaxValue, r.Accept.Provision.ReadDataLong(64)); + Assert.AreEqual(0x87654321u, r.Accept.QuestionId); + } + + [TestMethod] + public void MessageBootstrap() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Bootstrap; + Assert.AreEqual(Message.WHICH.Bootstrap, w.which); + w.Bootstrap.QuestionId = 0xaa55aa55u; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + Assert.AreEqual(Message.WHICH.Bootstrap, r.which); + Assert.AreEqual(0xaa55aa55u, r.Bootstrap.QuestionId); + } + + [TestMethod] + public void MessageCall() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Call; + Assert.AreEqual(Message.WHICH.Call, w.which); + w.Call.AllowThirdPartyTailCall = true; + w.Call.InterfaceId = ulong.MaxValue; + w.Call.MethodId = 0x1111; + w.Call.Params.CapTable.Init(6); + w.Call.Params.CapTable[0].which = CapDescriptor.WHICH.None; + w.Call.Params.CapTable[1].which = CapDescriptor.WHICH.ReceiverAnswer; + w.Call.Params.CapTable[1].ReceiverAnswer.QuestionId = 0x12345678u; + w.Call.Params.CapTable[1].ReceiverAnswer.Transform.Init(2); + w.Call.Params.CapTable[1].ReceiverAnswer.Transform[0].which = PromisedAnswer.Op.WHICH.GetPointerField; + w.Call.Params.CapTable[1].ReceiverAnswer.Transform[0].GetPointerField = 0x2222; + w.Call.Params.CapTable[1].ReceiverAnswer.Transform[1].which = PromisedAnswer.Op.WHICH.Noop; + w.Call.Params.CapTable[2].which = CapDescriptor.WHICH.ReceiverHosted; + w.Call.Params.CapTable[2].ReceiverHosted = 12345678u; + w.Call.Params.CapTable[3].which = CapDescriptor.WHICH.SenderHosted; + w.Call.Params.CapTable[3].SenderHosted = 23456789u; + w.Call.Params.CapTable[4].which = CapDescriptor.WHICH.SenderPromise; + w.Call.Params.CapTable[4].SenderPromise = 34567890u; + w.Call.Params.CapTable[5].which = CapDescriptor.WHICH.ThirdPartyHosted; + w.Call.Params.CapTable[5].ThirdPartyHosted.Id.SetStruct(1, 0); + w.Call.Params.CapTable[5].ThirdPartyHosted.Id.WriteData(0, double.Epsilon); + w.Call.Params.CapTable[5].ThirdPartyHosted.VineId = 111111u; + + Assert.AreEqual(CapDescriptor.WHICH.None, w.Call.Params.CapTable[0].which); + Assert.AreEqual(CapDescriptor.WHICH.ReceiverAnswer, w.Call.Params.CapTable[1].which); + Assert.AreEqual(CapDescriptor.WHICH.ReceiverHosted, w.Call.Params.CapTable[2].which); + Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, w.Call.Params.CapTable[3].which); + Assert.AreEqual(CapDescriptor.WHICH.SenderPromise, w.Call.Params.CapTable[4].which); + Assert.AreEqual(CapDescriptor.WHICH.ThirdPartyHosted, w.Call.Params.CapTable[5].which); + + var content = w.Call.Params.Content.Rewrap(); + content.SetStruct(1, 0); + content.WriteData(0, double.PositiveInfinity); + w.Call.QuestionId = 0x77777777u; + w.Call.SendResultsTo.which = Call.sendResultsTo.WHICH.ThirdParty; + w.Call.SendResultsTo.ThirdParty.SetStruct(1, 0); + w.Call.SendResultsTo.ThirdParty.WriteData(0, double.NegativeInfinity); + w.Call.Target.which = MessageTarget.WHICH.PromisedAnswer; + w.Call.Target.PromisedAnswer.QuestionId = 5555555u; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + Assert.AreEqual(Message.WHICH.Call, r.which); + Assert.IsTrue(r.Call.AllowThirdPartyTailCall); + Assert.AreEqual(ulong.MaxValue, r.Call.InterfaceId); + Assert.AreEqual((ushort)0x1111, r.Call.MethodId); + var capTable = r.Call.Params.CapTable; + Assert.AreEqual(6, capTable.Count); + Assert.AreEqual(CapDescriptor.WHICH.None, capTable[0].which); + Assert.AreEqual(CapDescriptor.WHICH.ReceiverAnswer, capTable[1].which); + Assert.AreEqual(0x12345678u, capTable[1].ReceiverAnswer.QuestionId); + var transform = capTable[1].ReceiverAnswer.Transform; + Assert.AreEqual(2, transform.Count); + Assert.AreEqual(PromisedAnswer.Op.WHICH.GetPointerField, transform[0].which); + Assert.AreEqual((ushort)0x2222, transform[0].GetPointerField); + Assert.AreEqual(PromisedAnswer.Op.WHICH.Noop, transform[1].which); + Assert.AreEqual(CapDescriptor.WHICH.ReceiverHosted, capTable[2].which); + Assert.AreEqual(12345678u, capTable[2].ReceiverHosted); + Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, capTable[3].which); + Assert.AreEqual(23456789u, capTable[3].SenderHosted); + Assert.AreEqual(CapDescriptor.WHICH.SenderPromise, capTable[4].which); + Assert.AreEqual(34567890u, capTable[4].SenderPromise); + Assert.AreEqual(CapDescriptor.WHICH.ThirdPartyHosted, capTable[5].which); + var tph = capTable[5].ThirdPartyHosted; + Assert.AreEqual(ObjectKind.Struct, tph.Id.Kind); + Assert.AreEqual(double.Epsilon, tph.Id.ReadDataDouble(0)); + Assert.AreEqual(111111u, tph.VineId); + Assert.AreEqual(ObjectKind.Struct, r.Call.Params.Content.Kind); + Assert.AreEqual(double.PositiveInfinity, r.Call.Params.Content.ReadDataDouble(0)); + Assert.AreEqual(0x77777777u, r.Call.QuestionId); + var srt = r.Call.SendResultsTo; + Assert.AreEqual(Call.sendResultsTo.WHICH.ThirdParty, srt.which); + Assert.AreEqual(ObjectKind.Struct, srt.ThirdParty.Kind); + Assert.AreEqual(double.NegativeInfinity, srt.ThirdParty.ReadDataDouble(0)); + Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Call.Target.which); + Assert.AreEqual(5555555u, r.Call.Target.PromisedAnswer.QuestionId); + } + + [TestMethod] + public void MessageDisembargo() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Disembargo; + + var ctx = w.Disembargo.Context; + ctx.which = Disembargo.context.WHICH.SenderLoopback; + ctx.SenderLoopback = 1234567u; + var tgt = w.Disembargo.Target; + tgt.which = MessageTarget.WHICH.PromisedAnswer; + tgt.PromisedAnswer.QuestionId = 7654321u; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + { + Assert.AreEqual(Message.WHICH.Disembargo, r.which); + Assert.AreEqual(Disembargo.context.WHICH.SenderLoopback, r.Disembargo.Context.which); + Assert.AreEqual(1234567u, r.Disembargo.Context.SenderLoopback); + Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Disembargo.Target.which); + Assert.AreEqual(7654321u, r.Disembargo.Target.PromisedAnswer.QuestionId); + } + } + + [TestMethod] + public void MessageFinish() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Finish; + + w.Finish.QuestionId = 0xaaaaaaaa; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Finish, r.which); + Assert.AreEqual(0xaaaaaaaa, r.Finish.QuestionId); + } + } + + [TestMethod] + public void MessageJoin() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Join; + w.Join.KeyPart.SetStruct(2, 0); + w.Join.KeyPart.WriteData(0, long.MinValue); + w.Join.KeyPart.WriteData(64, long.MaxValue); + w.Join.QuestionId = 0x88888888; + w.Join.Target.which = MessageTarget.WHICH.ImportedCap; + w.Join.Target.ImportedCap = 0x99999999; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Join, r.which); + Assert.AreEqual(ObjectKind.Struct, r.Join.KeyPart.Kind); + Assert.AreEqual(long.MinValue, r.Join.KeyPart.ReadDataLong(0)); + Assert.AreEqual(long.MaxValue, r.Join.KeyPart.ReadDataLong(64)); + Assert.AreEqual(0x88888888, r.Join.QuestionId); + Assert.AreEqual(MessageTarget.WHICH.ImportedCap, r.Join.Target.which); + Assert.AreEqual(0x99999999, r.Join.Target.ImportedCap); + } + } + + [TestMethod] + public void MessageProvide() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Provide; + w.Provide.QuestionId = 0xbbbbbbbb; + w.Provide.Recipient.SetStruct(1, 0); + w.Provide.Recipient.WriteData(0, -1); + w.Provide.Target.which = MessageTarget.WHICH.PromisedAnswer; + w.Provide.Target.PromisedAnswer.QuestionId = 0xcccccccc; + w.Provide.Target.PromisedAnswer.Transform.Init(1); + w.Provide.Target.PromisedAnswer.Transform[0].which = PromisedAnswer.Op.WHICH.Noop; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Provide, r.which); + Assert.AreEqual(0xbbbbbbbb, r.Provide.QuestionId); + Assert.AreEqual(-1, r.Provide.Recipient.ReadDataInt(0)); + Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Provide.Target.which); + Assert.AreEqual(0xcccccccc, r.Provide.Target.PromisedAnswer.QuestionId); + Assert.AreEqual(1, r.Provide.Target.PromisedAnswer.Transform.Count); + Assert.AreEqual(PromisedAnswer.Op.WHICH.Noop, r.Provide.Target.PromisedAnswer.Transform[0].which); + } + } + + [TestMethod] + public void MessageRelease() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Release; + w.Release.Id = 0xdddddddd; + w.Release.ReferenceCount = 27; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Release, r.which); + Assert.AreEqual(0xdddddddd, r.Release.Id); + Assert.AreEqual(27u, r.Release.ReferenceCount); + } + } + + [TestMethod] + public void MessageResolve() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Resolve; + w.Resolve.which = Resolve.WHICH.Cap; + w.Resolve.Cap.which = CapDescriptor.WHICH.SenderHosted; + w.Resolve.Cap.SenderHosted = 0xeeeeeeee; + w.Resolve.PromiseId = 0x11111111; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Resolve, r.which); + Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, r.Resolve.Cap.which); + Assert.AreEqual(0xeeeeeeee, r.Resolve.Cap.SenderHosted); + Assert.AreEqual(0x11111111u, r.Resolve.PromiseId); + } + } + + [TestMethod] + public void MessageReturn() + { + var mb = MessageBuilder.Create(); + + { + var w = mb.BuildRoot(); + w.which = Message.WHICH.Return; + w.Return.which = Return.WHICH.Results; + w.Return.Results.CapTable.Init(1); + w.Return.Results.CapTable[0].which = CapDescriptor.WHICH.SenderHosted; + w.Return.Results.CapTable[0].SenderHosted = 0x22222222; + var content = w.Return.Results.Content.Rewrap(); + content.SetStruct(2, 0); + content.WriteData(0, double.MinValue); + content.WriteData(64, double.MaxValue); + Assert.IsTrue(w.Return.ReleaseParamCaps); + w.Return.ReleaseParamCaps = false; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Return, r.which); + Assert.AreEqual(Return.WHICH.Results, r.Return.which); + Assert.AreEqual(1, r.Return.Results.CapTable.Count); + Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, r.Return.Results.CapTable[0].which); + Assert.AreEqual(0x22222222u, r.Return.Results.CapTable[0].SenderHosted); + Assert.AreEqual(double.MinValue, r.Return.Results.Content.ReadDataDouble(0)); + Assert.AreEqual(double.MaxValue, + r.Return.Results.Content.ReadDataDouble(64)); + Assert.IsFalse(r.Return.ReleaseParamCaps); + } + } + + [TestMethod] + public void MessageUnimplemented() + { + var mb = MessageBuilder.Create(); + + { + var u = mb.BuildRoot(); + u.which = Message.WHICH.Unimplemented; + var w = u.Unimplemented; + w.which = Message.WHICH.Resolve; + w.Resolve.which = Resolve.WHICH.Exception; + w.Resolve.Exception.Reason = "reason"; + } + + var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); + + { + Assert.AreEqual(Message.WHICH.Unimplemented, r.which); + Assert.AreEqual(Message.WHICH.Resolve, r.Unimplemented.which); + Assert.AreEqual(Resolve.WHICH.Exception, r.Unimplemented.Resolve.which); + Assert.AreEqual("reason", r.Unimplemented.Resolve.Exception.Reason); + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/SegmentAllocatorTests.cs b/Capnp.Net.Runtime.Tests/SegmentAllocatorTests.cs new file mode 100644 index 0000000..7506f08 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/SegmentAllocatorTests.cs @@ -0,0 +1,41 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class SegmentAllocatorTests + { + [TestMethod] + public void BasicSegmentAllocator() + { + var alloc = new SegmentAllocator(128); + + Assert.IsTrue(alloc.Allocate(1, 0, out var slice1, false)); + Assert.AreEqual(0u, slice1.SegmentIndex); + Assert.AreEqual(0, slice1.Offset); + + Assert.IsTrue(alloc.Allocate(1, 1, out var slice2, false)); + Assert.AreEqual(0u, slice2.SegmentIndex); + Assert.AreEqual(1, slice2.Offset); + + Assert.IsTrue(alloc.Allocate(127, 0, out var slice3, false)); + Assert.AreEqual(1u, slice3.SegmentIndex); + Assert.AreEqual(0, slice3.Offset); + + Assert.IsFalse(alloc.Allocate(127, 0, out var slice4, true)); + Assert.IsFalse(alloc.Allocate(127, 1, out var slice5, true)); + + Assert.IsTrue(alloc.Allocate(2, 0, out var slice6, true)); + Assert.AreEqual(0u, slice6.SegmentIndex); + Assert.AreEqual(2, slice6.Offset); + + Assert.IsTrue(alloc.Allocate(1, 1, out var slice7, true)); + Assert.AreEqual(1u, slice7.SegmentIndex); + Assert.AreEqual(127, slice7.Offset); + + Assert.IsTrue(alloc.Allocate(129, 0, out var slice8, false)); + Assert.AreEqual(2u, slice8.SegmentIndex); + Assert.AreEqual(0, slice8.Offset); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TcpRpc.cs b/Capnp.Net.Runtime.Tests/TcpRpc.cs new file mode 100644 index 0000000..63b2fae --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TcpRpc.cs @@ -0,0 +1,697 @@ +using System.Net; +using System.Net.Sockets; +using System.Threading; +using System.Threading.Tasks; +using Capnp.Rpc; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.Extensions.Logging; +using System.Diagnostics; + +namespace Capnp.Net.Runtime.Tests +{ + + [TestClass] + public class TcpRpc + { + public static int TcpPort = 33444; + + (TcpRpcServer, TcpRpcClient) SetupClientServerPair() + { + var server = new TcpRpcServer(IPAddress.Any, TcpPort); + var client = new TcpRpcClient("localhost", TcpPort); + return (server, client); + } + + bool ExpectingLogOutput { get; set; } + + [TestInitialize] + public void InitConsoleLogging() + { + ExpectingLogOutput = true; + + Logging.LoggerFactory = new LoggerFactory().AddConsole((msg, level) => + { + if (!ExpectingLogOutput && level != LogLevel.Debug) + { + Assert.Fail("Did not expect any logging output, but got this: " + msg); + } + return true; + }); + } + + int MediumTimeout => Debugger.IsAttached ? Timeout.Infinite : 2000; + + [TestMethod] + public void CreateAndDispose() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + } + } + + [TestMethod] + public void ConnectAndDispose() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + } + } + + [TestMethod] + public void ConnectNoServer() + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(Assert.ThrowsExceptionAsync(() => client.WhenConnected).Wait(10000)); + } + } + + [TestMethod] + public void ConnectAndBootstrap() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + server.Main = new ProvidedCapabilityMock(); + var main = client.GetMain(); + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumTimeout)); + } + } + + [TestMethod] + public void ConnectNoBootstrap() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var main = client.GetMain(); + var resolving = main as IResolvingCapability; + Assert.IsTrue(Assert.ThrowsExceptionAsync(() => resolving.WhenResolved).Wait(MediumTimeout)); + } + } + + [TestMethod] + public void CallReturn() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, false)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + var result = DynamicSerializerState.CreateForRpc(); + result.SetStruct(1, 0); + result.WriteData(0, 654321); + mock.Return.SetResult(result); + + Assert.IsTrue(answer.WhenReturned.Wait(MediumTimeout)); + var outresult = answer.WhenReturned.Result; + Assert.AreEqual(ObjectKind.Struct, outresult.Kind); + Assert.AreEqual(654321, outresult.ReadDataInt(0)); + } + } + } + + [TestMethod] + public void CallCancelOnServer() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, false)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + mock.Return.SetCanceled(); + + Assert.IsTrue(Assert.ThrowsExceptionAsync(() => answer.WhenReturned).Wait(MediumTimeout)); + } + } + } + + [TestMethod] + public void CallCancelOnClient() + { + ExpectingLogOutput = false; + + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + try + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + CancellationToken ctx; + using (var answer = main.Call(0x1234567812345678, 0x3333, args, false)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + ctx = ct; + } + + Assert.IsTrue(SpinWait.SpinUntil(() => ctx.IsCancellationRequested, MediumTimeout)); + } + finally + { + ExpectingLogOutput = true; + } + } + } + + [TestMethod] + public void CallReturnAfterClientSideCancel() + { + ExpectingLogOutput = false; + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + try + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + CancellationToken ctx; + IPromisedAnswer answer; + using (answer = main.Call(0x1234567812345678, 0x3333, args, false)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + ctx = ct; + } + + Assert.IsTrue(SpinWait.SpinUntil(() => ctx.IsCancellationRequested, MediumTimeout)); + + var mbr = MessageBuilder.Create(); + mbr.InitCapTable(); + var result = new DynamicSerializerState(mbr); + result.SetStruct(1, 0); + result.WriteData(0, 654321); + mock.Return.SetResult(result); + + // Even after the client cancelled the call, the server must still send + // a response. + Assert.IsTrue(answer.WhenReturned.ContinueWith(t => { }).Wait(MediumTimeout)); + } + finally + { + ExpectingLogOutput = true; + } + } + } + + class MyTestException: System.Exception + { + public MyTestException(): base("Test exception") + { + } + } + + [TestMethod] + public void CallServerSideException() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, false)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + mock.Return.SetException(new MyTestException()); + + var exTask = Assert.ThrowsExceptionAsync(() => answer.WhenReturned); + Assert.IsTrue(exTask.Wait(MediumTimeout)); + Assert.IsTrue(exTask.Result.Message.Contains(new MyTestException().Message)); + } + } + } + + [TestMethod] + public void PipelineBeforeReturn() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, true)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + + var pipelined = (BareProxy)CapabilityReflection.CreateProxy(answer.Access( + new MemberAccessPath(new MemberAccessPath.MemberAccess[] { new MemberAccessPath.StructMemberAccess(1) }))); + + var args2 = DynamicSerializerState.CreateForRpc(); + args2.SetStruct(1, 0); + args2.WriteData(0, 654321); + + using (var answer2 = pipelined.Call(0x8765432187654321, 0x4444, args2, false)) + { + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + var mock2 = new ProvidedCapabilityMock(); + + var result = DynamicSerializerState.CreateForRpc(); + result.SetStruct(1, 2); + result.WriteData(0, 654321); + uint id = result.ProvideCapability(mock2); + result.LinkToCapability(1, id); + + mock.Return.SetResult(result); + + Assert.IsTrue(answer.WhenReturned.Wait(MediumTimeout)); + Assert.IsFalse(ct.IsCancellationRequested); + + Assert.IsTrue(mock2.WhenCalled.Wait(MediumTimeout)); + + (var interfaceId2, var methodId2, var inargs2, var ct2) = mock2.WhenCalled.Result; + Assert.AreEqual(0x8765432187654321, interfaceId2); + Assert.AreEqual(0x4444, methodId2); + Assert.AreEqual(ObjectKind.Struct, inargs2.Kind); + Assert.AreEqual(654321, inargs2.ReadDataInt(0)); + + var result2 = DynamicSerializerState.CreateForRpc(); + result2.SetStruct(1, 0); + result2.WriteData(0, 222222); + mock2.Return.SetResult(result2); + + Assert.IsTrue(answer2.WhenReturned.Wait(MediumTimeout)); + var outresult2 = answer2.WhenReturned.Result; + Assert.AreEqual(ObjectKind.Struct, outresult2.Kind); + Assert.AreEqual(222222, outresult2.ReadDataInt(0)); + } + } + } + } + + [TestMethod] + public void PipelineAfterReturn() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, true)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + var mock2 = new ProvidedCapabilityMock(); + + var result = DynamicSerializerState.CreateForRpc(); + result.SetStruct(1, 2); + result.WriteData(0, 654321); + uint id = result.ProvideCapability(mock2); + result.LinkToCapability(1, id); + + mock.Return.SetResult(result); + + using (var pipelined = (BareProxy)CapabilityReflection.CreateProxy( + answer.Access( + new MemberAccessPath( + new MemberAccessPath.MemberAccess[] { + new MemberAccessPath.StructMemberAccess(1) })))) + { + var args2 = DynamicSerializerState.CreateForRpc(); + args2.SetStruct(1, 0); + args2.WriteData(0, 654321); + + using (var answer2 = pipelined.Call(0x8765432187654321, 0x4444, args2, false)) + { + Assert.IsTrue(answer.WhenReturned.Wait(MediumTimeout)); + Assert.IsTrue(mock2.WhenCalled.Wait(MediumTimeout)); + + (var interfaceId2, var methodId2, var inargs2, var ct2) = mock2.WhenCalled.Result; + Assert.AreEqual(0x8765432187654321, interfaceId2); + Assert.AreEqual(0x4444, methodId2); + Assert.AreEqual(ObjectKind.Struct, inargs2.Kind); + Assert.AreEqual(654321, inargs2.ReadDataInt(0)); + + var result2 = DynamicSerializerState.CreateForRpc(); + result2.SetStruct(1, 0); + result2.WriteData(0, 222222); + mock2.Return.SetResult(result2); + + Assert.IsTrue(answer2.WhenReturned.Wait(MediumTimeout)); + var outresult2 = answer2.WhenReturned.Result; + Assert.AreEqual(ObjectKind.Struct, outresult2.Kind); + Assert.AreEqual(222222, outresult2.ReadDataInt(0)); + } + } + + } + } + } + + [TestMethod] + public void PipelineMultiple() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + using (var answer = main.Call(0x1234567812345678, 0x3333, args, true)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + + var pipelined = (BareProxy)CapabilityReflection.CreateProxy(answer.Access(new MemberAccessPath(new MemberAccessPath.MemberAccess[] { new MemberAccessPath.StructMemberAccess(1) }))); + + var args2 = DynamicSerializerState.CreateForRpc(); + args2.SetStruct(1, 0); + args2.WriteData(0, 111111); + + var args3 = DynamicSerializerState.CreateForRpc(); + args3.SetStruct(1, 0); + args3.WriteData(0, 222222); + + using (var answer2 = pipelined.Call(0x1111111111111111, 0x1111, args2, false)) + using (var answer3 = pipelined.Call(0x2222222222222222, 0x2222, args3, false)) + { + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + + Assert.AreEqual(0x1234567812345678, interfaceId); + Assert.AreEqual(0x3333, methodId); + Assert.AreEqual(ObjectKind.Struct, inargs.Kind); + Assert.AreEqual(123456, inargs.ReadDataInt(0)); + + var mock2 = new ProvidedCapabilityMultiCallMock(); + + var result = DynamicSerializerState.CreateForRpc(); + result.SetStruct(1, 2); + result.WriteData(0, 654321); + uint id = result.ProvideCapability(mock2); + result.LinkToCapability(1, id); + + mock.Return.SetResult(result); + + Assert.IsTrue(answer.WhenReturned.Wait(MediumTimeout)); + Assert.IsFalse(ct.IsCancellationRequested); + + var args4 = DynamicSerializerState.CreateForRpc(); + args4.SetStruct(1, 0); + args4.WriteData(0, 333333); + + var args5 = DynamicSerializerState.CreateForRpc(); + args5.SetStruct(1, 0); + args5.WriteData(0, 444444); + + using (var answer4 = pipelined.Call(0x3333333333333333, 0x3333, args4, false)) + using (var answer5 = pipelined.Call(0x4444444444444444, 0x4444, args5, false)) + { + var call2 = mock2.WhenCalled; + var call3 = mock2.WhenCalled; + var call4 = mock2.WhenCalled; + var call5 = mock2.WhenCalled; + + Assert.IsTrue(call2.Wait(MediumTimeout)); + Assert.IsTrue(call3.Wait(MediumTimeout)); + Assert.IsTrue(call4.Wait(MediumTimeout)); + Assert.IsTrue(call5.Wait(MediumTimeout)); + + Assert.AreEqual(0x1111111111111111, call2.Result.InterfaceId); + Assert.AreEqual(0x2222222222222222, call3.Result.InterfaceId); + Assert.AreEqual(0x3333333333333333, call4.Result.InterfaceId); + Assert.AreEqual(0x4444444444444444, call5.Result.InterfaceId); + + var ret2 = DynamicSerializerState.CreateForRpc(); + ret2.SetStruct(1, 0); + ret2.WriteData(0, -1); + call2.Result.Result.SetResult(ret2); + + var ret3 = DynamicSerializerState.CreateForRpc(); + ret3.SetStruct(1, 0); + ret3.WriteData(0, -2); + call3.Result.Result.SetResult(ret3); + + var ret4 = DynamicSerializerState.CreateForRpc(); + ret4.SetStruct(1, 0); + ret4.WriteData(0, -3); + call4.Result.Result.SetResult(ret4); + + var ret5 = DynamicSerializerState.CreateForRpc(); + ret5.SetStruct(1, 0); + ret5.WriteData(0, -4); + call5.Result.Result.SetResult(ret5); + + Assert.IsTrue(answer2.WhenReturned.Wait(MediumTimeout)); + Assert.IsTrue(answer3.WhenReturned.Wait(MediumTimeout)); + Assert.IsTrue(answer4.WhenReturned.Wait(MediumTimeout)); + Assert.IsTrue(answer5.WhenReturned.Wait(MediumTimeout)); + + Assert.AreEqual(-1, answer2.WhenReturned.Result.ReadDataInt(0)); + Assert.AreEqual(-2, answer3.WhenReturned.Result.ReadDataInt(0)); + Assert.AreEqual(-3, answer4.WhenReturned.Result.ReadDataInt(0)); + Assert.AreEqual(-4, answer5.WhenReturned.Result.ReadDataInt(0)); + } + } + } + } + } + + [TestMethod] + public void PipelineCallAfterDisposal() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + BareProxy pipelined; + using (var answer = main.Call(0x1234567812345678, 0x3333, args, true)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + + pipelined = (BareProxy)CapabilityReflection.CreateProxy( + answer.Access(new MemberAccessPath(new MemberAccessPath.MemberAccess[] { new MemberAccessPath.StructMemberAccess(1) }))); + + } + + var args2 = DynamicSerializerState.CreateForRpc(); + args2.SetStruct(1, 0); + args2.WriteData(0, 654321); + + Assert.ThrowsException(() => pipelined.Call(0x8765432187654321, 0x4444, args2, false)); + } + } + + [TestMethod] + public void PipelineCallDuringDisposal() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumTimeout)); + SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumTimeout); + Assert.AreEqual(1, server.ConnectionCount); + + var mock = new ProvidedCapabilityMock(); + server.Main = mock; + var main = client.GetMain(); + Assert.IsTrue(main.WhenResolved.Wait(MediumTimeout)); + var args = DynamicSerializerState.CreateForRpc(); + args.SetStruct(1, 0); + args.WriteData(0, 123456); + IPromisedAnswer answer2; + using (var answer = main.Call(0x1234567812345678, 0x3333, args, true)) + { + Assert.IsTrue(mock.WhenCalled.Wait(MediumTimeout)); + + var pipelined = (BareProxy)CapabilityReflection.CreateProxy(answer.Access(new MemberAccessPath(new MemberAccessPath.MemberAccess[] { new MemberAccessPath.StructMemberAccess(1) }))); + + var args2 = DynamicSerializerState.CreateForRpc(); + args2.SetStruct(1, 0); + args2.WriteData(0, 654321); + + answer2 = pipelined.Call(0x8765432187654321, 0x4444, args2, false); + } + + using (answer2) + { + (var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result; + + var tcs = new TaskCompletionSource(); + using (ct.Register(() => tcs.SetResult(0))) + { + Assert.IsTrue(tcs.Task.Wait(MediumTimeout)); + } + + var mock2 = new ProvidedCapabilityMock(); + + var result = DynamicSerializerState.CreateForRpc(); + result.SetStruct(1, 2); + result.WriteData(0, 654321); + uint id = result.ProvideCapability(mock2); + result.LinkToCapability(1, id); + + mock.Return.SetResult(result); + + Assert.IsTrue(Assert.ThrowsExceptionAsync( + () => answer2.WhenReturned).Wait(MediumTimeout)); + } + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TcpRpcAdvancedStuff.cs b/Capnp.Net.Runtime.Tests/TcpRpcAdvancedStuff.cs new file mode 100644 index 0000000..9a7b6a6 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TcpRpcAdvancedStuff.cs @@ -0,0 +1,92 @@ +using Capnp.Net.Runtime.Tests.GenImpls; +using Capnp.Rpc; +using Capnproto_test.Capnp.Test; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class TcpRpcAdvancedStuff: TestBase + { + [TestMethod] + public void MultiConnect() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + var tcs = new TaskCompletionSource(); + server.Main = new TestInterfaceImpl(counters, tcs); + + for (int i = 1; i <= 10; i++) + { + using (var client = SetupClient()) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var request1 = main.Foo(123, true, default); + var request3 = Assert.ThrowsExceptionAsync(() => main.Bar(default)); + var s = new TestAllTypes(); + Common.InitTestMessage(s); + var request2 = main.Baz(s, default); + + Assert.IsTrue(request1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request2.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request3.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("foo", request1.Result); + Assert.AreEqual(2 * i, counters.CallCount); + } + } + + // Bootstrap capability must not be disposed + Assert.IsFalse(tcs.Task.IsCompleted); + } + } + } + + [TestMethod] + public void TwoClients() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + using (var client1 = SetupClient()) + using (var client2 = SetupClient()) + { + Assert.IsTrue(client1.WhenConnected.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(client2.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client1.GetMain()) + { + Assert.IsTrue(main.Hold(new TestInterfaceImpl(counters)).Wait(MediumNonDbgTimeout)); + } + + using (var main = client2.GetMain()) + { + Assert.IsTrue(main.CallHeld().Wait(MediumNonDbgTimeout)); + var getHeld = main.GetHeld(); + Assert.IsTrue(getHeld.Wait(MediumNonDbgTimeout)); + var foo = getHeld.Result.Foo(123, true); + Assert.IsTrue(foo.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("foo", foo.Result); + } + + client1.Dispose(); + + using (var main = client2.GetMain()) + { + ExpectPromiseThrows(main.CallHeld()); + } + } + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TcpRpcInterop.cs b/Capnp.Net.Runtime.Tests/TcpRpcInterop.cs new file mode 100644 index 0000000..8b20837 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TcpRpcInterop.cs @@ -0,0 +1,1028 @@ +using Capnp.Net.Runtime.Tests.GenImpls; +using Capnp.Rpc; +using Capnproto_test.Capnp.Test; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.IO; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class TcpRpcInterop: TestBase + { + Process StartProcess(ProcessStartInfo processStartInfo) + { + try + { + return Process.Start(processStartInfo); + } + catch (Win32Exception exception) when (exception.ErrorCode == 2 || exception.ErrorCode == 3) + { + Assert.Fail($"Did not find test executable {processStartInfo.FileName}. Did you build CapnpCompatTest.sln in Release configuration?"); + } + catch (System.Exception exception) + { + Assert.Fail($"Could not execute {processStartInfo.FileName}: {exception.Message}"); + } + return null; + } + + Process _currentProcess; + + void LaunchCompatTestProcess(string whichTest, Action test) + { + string myPath = Path.GetDirectoryName(typeof(TcpRpcInterop).Assembly.Location); + string config; +#if DEBUG + config = "Debug"; +#else + config = "Release"; +#endif + string path = Path.Combine(myPath, $@"..\..\..\..\{config}\CapnpCompatTest.exe"); + path = Path.GetFullPath(path); + string arguments = $"{whichTest} 127.0.0.1:{TcpPort}"; + var startInfo = new ProcessStartInfo(path, arguments) + { + RedirectStandardError = true, + RedirectStandardOutput = true, + RedirectStandardInput = true + }; + + using (_currentProcess = StartProcess(startInfo)) + using (var job = new Job()) + { + job.AddProcess(_currentProcess.Handle); + + try + { + _currentProcess.StandardError.ReadToEndAsync().ContinueWith(t => Console.Error.WriteLine(t.Result)); + var firstLine = _currentProcess.StandardOutput.ReadLineAsync(); + Assert.IsTrue(firstLine.Wait(MediumNonDbgTimeout), "Problem after launching test process"); + Assert.IsNotNull(firstLine.Result, "Problem after launching test process"); + Assert.IsTrue(firstLine.Result.StartsWith("Listening") || firstLine.Result.StartsWith("Connecting"), + "Problem after launching test process"); + + test(_currentProcess.StandardOutput); + } + finally + { + try + { + _currentProcess.Kill(); + } + catch + { + } + } + } + } + + void SendInput(string line) + { + _currentProcess.StandardInput.WriteLine(line); + } + + void AssertOutput(StreamReader stdout, string expected) + { + var line = stdout.ReadLineAsync(); + Assert.IsTrue(line.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(expected, line.Result); + } + + [TestMethod] + public void BasicClient() + { + LaunchCompatTestProcess("server:Interface", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var request1 = main.Foo(123, true, default); + var request3 = Assert.ThrowsExceptionAsync(() => main.Bar(default)); + var s = new TestAllTypes(); + Common.InitTestMessage(s); + var request2 = main.Baz(s, default); + + AssertOutput(stdout, "foo 123 1"); + Assert.IsTrue(request1.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("foo", request1.Result); + + Assert.IsTrue(request2.Wait(MediumNonDbgTimeout)); + + AssertOutput(stdout, "baz"); + AssertOutput(stdout, "baz fin"); + Assert.IsTrue(request3.Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void BasicServer() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestInterfaceImpl(counters); + + LaunchCompatTestProcess("client:Basic", stdout => + { + AssertOutput(stdout, "Basic test start"); + AssertOutput(stdout, "Basic test end"); + Assert.AreEqual(2, counters.CallCount); + }); + } + } + + [TestMethod] + public void PipelineClient() + { + LaunchCompatTestProcess("server:Pipeline", stdout => + { + stdout.ReadToEndAsync().ContinueWith(t => Console.WriteLine(t.Result)); + + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var chainedCallCount = new Counters(); + var request = main.GetCap(234, new TestInterfaceImpl(chainedCallCount), default); + using (var box = request.OutBox_Cap()) + { + var pipelineRequest = box.Foo(321, false, default); + using (var box2 = ((Proxy)box).Cast(false)) + { + var pipelineRequest2 = box2.Grault(default); + + Assert.IsTrue(pipelineRequest.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(pipelineRequest2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("bar", pipelineRequest.Result); + Common.CheckTestMessage(pipelineRequest2.Result); + + Assert.AreEqual(1, chainedCallCount.CallCount); + } + } + request.ContinueWith(t => t.Result.Item2.Cap.Dispose()); + } + } + }); + } + + [TestMethod] + public void PipelineServer() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestPipelineImpl(counters); + + LaunchCompatTestProcess("client:Pipelining", stdout => + { + AssertOutput(stdout, "Pipelining test start"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "Pipelining test end"); + Assert.AreEqual(3, counters.CallCount); + }); + } + } + + [TestMethod] + public void ReleaseClient() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var task1 = main.GetHandle(default); + var task2 = main.GetHandle(default); + Assert.IsTrue(task1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(task2.Wait(MediumNonDbgTimeout)); + + AssertOutput(stdout, "getHandle"); + AssertOutput(stdout, "++"); + AssertOutput(stdout, "getHandle"); + AssertOutput(stdout, "++"); + + task1.Result.Dispose(); + + AssertOutput(stdout, "--"); + + task2.Result.Dispose(); + + AssertOutput(stdout, "--"); + } + } + }); + } + + [TestMethod] + public void ReleaseServer() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:Release", stdout => + { + AssertOutput(stdout, "Release test start"); + AssertOutput(stdout, "sync"); + Assert.AreEqual(2, counters.HandleCount); + SendInput("x"); + AssertOutput(stdout, "handle1 null"); + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 1, MediumNonDbgTimeout)); + SendInput("x"); + AssertOutput(stdout, "handle2 null"); + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 1, MediumNonDbgTimeout)); + SendInput("x"); + AssertOutput(stdout, "promise null"); + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 0, MediumNonDbgTimeout)); + SendInput("x"); + AssertOutput(stdout, "Release test end"); + }); + } + } + + [TestMethod] + public void ReleaseOnCancelClient() + { + // Since we have a threaded model, there is no way to deterministically provoke the situation + // where Cancel and Finish message cross paths. Instead, we'll do a lot of such requests and + // later on verify that the handle count is 0. + int iterationCount = 1000; + + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + ((Proxy)main).WhenResolved.Wait(MediumNonDbgTimeout); + + async Task VerifyOutput() + { + int handleCount = 0; + + for (int i = 0; i < 2 * iterationCount; i++) + { + string line = await stdout.ReadLineAsync(); + + switch (line) + { + case "getHandle": + line = await stdout.ReadLineAsync(); + Assert.AreEqual("++", line); + ++handleCount; + Assert.IsTrue(handleCount <= iterationCount); + break; + + case "--": + Assert.IsTrue(handleCount > 0); + --handleCount; + break; + + default: + Assert.Fail("Unexpected output"); + break; + } + } + + Assert.AreEqual(0, handleCount); + } + + var verifyOutputTask = VerifyOutput(); + + for (int i = 0; i < iterationCount; i++) + { + var task = main.GetHandle(default); + Impatient.GetAnswer(task).Dispose(); + task.ContinueWith(t => + { + try + { + t.Result.Dispose(); + } + catch (TaskCanceledException) + { + } + }); + } + + Assert.IsTrue(verifyOutputTask.Wait(LargeNonDbgTimeout)); + + // Not part of original test. Ensure that there is no unwanted extra output + // arising from the test sequence above. + var sync = main.GetCallSequence(0, default); + AssertOutput(stdout, "getCallSequence"); + } + } + }); + } + + [TestMethod] + public void ReleaseOnCancelServer() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:ReleaseOnCancel", stdout => + { + AssertOutput(stdout, "ReleaseOnCancel test start"); + AssertOutput(stdout, "ReleaseOnCancel test end"); + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 0, MediumNonDbgTimeout)); + }); + } + } + + [TestMethod] + public void TestTailCallClient() + { + LaunchCompatTestProcess("server:TailCaller", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var calleeCallCount = new Counters(); + var callee = new TestTailCalleeImpl(calleeCallCount); + + var promise = main.Foo(456, callee, default); + var dependentCall0 = promise.C().GetCallSequence(0, default); + + Assert.IsTrue(promise.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(456u, promise.Result.I); + Assert.AreEqual("from TestTailCaller", promise.Result.T); + + var dependentCall1 = promise.C().GetCallSequence(0, default); + var dependentCall2 = promise.C().GetCallSequence(0, default); + + AssertOutput(stdout, "foo"); + Assert.IsTrue(dependentCall0.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(dependentCall1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(dependentCall2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual(1, calleeCallCount.CallCount); + } + } + }); + } + + [TestMethod] + public void TestTailCallServer() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestTailCallerImpl(counters); + + LaunchCompatTestProcess("client:TailCall", stdout => + { + AssertOutput(stdout, "TailCall test start"); + AssertOutput(stdout, "foo"); + AssertOutput(stdout, "TailCall test end"); + + Assert.AreEqual(1, counters.CallCount); + }); + } + } + + [TestMethod] + public void CancelationServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + stdout.ReadToEndAsync().ContinueWith(t => Console.WriteLine(t.Result)); + + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var counters = new Counters(); + var destroyed = new TaskCompletionSource(); + var impl = new TestInterfaceImpl(counters, destroyed); + var cts = new CancellationTokenSource(); + var cancelTask = main.ExpectCancel(impl, cts.Token); + + Assert.IsFalse(SpinWait.SpinUntil(() => destroyed.Task.IsCompleted || cancelTask.IsCompleted, ShortTimeout)); + + cts.Cancel(); + + Assert.IsTrue(destroyed.Task.Wait(MediumNonDbgTimeout)); + Assert.IsFalse(cancelTask.IsCompletedSuccessfully); + } + } + }); + } + + [TestMethod] + public void CancelationClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:Cancelation", stdout => + { + AssertOutput(stdout, "Cancelation test start"); + AssertOutput(stdout, "~"); + AssertOutput(stdout, "Cancelation test end"); + }); + } + } + + [TestMethod] + public void PromiseResolveServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var tcs = new TaskCompletionSource(); + var eager = tcs.Task.PseudoEager(); + + var request = main.CallFoo(eager, default); + AssertOutput(stdout, "callFoo"); + var request2 = main.CallFooWhenResolved(eager, default); + AssertOutput(stdout, "callFooWhenResolved"); + + var gcs = main.GetCallSequence(0, default); + AssertOutput(stdout, "getCallSequence"); + Assert.IsTrue(gcs.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(2u, gcs.Result); + + var chainedCallCount = new Counters(); + var tiimpl = new TestInterfaceImpl(chainedCallCount); + tcs.SetResult(tiimpl); + + Assert.IsTrue(request.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("bar", request.Result); + Assert.AreEqual("bar", request2.Result); + Assert.AreEqual(2, chainedCallCount.CallCount); + + AssertOutput(stdout, "fin"); + AssertOutput(stdout, "fin"); + } + } + }); + } + + [TestMethod] + public void PromiseResolveClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:PromiseResolve", stdout => + { + AssertOutput(stdout, "PromiseResolve test start"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "PromiseResolve test end"); + Assert.AreEqual(3, counters.CallCount); + }); + } + } + + [TestMethod] + public void RetainAndReleaseServer() + { + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + stdout.ReadToEndAsync().ContinueWith(t => Console.WriteLine(t.Result)); + + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var holdTask = main.Hold(new TestInterfaceImpl(new Counters(), destructionPromise), default); + Assert.IsTrue(holdTask.Wait(MediumNonDbgTimeout)); + + var cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, cstask.Result); + + Assert.IsFalse(destructionTask.IsCompleted); + + var htask = main.CallHeld(default); + Assert.IsTrue(htask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", htask.Result); + + var gtask = main.GetHeld(default); + Assert.IsTrue(gtask.Wait(MediumNonDbgTimeout)); + // We can get the cap back from it. + using (var cap = gtask.Result) + { + // And call it, without any network communications. + long oldSendCount = client.SendCount; + var ftask = cap.Foo(123, true, default); + Assert.IsTrue(ftask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("foo", ftask.Result); + Assert.AreEqual(oldSendCount, client.SendCount); + + // We can send another copy of the same cap to another method, and it works. + var ctask = main.CallFoo(cap, default); + Assert.IsTrue(ctask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ctask.Result); + + // Give some time to settle. + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(5u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(6u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(7u, cstask.Result); + + // Can't be destroyed, we haven't released it. + Assert.IsFalse(destructionTask.IsCompleted); + } + + // At this point, we have a major difference to Cap'n Proto original test suite. + // In the original suite, you will find the following comment: + // "We released our client, which should cause the server to be released, which in turn will + // release the cap pointing back to us." + // For the situation here, this assumption would be wrong: Releasing the client does NOT release + // the server, because it is the bootstrap capability, and there might be other clients in the future. + // The bootstrap capbility is held as long as the TCP server is running. + // Instead, the test requests the server to hold the "null" capability, which will replace the + // existing one, which in turn will release the cap pointing back to us. + holdTask = main.Hold(null, default); + Assert.IsTrue(holdTask.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void RetainAndReleaseClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:RetainAndRelease", stdout => + { + AssertOutput(stdout, "RetainAndRelease test start"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "~"); + AssertOutput(stdout, "RetainAndRelease test end"); + }); + } + } + + [TestMethod] + public void CancelServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + using (var main = client.GetMain()) + using (var cts = new CancellationTokenSource()) + { + var counters = new Counters(); + var ntask = main.NeverReturn(new TestInterfaceImpl(counters, destructionPromise), cts.Token); + + // Allow some time to settle. + var cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(2u, cstask.Result); + + // The cap shouldn't have been destroyed yet because the call never returned. + Assert.IsFalse(destructionTask.IsCompleted); + + // There will be no automatic cancellation just because "ntask" goes of of scope or + // because the Proxy is disposed. Even ntask.Dispose() would not cancel the request. + // In .NET this needs to be done explicitly. + cts.Cancel(); + + // Now the cap should be released. + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void CancelClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:Cancel", stdout => + { + AssertOutput(stdout, "Cancel test start"); + AssertOutput(stdout, "~"); + AssertOutput(stdout, "Cancel test end"); + }); + } + } + + [TestMethod] + public void SendTwiceServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + var cap = new TestInterfaceImpl(new Counters(), destructionPromise); + + Task ftask1, ftask2; + + using (Skeleton.Claim(cap)) + { + var ftask = main.CallFoo(cap, default); + Assert.IsTrue(ftask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask.Result); + + var ctask = main.GetCallSequence(0, default); + Assert.IsTrue(ctask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, ctask.Result); + + ftask1 = main.CallFoo(cap, default); + ftask2 = main.CallFoo(cap, default); + } + + Assert.IsTrue(ftask1.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask1.Result); + Assert.IsTrue(ftask2.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask2.Result); + + // Now the cap should be released. + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void SendTwiceClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:SendTwice", stdout => + { + AssertOutput(stdout, "SendTwice test start"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "foo 123 1"); + AssertOutput(stdout, "~"); + AssertOutput(stdout, "SendTwice test end"); + }); + } + } + + [TestMethod] + public void EmbargoServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + int retry = 0; + + label: + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout), "client connect"); + + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + if (!resolving.WhenResolved.Wait(MediumNonDbgTimeout)) + { + if (++retry == 5) + { + Assert.Fail("Attempting to obtain bootstrap interface failed. Bailing out."); + } + goto label; + } + + var cap = new TestCallOrderImpl(); + + var earlyCall = main.GetCallSequence(0, default); + + var echo = main.Echo(cap, default); + + using (var pipeline = echo.Eager()) + { + var call0 = pipeline.GetCallSequence(0, default); + var call1 = pipeline.GetCallSequence(1, default); + + Assert.IsTrue(earlyCall.Wait(MediumNonDbgTimeout), "early call returns"); + + var call2 = pipeline.GetCallSequence(2, default); + + Assert.IsTrue(echo.Wait(MediumNonDbgTimeout)); + using (var resolved = echo.Result) + { + var call3 = pipeline.GetCallSequence(3, default); + var call4 = pipeline.GetCallSequence(4, default); + var call5 = pipeline.GetCallSequence(5, default); + + Assert.IsTrue(call0.Wait(MediumNonDbgTimeout), "call 0 returns"); + Assert.IsTrue(call1.Wait(MediumNonDbgTimeout), "call 1 returns"); + Assert.IsTrue(call2.Wait(MediumNonDbgTimeout), "call 2 returns"); + Assert.IsTrue(call3.Wait(MediumNonDbgTimeout), "call 3 returns"); + Assert.IsTrue(call4.Wait(MediumNonDbgTimeout), "call 4 returns"); + Assert.IsTrue(call5.Wait(MediumNonDbgTimeout), "call 5 returns"); + + Assert.AreEqual(0u, call0.Result); + Assert.AreEqual(1u, call1.Result); + Assert.AreEqual(2u, call2.Result); + Assert.AreEqual(3u, call3.Result); + Assert.AreEqual(4u, call4.Result); + Assert.AreEqual(5u, call5.Result); + } + + } + } + } + }); + } + + [TestMethod] + public void EmbargoClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:Embargo", stdout => + { + AssertOutput(stdout, "Embargo test start"); + AssertOutput(stdout, "Embargo test end"); + }); + } + } + + public void EmbargoErrorImpl(StreamReader stdout) + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var cap = new TaskCompletionSource(); + + var earlyCall = main.GetCallSequence(0, default); + + using (var eager = cap.Task.PseudoEager()) + { + var echo = main.Echo(eager, default); + + using (var pipeline = echo.Eager()) + { + var call0 = pipeline.GetCallSequence(0, default); + var call1 = pipeline.GetCallSequence(1, default); + + Assert.IsTrue(earlyCall.Wait(MediumNonDbgTimeout)); + + var call2 = pipeline.GetCallSequence(2, default); + + Assert.IsTrue(echo.Wait(MediumNonDbgTimeout)); + using (var resolved = echo.Result) + { + var call3 = pipeline.GetCallSequence(3, default); + var call4 = pipeline.GetCallSequence(4, default); + var call5 = pipeline.GetCallSequence(5, default); + + cap.SetException(new InvalidOperationException("I'm annoying")); + + ExpectPromiseThrows(call0); + ExpectPromiseThrows(call1); + ExpectPromiseThrows(call2); + ExpectPromiseThrows(call3); + ExpectPromiseThrows(call4); + ExpectPromiseThrows(call5); + } + } + } + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + } + + [TestMethod] + public void EmbargoErrorServer() + { + LaunchCompatTestProcess("server:MoreStuff", EmbargoErrorImpl); + } + + [TestMethod] + public void RepeatedEmbargoError() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + for (int i = 0; i < 100; i++) + { + EmbargoErrorImpl(stdout); + } + }); + } + + [TestMethod] + public void EmbargoErrorClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:EmbargoError", stdout => + { + AssertOutput(stdout, "EmbargoError test start"); + AssertOutput(stdout, "EmbargoError test end"); + }); + } + } + + [TestMethod] + public void EmbargoNullServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + int retry = 0; + + label: + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + if (!resolving.WhenResolved.Wait(MediumNonDbgTimeout)) + { + if (++retry == 5) + { + Assert.Fail("Attempting to obtain bootstrap interface failed. Bailing out."); + } + goto label; + } + + var promise = main.GetNull(default); + + using (var cap = promise.Eager()) + { + var call0 = cap.GetCallSequence(0, default); + + Assert.IsTrue(promise.Wait(MediumNonDbgTimeout)); + using (promise.Result) + { + var call1 = cap.GetCallSequence(1, default); + + ExpectPromiseThrows(call0); + ExpectPromiseThrows(call1); + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + } + } + + }); + } + + [TestMethod] + public void EmbargoNullClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:EmbargoNull", stdout => + { + AssertOutput(stdout, "EmbargoNull test start"); + AssertOutput(stdout, "EmbargoNull test end"); + }); + } + } + + [TestMethod] + public void CallBrokenPromiseServer() + { + LaunchCompatTestProcess("server:MoreStuff", stdout => + { + using (var client = new TcpRpcClient("localhost", TcpPort)) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var tcs = new TaskCompletionSource(); + + using (var eager = tcs.Task.PseudoEager()) + { + var req = main.Hold(eager, default); + Assert.IsTrue(req.Wait(MediumNonDbgTimeout)); + } + + var req2 = main.CallHeld(default); + + Assert.IsFalse(req2.Wait(ShortTimeout)); + + tcs.SetException(new InvalidOperationException("I'm a promise-breaker!")); + + ExpectPromiseThrows(req2); + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void CallBrokenPromiseClient() + { + using (var server = SetupServer()) + { + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + + LaunchCompatTestProcess("client:CallBrokenPromise", stdout => + { + AssertOutput(stdout, "CallBrokenPromise test start"); + AssertOutput(stdout, "CallBrokenPromise test end"); + }); + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TcpRpcPorted.cs b/Capnp.Net.Runtime.Tests/TcpRpcPorted.cs new file mode 100644 index 0000000..a13b4a5 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TcpRpcPorted.cs @@ -0,0 +1,622 @@ +using System; +using System.Diagnostics; +using System.Net; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Threading.Tasks; +using Capnp.Rpc; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Capnp.Net.Runtime.Tests.GenImpls; +using Capnproto_test.Capnp.Test; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class TcpRpcPorted: TestBase + { + [TestMethod] + public void Basic() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestInterfaceImpl(counters); + using (var main = client.GetMain()) + { + var request1 = main.Foo(123, true, default); + var request3 = Assert.ThrowsExceptionAsync(() => main.Bar(default)); + var s = new TestAllTypes(); + Common.InitTestMessage(s); + var request2 = main.Baz(s, default); + + Assert.IsTrue(request1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request2.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request3.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("foo", request1.Result); + Assert.AreEqual(2, counters.CallCount); + } + } + } + + [TestMethod] + public void Pipeline() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestPipelineImpl(counters); + using (var main = client.GetMain()) + { + var chainedCallCount = new Counters(); + var request = main.GetCap(234, new TestInterfaceImpl(chainedCallCount), default); + using (var outBox = request.OutBox_Cap()) + { + var pipelineRequest = outBox.Foo(321, false, default); + var pipelineRequest2 = ((Proxy)outBox).Cast(false).Grault(default); + + Assert.IsTrue(pipelineRequest.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(pipelineRequest2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("bar", pipelineRequest.Result); + Common.CheckTestMessage(pipelineRequest2.Result); + + Assert.AreEqual(3, counters.CallCount); + Assert.AreEqual(1, chainedCallCount.CallCount); + } + } + + } + } + + [TestMethod] + public void Release() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + using (var main = client.GetMain()) + { + var task1 = main.GetHandle(default); + var task2 = main.GetHandle(default); + Assert.IsTrue(task1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(task2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual(2, counters.HandleCount); + + task1.Result.Dispose(); + + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 1, MediumNonDbgTimeout)); + + task2.Result.Dispose(); + + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 0, MediumNonDbgTimeout)); + } + + } + } + + [TestMethod] + public void ReleaseOnCancel() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + using (var main = client.GetMain()) + { + ((Proxy)main).WhenResolved.Wait(MediumNonDbgTimeout); + + // Since we have a threaded model, there is no way to deterministically provoke the situation + // where Cancel and Finish message cross paths. Instead, we'll do a lot of such requests and + // later on verify that the handle count is 0. + + for (int i = 0; i < 1000; i++) + { + var cts = new CancellationTokenSource(); + var task = main.GetHandle(cts.Token); + cts.Cancel(); + task.ContinueWith(t => + { + t.Result.Dispose(); + cts.Dispose(); + }); + } + + Thread.Sleep(ShortTimeout); + + Assert.IsTrue(SpinWait.SpinUntil(() => counters.HandleCount == 0, MediumNonDbgTimeout)); + } + } + } + + [TestMethod] + public void TestTailCall() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestTailCallerImpl(counters); + using (var main = client.GetMain()) + { + var calleeCallCount = new Counters(); + var callee = new TestTailCalleeImpl(calleeCallCount); + + var promise = main.Foo(456, callee, default); + var dependentCall0 = promise.C().GetCallSequence(0, default); + + Assert.IsTrue(promise.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(456u, promise.Result.I); + Assert.AreEqual("from TestTailCaller", promise.Result.T); + + var dependentCall1 = promise.C().GetCallSequence(0, default); + var dependentCall2 = promise.C().GetCallSequence(0, default); + + Assert.IsTrue(dependentCall0.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(dependentCall1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(dependentCall2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual(1, counters.CallCount); + Assert.AreEqual(1, calleeCallCount.CallCount); + } + } + } + + [TestMethod] + public void Cancelation() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + server.Main = new TestMoreStuffImpl(counters); + using (var main = client.GetMain()) + { + var destroyed = new TaskCompletionSource(); + var impl = new TestInterfaceImpl(counters, destroyed); + var cts = new CancellationTokenSource(); + var cancelTask = main.ExpectCancel(impl, cts.Token); + + Assert.IsFalse(SpinWait.SpinUntil(() => destroyed.Task.IsCompleted || cancelTask.IsCompleted, ShortTimeout)); + + cts.Cancel(); + + Assert.IsTrue(destroyed.Task.Wait(MediumNonDbgTimeout)); + Assert.IsFalse(cancelTask.IsCompletedSuccessfully); + } + + } + } + + [TestMethod] + public void PromiseResolve() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var tcs = new TaskCompletionSource(); + var eager = tcs.Task.PseudoEager(); + + var request = main.CallFoo(eager, default); + var request2 = main.CallFooWhenResolved(eager, default); + + var gcs = main.GetCallSequence(0, default); + Assert.IsTrue(gcs.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(2u, gcs.Result); + Assert.AreEqual(3, counters.CallCount); + + var chainedCallCount = new Counters(); + var tiimpl = new TestInterfaceImpl(chainedCallCount); + tcs.SetResult(tiimpl); + + Assert.IsTrue(request.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(request2.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual("bar", request.Result); + Assert.AreEqual("bar", request2.Result); + Assert.AreEqual(3, counters.CallCount); + Assert.AreEqual(2, chainedCallCount.CallCount); + } + + } + } + + [TestMethod] + public void RetainAndRelease() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var holdTask = main.Hold(new TestInterfaceImpl(new Counters(), destructionPromise), default); + Assert.IsTrue(holdTask.Wait(MediumNonDbgTimeout)); + + var cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, cstask.Result); + + Assert.IsFalse(destructionTask.IsCompleted); + + var htask = main.CallHeld(default); + Assert.IsTrue(htask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", htask.Result); + + var gtask = main.GetHeld(default); + Assert.IsTrue(gtask.Wait(MediumNonDbgTimeout)); + // We can get the cap back from it. + using (var cap = gtask.Result) + { + // Wait for balanced state + WaitClientServerIdle(server, client); + + // And call it, without any network communications. + long oldSendCount = client.SendCount; + var ftask = cap.Foo(123, true, default); + Assert.IsTrue(ftask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("foo", ftask.Result); + Assert.AreEqual(oldSendCount, client.SendCount); + + // We can send another copy of the same cap to another method, and it works. + var ctask = main.CallFoo(cap, default); + Assert.IsTrue(ctask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ctask.Result); + + // Give some time to settle. + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(5u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(6u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(7u, cstask.Result); + + // Can't be destroyed, we haven't released it. + Assert.IsFalse(destructionTask.IsCompleted); + } + + // In deviation from original test, we have null the held capability on the main interface. + // This is because the main interface is the bootstrap capability and, as such, won't be disposed + // after disconnect. + var holdNullTask = main.Hold(null, default); + Assert.IsTrue(holdNullTask.Wait(MediumNonDbgTimeout)); + } + + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + + [TestMethod] + public void Cancel() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + using (var cts = new CancellationTokenSource()) + { + var ntask = main.NeverReturn(new TestInterfaceImpl(counters, destructionPromise), cts.Token); + + // Allow some time to settle. + var cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, cstask.Result); + cstask = main.GetCallSequence(0, default); + Assert.IsTrue(cstask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(2u, cstask.Result); + + // The cap shouldn't have been destroyed yet because the call never returned. + Assert.IsFalse(destructionTask.IsCompleted); + + // There will be no automatic cancellation just because "ntask" goes of of scope or + // because the Proxy is disposed. Even ntask.Dispose() would not cancel the request. + // In .NET this needs to be done explicitly. + cts.Cancel(); + } + + // Now the cap should be released. + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + + [TestMethod] + public void SendTwice() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var destructionPromise = new TaskCompletionSource(); + var destructionTask = destructionPromise.Task; + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var cap = new TestInterfaceImpl(new Counters(), destructionPromise); + + Task ftask1, ftask2; + + using (Skeleton.Claim(cap)) + { + var ftask = main.CallFoo(cap, default); + Assert.IsTrue(ftask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask.Result); + + var ctask = main.GetCallSequence(0, default); + Assert.IsTrue(ctask.Wait(MediumNonDbgTimeout)); + Assert.AreEqual(1u, ctask.Result); + + ftask1 = main.CallFoo(cap, default); + ftask2 = main.CallFoo(cap, default); + } + + Assert.IsTrue(ftask1.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask1.Result); + Assert.IsTrue(ftask2.Wait(MediumNonDbgTimeout)); + Assert.AreEqual("bar", ftask2.Result); + + // Now the cap should be released. + Assert.IsTrue(destructionTask.Wait(MediumNonDbgTimeout)); + } + } + } + + [TestMethod] + public void Embargo() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var cap = new TestCallOrderImpl(); + + var earlyCall = main.GetCallSequence(0, default); + + var echo = main.Echo(cap, default); + + using (var pipeline = echo.Eager()) + { + var call0 = pipeline.GetCallSequence(0, default); + var call1 = pipeline.GetCallSequence(1, default); + + Assert.IsTrue(earlyCall.Wait(MediumNonDbgTimeout)); + + impl.EnableEcho(); + + var call2 = pipeline.GetCallSequence(2, default); + + Assert.IsTrue(echo.Wait(MediumNonDbgTimeout)); + using (var resolved = echo.Result) + { + var call3 = pipeline.GetCallSequence(3, default); + var call4 = pipeline.GetCallSequence(4, default); + var call5 = pipeline.GetCallSequence(5, default); + + Assert.IsTrue(call0.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(call1.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(call2.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(call3.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(call4.Wait(MediumNonDbgTimeout)); + Assert.IsTrue(call5.Wait(MediumNonDbgTimeout)); + + Assert.AreEqual(0u, call0.Result); + Assert.AreEqual(1u, call1.Result); + Assert.AreEqual(2u, call2.Result); + Assert.AreEqual(3u, call3.Result); + Assert.AreEqual(4u, call4.Result); + Assert.AreEqual(5u, call5.Result); + } + } + } + } + } + + [TestMethod] + public void EmbargoError() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var cap = new TaskCompletionSource(); + + var earlyCall = main.GetCallSequence(0, default); + + var echo = main.Echo(cap.Task.PseudoEager(), default); + + var pipeline = echo.Eager(); + + var call0 = pipeline.GetCallSequence(0, default); + var call1 = pipeline.GetCallSequence(1, default); + + Assert.IsTrue(earlyCall.Wait(MediumNonDbgTimeout)); + + impl.EnableEcho(); + + var call2 = pipeline.GetCallSequence(2, default); + + Assert.IsTrue(echo.Wait(MediumNonDbgTimeout)); + var resolved = echo.Result; + + var call3 = pipeline.GetCallSequence(3, default); + var call4 = pipeline.GetCallSequence(4, default); + var call5 = pipeline.GetCallSequence(5, default); + + cap.SetException(new InvalidOperationException("I'm annoying")); + + ExpectPromiseThrows(call0); + ExpectPromiseThrows(call1); + ExpectPromiseThrows(call2); + ExpectPromiseThrows(call3); + ExpectPromiseThrows(call4); + ExpectPromiseThrows(call5); + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + } + + [TestMethod] + public void EmbargoNull() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var promise = main.GetNull(default); + + var cap = promise.Eager(); + + var call0 = cap.GetCallSequence(0, default); + + Assert.IsTrue(promise.Wait(MediumNonDbgTimeout)); + + var call1 = cap.GetCallSequence(1, default); + + ExpectPromiseThrows(call0); + ExpectPromiseThrows(call1); + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + } + + [TestMethod] + public void CallBrokenPromise() + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + + var tcs = new TaskCompletionSource(); + + var req = main.Hold(tcs.Task.PseudoEager(), default); + Assert.IsTrue(req.Wait(MediumNonDbgTimeout)); + + var req2 = main.CallHeld(default); + + Assert.IsFalse(req2.Wait(ShortTimeout)); + + tcs.SetException(new InvalidOperationException("I'm a promise-breaker!")); + + ExpectPromiseThrows(req2); + + // Verify that we're still connected (there were no protocol errors). + Assert.IsTrue(main.GetCallSequence(1, default).Wait(MediumNonDbgTimeout)); + } + } + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TcpRpcStress.cs b/Capnp.Net.Runtime.Tests/TcpRpcStress.cs new file mode 100644 index 0000000..d8ae9cc --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TcpRpcStress.cs @@ -0,0 +1,103 @@ +using Capnp.Net.Runtime.Tests.GenImpls; +using Capnp.Rpc; +using Capnproto_test.Capnp.Test; +using Microsoft.Extensions.Logging; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class TcpRpcStress: TestBase + { + ILogger Logger { get; set; } + + void Repeat(int count, Action action) + { + for (int i = 0; i < count; i++) + { + Logger.LogTrace("Repetition {0}", i); + action(); + } + } + + [TestInitialize] + public void InitConsoleLogging() + { + Logging.LoggerFactory = new LoggerFactory().AddConsole((msg, level) => true); + Logger = Logging.CreateLogger(); + if (Thread.CurrentThread.Name == null) + Thread.CurrentThread.Name = $"Test Thread {Thread.CurrentThread.ManagedThreadId}"; + } + + [TestMethod] + public void ResolveMain() + { + Repeat(5000, () => + { + (var server, var client) = SetupClientServerPair(); + + using (server) + using (client) + { + Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout)); + + var counters = new Counters(); + var impl = new TestMoreStuffImpl(counters); + server.Main = impl; + using (var main = client.GetMain()) + { + var resolving = main as IResolvingCapability; + Assert.IsTrue(resolving.WhenResolved.Wait(MediumNonDbgTimeout)); + } + } + }); + } + + [TestMethod] + public void Cancel() + { + var t = new TcpRpcPorted(); + Repeat(1000, t.Cancel); + } + + [TestMethod] + public void Embargo() + { + var t = new TcpRpcPorted(); + Repeat(100, t.Embargo); + + var t2 = new TcpRpcInterop(); + Repeat(100, t2.EmbargoServer); + } + + [TestMethod] + public void EmbargoNull() + { + // Some code paths are really rare during this test, therefore increased repetition count. + + var t = new TcpRpcPorted(); + Repeat(1000, t.EmbargoNull); + + var t2 = new TcpRpcInterop(); + Repeat(100, t2.EmbargoNullServer); + } + + [TestMethod] + public void RetainAndRelease() + { + var t = new TcpRpcPorted(); + Repeat(100, t.RetainAndRelease); + } + + [TestMethod] + public void PipelineAfterReturn() + { + var t = new TcpRpc(); + Repeat(100, t.PipelineAfterReturn); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/TestBase.cs b/Capnp.Net.Runtime.Tests/TestBase.cs new file mode 100644 index 0000000..fc1e2b7 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TestBase.cs @@ -0,0 +1,89 @@ +using Capnp.Rpc; +using Microsoft.Extensions.Logging; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Net; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests +{ + public class TestBase + { + public static int TcpPort = 33444; + public static int MediumNonDbgTimeout => Debugger.IsAttached ? Timeout.Infinite : 5000; + public static int LargeNonDbgTimeout => Debugger.IsAttached ? Timeout.Infinite : 10000; + public static int ShortTimeout => 500; + + protected ILogger Logger { get; set; } + + protected TcpRpcClient SetupClient() => new TcpRpcClient("localhost", TcpPort); + protected TcpRpcServer SetupServer() => new TcpRpcServer(IPAddress.Any, TcpPort); + + protected (TcpRpcServer, TcpRpcClient) SetupClientServerPair() + { + var server = SetupServer(); + var client = SetupClient(); + return (server, client); + } + + [TestInitialize] + public void InitConsoleLogging() + { + Logging.LoggerFactory = new LoggerFactory().AddConsole((msg, level) => true); + Logger = Logging.CreateLogger(); + if (Thread.CurrentThread.Name == null) + Thread.CurrentThread.Name = $"Test Thread {Thread.CurrentThread.ManagedThreadId}"; + } + + /// + /// Somewhat ugly helper method which ensures that both Tcp client and server + /// are waiting for data reception from each other. This is a "balanced" state, meaning + /// that nothing will ever happen in the RcpEngines without some other thread requesting + /// anything. + /// + protected void WaitClientServerIdle(TcpRpcServer server, TcpRpcClient client) + { + var conn = server.Connections[0]; + SpinWait.SpinUntil(() => conn.IsWaitingForData && client.IsWaitingForData && + conn.RecvCount == client.SendCount && + conn.SendCount == client.RecvCount, + MediumNonDbgTimeout); + } + + protected void ExpectPromiseThrows(Task task) + { + async Task ExpectPromiseThrowsAsync(Task t) + { + try + { + await t; + Assert.Fail("Did not throw"); + } + catch (InvalidOperationException) + { + // Happens if the call went to the resolution + // (thus, locally). In this case, the original + // exception is routed here. + } + catch (RpcException) + { + // Happens if the call went to the promise + // (thus, remotely). In this case, the original + // exception had to be serialized, so we receive + // the wrapped version. + } + catch (System.Exception exception) + { + Assert.Fail($"Got wrong kind of exception: {exception}"); + } + } + + Assert.IsTrue(ExpectPromiseThrowsAsync(task).Wait(MediumNonDbgTimeout)); + } + + } +} diff --git a/Capnp.Net.Runtime.Tests/TestCapImplementations.cs b/Capnp.Net.Runtime.Tests/TestCapImplementations.cs new file mode 100644 index 0000000..a8e7b78 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TestCapImplementations.cs @@ -0,0 +1,745 @@ +using Capnp.Rpc; +using Microsoft.Extensions.Logging; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; +using System.Linq.Expressions; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using Capnproto_test.Capnp.Test; + +namespace Capnp.Net.Runtime.Tests.GenImpls +{ + class Common + { + static byte[] Data(string s) => System.Text.Encoding.UTF8.GetBytes(s); + + static bool DataSequenceEqual(IEnumerable> seq1, IEnumerable> seq2) + { + return seq1.Zip(seq2, (s1, s2) => s1.SequenceEqual(s2)).All(_ => _); + } + + public static void InitTestMessage(TestAllTypes s) + { + s.BoolField = true; + s.Int8Field = -123; + s.Int16Field = -12345; + s.Int32Field = -12345678; + s.Int64Field = -123456789012345; + s.UInt8Field = 234; + s.UInt16Field = 45678; + s.UInt32Field = 3456789012; + s.UInt64Field = 12345678901234567890; + s.Float32Field = 1234.5f; + s.Float64Field = -123e45; + s.TextField = "foo"; + s.DataField = Data("bar"); + { + s.StructField = new TestAllTypes(); + var sub = s.StructField; + sub.BoolField = true; + sub.Int8Field = -12; + sub.Int16Field = 3456; + sub.Int32Field = -78901234; + sub.Int64Field = 56789012345678; + sub.UInt8Field = 90; + sub.UInt16Field = 1234; + sub.UInt32Field = 56789012; + sub.UInt64Field = 345678901234567890; + sub.Float32Field = -1.25e-10f; + sub.Float64Field = 345; + sub.TextField = "baz"; + sub.DataField = Data("qux"); + { + sub.StructField = new TestAllTypes() + { + TextField = "nested", + StructField = new TestAllTypes() + { + TextField = "really nested" + } + }; + } + sub.EnumField = TestEnum.baz; + sub.VoidList = 3; + sub.BoolList = new bool[] { false, true, false, true, true }; + sub.Int8List = new sbyte[] { 12, -34, -0x80, 0x7f }; + sub.Int16List = new short[] { 1234, -5678, -0x8000, 0x7fff }; + sub.Int32List = new int[] { 12345678, -90123456, -0x7fffffff - 1, 0x7fffffff }; + sub.Int64List = new long[] { 123456789012345, -678901234567890, -0x7fffffffffffffff - 1, 0x7fffffffffffffff }; + sub.UInt8List = new byte[] { 12, 34, 0, 0xff }; + sub.UInt16List = new ushort[] { 1234, 5678, 0, 0xffff }; + sub.UInt32List = new uint[] { 12345678u, 90123456u, 0u, 0xffffffffu }; + sub.UInt64List = new ulong[] { 123456789012345, 678901234567890, 0, 0xffffffffffffffff }; + sub.Float32List = new float[] { 0, 1234567, 1e37f, -1e37f, 1e-37f, -1e-37f }; + sub.Float64List = new double[] { 0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306 }; + sub.TextList = new string[] { "quux", "corge", "grault" }; + sub.DataList = new byte[][] { Data("garply"), Data("waldo"), Data("fred") }; + sub.StructList = new TestAllTypes[] + { + new TestAllTypes() { TextField = "x structlist 1" }, + new TestAllTypes() { TextField = "x structlist 2" }, + new TestAllTypes() { TextField = "x structlist 3" } + }; + sub.EnumList = new TestEnum[] { TestEnum.qux, TestEnum.bar, TestEnum.grault }; + } + s.EnumField = TestEnum.corge; + s.VoidList = 6; + s.BoolList = new bool[] { true, false, false, true }; + s.Int8List = new sbyte[] { 111, -111 }; + s.Int16List = new short[] { 11111, -11111 }; + s.Int32List = new int[] { 111111111, -111111111 }; + s.Int64List = new long[] { 1111111111111111111, -1111111111111111111 }; + s.UInt8List = new byte[] { 111, 222 }; + s.UInt16List = new ushort[] { 33333, 44444 }; + s.UInt32List = new uint[] { 3333333333 }; + s.UInt64List = new ulong[] { 11111111111111111111 }; + s.Float32List = new float[] { 5555.5f, float.PositiveInfinity, float.NegativeInfinity, float.NaN }; + s.Float64List = new double[] { 7777.75, double.PositiveInfinity, double.NegativeInfinity, double.NaN }; + s.TextList = new string[] { "plugh", "xyzzy", "thud" }; + s.DataList = new byte[][] { Data("oops"), Data("exhausted"), Data("rfc3092") }; + { + s.StructList = new TestAllTypes[] + { + new TestAllTypes() { TextField = "structlist 1" }, + new TestAllTypes() { TextField = "structlist 2" }, + new TestAllTypes() { TextField = "structlist 3" } + }; + } + s.EnumList = new TestEnum[] { TestEnum.foo, TestEnum.garply }; + } + + public static void CheckTestMessage(TestAllTypes s) + { + var sub = s.StructField; + Assert.IsTrue(sub.BoolField); + Assert.AreEqual(-12, sub.Int8Field); + Assert.AreEqual(3456, sub.Int16Field); + Assert.AreEqual(-78901234, sub.Int32Field); + Assert.AreEqual(56789012345678, sub.Int64Field); + Assert.AreEqual(90, sub.UInt8Field); + Assert.AreEqual(1234, sub.UInt16Field); + Assert.AreEqual(56789012u, sub.UInt32Field); + Assert.AreEqual(345678901234567890ul, sub.UInt64Field); + Assert.AreEqual(-1.25e-10f, sub.Float32Field); + Assert.AreEqual(345.0, sub.Float64Field); + Assert.AreEqual("baz", sub.TextField); + Assert.IsTrue(Data("qux").SequenceEqual(sub.DataField)); + { + var subsub = sub.StructField; + Assert.AreEqual("nested", subsub.TextField); + Assert.AreEqual("really nested", subsub.StructField.TextField); + } + Assert.AreEqual(TestEnum.baz, sub.EnumField); + Assert.AreEqual(3, sub.VoidList); + Assert.IsTrue(sub.BoolList.SequenceEqual(new bool[] { false, true, false, true, true })); + Assert.IsTrue(sub.Int8List.SequenceEqual(new sbyte[] { 12, -34, -0x80, 0x7f })); + Assert.IsTrue(sub.Int16List.SequenceEqual(new short[] { 1234, -5678, -0x8000, 0x7fff })); + Assert.IsTrue(sub.Int32List.SequenceEqual(new int[] { 12345678, -90123456, -0x7fffffff - 1, 0x7fffffff })); + Assert.IsTrue(sub.Int64List.SequenceEqual(new long[] { 123456789012345, -678901234567890, -0x7fffffffffffffff - 1, 0x7fffffffffffffff })); + Assert.IsTrue(sub.UInt8List.SequenceEqual(new byte[] { 12, 34, 0, 0xff })); + Assert.IsTrue(sub.UInt16List.SequenceEqual(new ushort[] { 1234, 5678, 0, 0xffff })); + Assert.IsTrue(sub.UInt32List.SequenceEqual(new uint[] { 12345678, 90123456, 0u, 0xffffffff })); + Assert.IsTrue(sub.UInt64List.SequenceEqual(new ulong[] { 123456789012345, 678901234567890, 0, 0xffffffffffffffff })); + Assert.IsTrue(sub.Float32List.SequenceEqual(new float[] { 0.0f, 1234567.0f, 1e37f, -1e37f, 1e-37f, -1e-37f })); + Assert.IsTrue(sub.Float64List.SequenceEqual(new double[] { 0.0, 123456789012345.0, 1e306, -1e306, 1e-306, -1e-306 })); + Assert.IsTrue(sub.TextList.SequenceEqual(new string[] { "quux", "corge", "grault" })); + Assert.IsTrue(DataSequenceEqual(sub.DataList, new byte[][] { Data("garply"), Data("waldo"), Data("fred") })); + { + var list = sub.StructList; + Assert.AreEqual(3, list.Count); + Assert.AreEqual("x structlist 1", list[0].TextField); + Assert.AreEqual("x structlist 2", list[1].TextField); + Assert.AreEqual("x structlist 3", list[2].TextField); + } + Assert.IsTrue(sub.EnumList.SequenceEqual(new TestEnum[] { TestEnum.qux, TestEnum.bar, TestEnum.grault })); + Assert.AreEqual(TestEnum.corge, s.EnumField); + + Assert.AreEqual(6, s.VoidList); + Assert.IsTrue(s.BoolList.SequenceEqual(new bool[] { true, false, false, true })); + Assert.IsTrue(s.Int8List.SequenceEqual(new sbyte[] { 111, -111 })); + Assert.IsTrue(s.Int16List.SequenceEqual(new short[] { 11111, -11111 })); + Assert.IsTrue(s.Int32List.SequenceEqual(new int[] { 111111111, -111111111 })); + Assert.IsTrue(s.Int64List.SequenceEqual(new long[] { 1111111111111111111, -1111111111111111111 })); + Assert.IsTrue(s.UInt8List.SequenceEqual(new byte[] { 111, 222 })); + Assert.IsTrue(s.UInt16List.SequenceEqual(new ushort[] { 33333, 44444 })); + Assert.IsTrue(s.UInt32List.SequenceEqual(new uint[] { 3333333333 })); + Assert.IsTrue(s.UInt64List.SequenceEqual(new ulong[] { 11111111111111111111 })); + { + var list = s.Float32List; + Assert.AreEqual(4, list.Count); + Assert.AreEqual(5555.5f, list[0]); + Assert.AreEqual(float.PositiveInfinity, list[1]); + Assert.AreEqual(float.NegativeInfinity, list[2]); + Assert.IsTrue(float.IsNaN(list[3])); + } + { + var list = s.Float64List; + Assert.AreEqual(4, list.Count); + Assert.AreEqual(7777.75, list[0]); + Assert.IsTrue(double.IsPositiveInfinity(list[1])); + Assert.IsTrue(double.IsNegativeInfinity(list[2])); + Assert.IsTrue(double.IsNaN(list[3])); + } + Assert.IsTrue(s.TextList.SequenceEqual(new string[] { "plugh", "xyzzy", "thud" })); + Assert.IsTrue(DataSequenceEqual(s.DataList, new byte[][] { Data("oops"), Data("exhausted"), Data("rfc3092") })); + { + var list = s.StructList; + Assert.AreEqual(3, list.Count); + Assert.AreEqual("structlist 1", list[0].TextField); + Assert.AreEqual("structlist 2", list[1].TextField); + Assert.AreEqual("structlist 3", list[2].TextField); + } + Assert.IsTrue(s.EnumList.SequenceEqual(new TestEnum[] { TestEnum.foo, TestEnum.garply })); + } + + public static void CheckTestMessageAllZero(TestAllTypes s) + { + Assert.IsFalse(s.BoolField); + Assert.AreEqual(0, s.Int8Field); + Assert.AreEqual(0, s.Int16Field); + Assert.AreEqual(0, s.Int32Field); + Assert.AreEqual(0, s.Int64Field); + Assert.AreEqual(0, s.UInt8Field); + Assert.AreEqual(0, s.UInt16Field); + Assert.AreEqual(0, s.UInt32Field); + Assert.AreEqual(0, s.UInt64Field); + Assert.AreEqual(0f, s.Float32Field); + Assert.AreEqual(0.0, s.Float64Field); + Assert.AreEqual(string.Empty, s.TextField); + Assert.IsTrue(Data(string.Empty).SequenceEqual(s.DataField)); + { + var sub = s.StructField; + Assert.IsFalse(sub.BoolField); + Assert.AreEqual(0, sub.Int8Field); + Assert.AreEqual(0, sub.Int16Field); + Assert.AreEqual(0, sub.Int32Field); + Assert.AreEqual(0, sub.Int64Field); + Assert.AreEqual(0, sub.UInt8Field); + Assert.AreEqual(0, sub.UInt16Field); + Assert.AreEqual(0, sub.UInt32Field); + Assert.AreEqual(0, sub.UInt64Field); + Assert.AreEqual(0f, sub.Float32Field); + Assert.AreEqual(0.0, sub.Float64Field); + Assert.AreEqual(string.Empty, sub.TextField); + Assert.AreEqual(Data(string.Empty), sub.DataField); + { + var subsub = sub.StructField; + Assert.AreEqual(string.Empty, subsub.TextField); + Assert.AreEqual(string.Empty, subsub.StructField.TextField); + } + Assert.AreEqual(0, sub.VoidList); + Assert.AreEqual(0, sub.BoolList.Count); + Assert.AreEqual(0, sub.Int8List.Count); + Assert.AreEqual(0, sub.Int16List.Count); + Assert.AreEqual(0, sub.Int32List.Count); + Assert.AreEqual(0, sub.Int64List.Count); + Assert.AreEqual(0, sub.UInt8List.Count); + Assert.AreEqual(0, sub.UInt16List.Count); + Assert.AreEqual(0, sub.UInt32List.Count); + Assert.AreEqual(0, sub.UInt64List.Count); + Assert.AreEqual(0, sub.Float32List.Count); + Assert.AreEqual(0, sub.Float64List.Count); + Assert.AreEqual(0, sub.TextList.Count); + Assert.AreEqual(0, sub.DataList.Count); + Assert.AreEqual(0, sub.StructList.Count); + } + + Assert.AreEqual(0, s.VoidList); + Assert.AreEqual(0, s.BoolList.Count); + Assert.AreEqual(0, s.Int8List.Count); + Assert.AreEqual(0, s.Int16List.Count); + Assert.AreEqual(0, s.Int32List.Count); + Assert.AreEqual(0, s.Int64List.Count); + Assert.AreEqual(0, s.UInt8List.Count); + Assert.AreEqual(0, s.UInt16List.Count); + Assert.AreEqual(0, s.UInt32List.Count); + Assert.AreEqual(0, s.UInt64List.Count); + Assert.AreEqual(0, s.Float32List.Count); + Assert.AreEqual(0, s.Float64List.Count); + Assert.AreEqual(0, s.TextList.Count); + Assert.AreEqual(0, s.DataList.Count); + Assert.AreEqual(0, s.StructList.Count); + } + + public static void InitListDefaults(TestLists lists) + { + lists.List0 = new TestLists.Struct0[] + { + new TestLists.Struct0(), + new TestLists.Struct0() + }; + lists.List1 = new TestLists.Struct1[] + { + new TestLists.Struct1() { F = true }, + new TestLists.Struct1() { F = false }, + new TestLists.Struct1() { F = true }, + new TestLists.Struct1() { F = true } + }; + lists.List8 = new TestLists.Struct8[] + { + new TestLists.Struct8() { F = 123 }, + new TestLists.Struct8() { F = 45 } + }; + lists.List16 = new TestLists.Struct16[] + { + new TestLists.Struct16() { F = 12345 }, + new TestLists.Struct16() { F = 6789 } + }; + lists.List32 = new TestLists.Struct32[] + { + new TestLists.Struct32() { F = 123456789 }, + new TestLists.Struct32() { F = 234567890 } + }; + lists.List64 = new TestLists.Struct64[] + { + new TestLists.Struct64() { F = 1234567890123456 }, + new TestLists.Struct64() { F = 2345678901234567} + }; + lists.ListP = new TestLists.StructP[] + { + new TestLists.StructP() { F = "foo" }, + new TestLists.StructP() { F = "bar" } + }; + + lists.Int32ListList = new int[][] + { + new int[] { 1, 2, 3 }, + new int[] { 4, 5 }, + new int[] { 12341234 } + }; + + lists.TextListList = new string[][] + { + new string[] { "foo", "bar" }, + new string[] { "baz" }, + new string[] { "qux", "corge" } + }; + + lists.StructListList = new TestAllTypes[][] + { + new TestAllTypes[] + { + new TestAllTypes() { Int32Field = 123 }, + new TestAllTypes() { Int32Field = 456 } + }, + new TestAllTypes[] + { + new TestAllTypes() { Int32Field = 789 } + } + }; + } + + public static void CheckListDefault(TestLists lists) + { + Assert.AreEqual(2, lists.List0.Count); + Assert.AreEqual(4, lists.List1.Count); + Assert.AreEqual(2, lists.List8.Count); + Assert.AreEqual(2, lists.List16.Count); + Assert.AreEqual(2, lists.List32.Count); + Assert.AreEqual(2, lists.List64.Count); + Assert.AreEqual(2, lists.ListP.Count); + + Assert.IsTrue(lists.List1[0].F); + Assert.IsFalse(lists.List1[1].F); + Assert.IsTrue(lists.List1[2].F); + Assert.IsTrue(lists.List1[3].F); + + Assert.AreEqual(123, lists.List8[0].F); + Assert.AreEqual(45, lists.List8[1].F); + + Assert.AreEqual(12345, lists.List16[0].F); + Assert.AreEqual(6789, lists.List16[1].F); + + Assert.AreEqual(123456789, lists.List32[0].F); + Assert.AreEqual(234567890, lists.List32[1].F); + + Assert.AreEqual(1234567890123456, lists.List64[0].F); + Assert.AreEqual(2345678901234567, lists.List64[1].F); + + Assert.AreEqual("foo", lists.ListP[0].F); + Assert.AreEqual("bar", lists.ListP[1].F); + + Assert.AreEqual(3, lists.Int32ListList.Count); + Assert.IsTrue(lists.Int32ListList[0].SequenceEqual(new int[] { 1, 2, 3 })); + Assert.IsTrue(lists.Int32ListList[1].SequenceEqual(new int[] { 4, 5 })); + Assert.IsTrue(lists.Int32ListList[2].SequenceEqual(new int[] { 12341234 })); + + Assert.AreEqual(3, lists.TextListList.Count); + Assert.IsTrue(lists.TextListList[0].SequenceEqual(new string[] { "foo", "bar" })); + Assert.IsTrue(lists.TextListList[1].SequenceEqual(new string[] { "baz" })); + Assert.IsTrue(lists.TextListList[2].SequenceEqual(new string[] { "qux", "corge" })); + + Assert.AreEqual(2, lists.StructListList.Count); + Assert.AreEqual(2, lists.StructListList[0].Count); + Assert.AreEqual(123, lists.StructListList[0][0]); + Assert.AreEqual(456, lists.StructListList[0][1]); + Assert.AreEqual(1, lists.StructListList[1].Count); + Assert.AreEqual(789, lists.StructListList[1][0]); + } + } + + class Counters + { + public int CallCount; + public int HandleCount; + } + + #region TestInterface + class TestInterfaceImpl : ITestInterface + { + readonly TaskCompletionSource _tcs; + protected readonly Counters _counters; + + public TestInterfaceImpl(Counters counters, TaskCompletionSource tcs) + { + _tcs = tcs; + _counters = counters; + } + + public TestInterfaceImpl(Counters counters) + { + _counters = counters; + } + + public Task Bar(CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } + + public Task Baz(TestAllTypes s, CancellationToken cancellationToken) + { + Interlocked.Increment(ref _counters.CallCount); + Common.CheckTestMessage(s); + return Task.CompletedTask; + } + + public void Dispose() + { + _tcs?.SetResult(0); + } + + public virtual Task Foo(uint i, bool j, CancellationToken cancellationToken) + { + Interlocked.Increment(ref _counters.CallCount); + Assert.AreEqual(123u, i); + Assert.IsTrue(j); + return Task.FromResult("foo"); + } + } + + #endregion TestInterface + + #region TestExtends + class TestExtendsImpl : TestInterfaceImpl, ITestExtends + { + public TestExtendsImpl(Counters counters) : base(counters) + { + } + + public override Task Foo(uint i, bool j, CancellationToken cancellationToken) + { + Interlocked.Increment(ref _counters.CallCount); + Assert.AreEqual(321u, i); + Assert.IsFalse(j); + return Task.FromResult("bar"); + } + + public Task Corge(TestAllTypes s, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } + + public Task Grault(CancellationToken cancellationToken) + { + Interlocked.Increment(ref _counters.CallCount); + var result = new TestAllTypes(); + Common.InitTestMessage(result); + return Task.FromResult(result); + } + + public Task Qux(CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } + } + #endregion TestExtends + + #region TestPipeline + class TestPipelineImpl : ITestPipeline + { + protected readonly Counters _counters; + + public TestPipelineImpl(Counters counters) + { + _counters = counters; + } + + public void Dispose() + { + } + + public async Task<(string, TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + Assert.AreEqual(234u, n); + var s = await inCap.Cast(true).Foo(123, true, cancellationToken_); + Assert.AreEqual("foo", s); + return ("bar", new TestPipeline.AnyBox() { Cap = BareProxy.FromImpl(new TestExtendsImpl(_counters)) }); + } + + public async Task<(string, TestPipeline.Box)> GetCap(uint n, ITestInterface inCap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + Assert.AreEqual(234u, n); + var s = await inCap.Foo(123, true, cancellationToken_); + Assert.AreEqual("foo", s); + return ("bar", new TestPipeline.Box() { Cap = new TestExtendsImpl(_counters) }); + } + + public Task TestPointers(ITestInterface cap, AnyPointer obj, IReadOnlyList list, CancellationToken cancellationToken_) + { + throw new NotImplementedException(); + } + } + #endregion TestPipeline + + #region TestCallOrder + class TestCallOrderImpl : ITestCallOrder + { + ILogger Logger { get; } = Logging.CreateLogger(); + + public uint Count { get; set; } + + public void Dispose() + { + } + + public Task GetCallSequence(uint expected, CancellationToken cancellationToken_) + { + return Task.FromResult(Count++); + } + } + #endregion TestCallOrder + + #region TestTailCaller + class TestTailCaller : ITestTailCaller + { + public void Dispose() + { + } + + public Task Foo(int i, ITestTailCallee callee, CancellationToken cancellationToken_) + { + return callee.Foo(i, "from TestTailCaller", cancellationToken_); + } + } + #endregion TestTailCaller + + #region TestTailCaller + class TestTailCallerImpl : ITestTailCaller + { + readonly Counters _counters; + + public TestTailCallerImpl(Counters counters) + { + _counters = counters; + } + + public void Dispose() + { + } + + public Task Foo(int i, ITestTailCallee callee, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + + using (callee) + { + return callee.Foo(i, "from TestTailCaller", cancellationToken_); + } + } + } + #endregion TestTailCaller + + #region TestTailCallee + class TestTailCalleeImpl : ITestTailCallee + { + readonly Counters _counters; + + public TestTailCalleeImpl(Counters counters) + { + _counters = counters; + } + + public void Dispose() + { + } + + public Task Foo(int i, string t, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + + var result = new TestTailCallee.TailResult() + { + I = (uint)i, + T = t, + C = new TestCallOrderImpl() + }; + return Task.FromResult(result); + } + } + #endregion TestTailCallee + + #region TestMoreStuff + class TestMoreStuffImpl : ITestMoreStuff + { + readonly TaskCompletionSource _echoAllowed = new TaskCompletionSource(); + readonly Counters _counters; + + public TestMoreStuffImpl(Counters counters) + { + _counters = counters; + } + + public ITestInterface ClientToHold { get; set; } + + public void EnableEcho() + { + _echoAllowed.SetResult(0); + } + + public async Task CallFoo(ITestInterface cap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + using (cap) + { + string s = await cap.Foo(123, true, cancellationToken_); + Assert.AreEqual("foo", s); + } + return "bar"; + } + + public async Task CallFooWhenResolved(ITestInterface cap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + await ((Proxy)cap).WhenResolved; + string s = await cap.Foo(123, true, cancellationToken_); + Assert.AreEqual("foo", s); + return "bar"; + } + + public async Task CallHeld(CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + + string s = await ClientToHold.Foo(123, true, cancellationToken_); + Assert.AreEqual("foo", s); + return "bar"; + } + + public void Dispose() + { + ClientToHold?.Dispose(); + } + + public Task Echo(ITestCallOrder cap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + return Task.FromResult(cap); + } + + public Task ExpectCancel(ITestInterface cap, CancellationToken cancellationToken_) + { + return NeverReturn(cap, cancellationToken_); + } + + public Task GetCallSequence(uint expected, CancellationToken cancellationToken_) + { + return Task.FromResult((uint)(Interlocked.Increment(ref _counters.CallCount) - 1)); + } + + public Task GetEnormousString(CancellationToken cancellationToken_) + { + return Task.FromResult(new string(new char[100000000])); + } + + public Task GetHandle(CancellationToken cancellationToken_) + { + return Task.FromResult((ITestHandle)new TestHandleImpl(_counters)); + } + + public Task GetHeld(CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + return Task.FromResult(ClientToHold); + } + + public Task GetNull(CancellationToken cancellationToken_) + { + return Task.FromResult(default(ITestMoreStuff)); + } + + public Task Hold(ITestInterface cap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + + ClientToHold?.Dispose(); + ClientToHold = cap; + + return Task.CompletedTask; + } + + public Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_) + { + throw new NotImplementedException(); + } + + public Task MethodWithNullDefault(string a, ITestInterface b, CancellationToken cancellationToken_) + { + throw new NotImplementedException(); + } + + public async Task NeverReturn(ITestInterface cap, CancellationToken cancellationToken_) + { + Interlocked.Increment(ref _counters.CallCount); + + try + { + var tcs = new TaskCompletionSource(); + using (cancellationToken_.Register(() => tcs.SetResult(0))) + { + await tcs.Task; + throw new TaskCanceledException(); + } + } + finally + { + cap.Dispose(); + } + } + } + + #endregion TestMoreStuff + + #region TestHandle + class TestHandleImpl : ITestHandle, IDisposable + { + readonly Counters _counters; + + public TestHandleImpl(Counters counters) + { + _counters = counters; + Interlocked.Increment(ref _counters.HandleCount); + } + + public void Dispose() + { + Interlocked.Decrement(ref _counters.HandleCount); + } + } + #endregion TestHandle +} diff --git a/Capnp.Net.Runtime.Tests/TestInterfaces.cs b/Capnp.Net.Runtime.Tests/TestInterfaces.cs new file mode 100644 index 0000000..3d22d54 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/TestInterfaces.cs @@ -0,0 +1,102 @@ +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Net.Runtime.Tests.ManualImpls +{ + // [Skeleton(typeof(TestInterfaceSkeleton))] + // [Proxy(typeof(TestInterfaceProxy))] + // interface ITestInterface: IDisposable + // { + // Task Foo(uint i, bool j); + // Task Bar(); + // Task Baz(int s); + // } + + // [Skeleton(typeof(TestExtendsSkeleton))] + // [Proxy(typeof(TestExtendsProxy))] + // interface ITestExtends: ITestInterface, IDisposable + // { + // void Qux(); + // Task Corge(int x); + // Task Grault(); + // } + + // interface ITestExtends2: ITestExtends, IDisposable + // { + // } + + // struct Box + // { + // public ITestExtends Cap { get; set; } + // } + + // struct AnyBox + // { + // public object Cap { get; set; } + // } + + // [Skeleton(typeof(TestPipelineSkeleton))] + // [Proxy(typeof(TestPipelineProxy))] + // interface ITestPipeline: IDisposable + // { + // Task<(string, Box)> GetCap(uint n, ITestInterface inCap); + // Task TestPointers(ITestExtends cap, DeserializerState obj, IReadOnlyList list); + // Task<(string, AnyBox)> GetAnyCap(uint n, object inCap); + // } + + // [Skeleton(typeof(TestCallOrderSkeleton))] + // [Proxy(typeof(TestCallOrderProxy))] + // interface ITestCallOrder : IDisposable + // { + // Task GetCallSequence(uint expected); + // } + + // struct TailResult + // { + // public uint I { get; set; } + // public string T { get; set; } + // public ITestCallOrder C { get; set; } + //} + + // [Skeleton(typeof(TestTailCalleeSkeleton))] + // [Proxy(typeof(TestTailCalleeProxy))] + // interface ITestTailCallee: IDisposable + // { + // Task Foo(int i, string t); + // } + + // [Skeleton(typeof(TestTailCallerSkeleton))] + // [Proxy(typeof(TestTailCallerProxy))] + // interface ITestTailCaller: IDisposable + // { + // Task Foo(int i, ITestTailCallee c); + // } + + // [Skeleton(typeof(TestHandleSkeleton))] + // [Proxy(typeof(TestHandleProxy))] + // interface ITestHandle: IDisposable { } + + + // [Skeleton(typeof(TestMoreStuffSkeleton))] + // [Proxy(typeof(TestMoreStuffProxy))] + // interface ITestMoreStuff: ITestCallOrder + // { + // Task CallFoo(ITestInterface cap); + // Task CallFooWhenResolved(ITestInterface cap); + // Task NeverReturn(ITestInterface cap, CancellationToken ct); + // Task Hold(ITestInterface cap); + // Task CallHeld(); + // Task GetHeld(); + // Task Echo(ITestCallOrder cap); + // Task ExpectCancel(ITestInterface cap, CancellationToken ct); + // Task<(string, string)> MethodWithDefaults(string a, uint b, string c); + // void MethodWithNullDefault(string a, ITestInterface b); + // Task GetHandle(); + // Task GetNull(); + // Task GetEnormousString(); + // } +} + diff --git a/Capnp.Net.Runtime.Tests/WirePointerTests.cs b/Capnp.Net.Runtime.Tests/WirePointerTests.cs new file mode 100644 index 0000000..ba7cd91 --- /dev/null +++ b/Capnp.Net.Runtime.Tests/WirePointerTests.cs @@ -0,0 +1,228 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Capnp.Net.Runtime.Tests +{ + [TestClass] + public class WirePointerTests + { + [TestMethod] + public void Struct() + { + var wp = default(WirePointer); + wp.BeginStruct(17, 71); + wp.Offset = -321; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.Struct, wp.Kind); + Assert.AreEqual(17, wp.StructDataCount); + Assert.AreEqual(71, wp.StructPtrCount); + Assert.AreEqual(-321, wp.Offset); + } + + [TestMethod] + public void StructAsListTag() + { + var wp = default(WirePointer); + wp.BeginStruct(17, 71); + wp.ListOfStructsElementCount = 555; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.Struct, wp.Kind); + Assert.AreEqual(17, wp.StructDataCount); + Assert.AreEqual(71, wp.StructPtrCount); + Assert.AreEqual(555, wp.ListOfStructsElementCount); + } + + [TestMethod] + public void ListOfEmpty() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfEmpty, 112); + wp.Offset = 517; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfEmpty, wp.ListKind); + Assert.AreEqual(112, wp.ListElementCount); + Assert.AreEqual(517, wp.Offset); + } + + [TestMethod] + public void ListOfBits() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfBits, 888); + wp.Offset = -919; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfBits, wp.ListKind); + Assert.AreEqual(888, wp.ListElementCount); + Assert.AreEqual(-919, wp.Offset); + } + + [TestMethod] + public void ListOfBytes() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfBytes, 1023); + wp.Offset = 1027; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfBytes, wp.ListKind); + Assert.AreEqual(1023, wp.ListElementCount); + Assert.AreEqual(1027, wp.Offset); + } + + [TestMethod] + public void ListOfShorts() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfShorts, 12345); + wp.Offset = -12345; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfShorts, wp.ListKind); + Assert.AreEqual(12345, wp.ListElementCount); + Assert.AreEqual(-12345, wp.Offset); + } + + [TestMethod] + public void ListOfInts() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfInts, 89400); + wp.Offset = 111000; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfInts, wp.ListKind); + Assert.AreEqual(89400, wp.ListElementCount); + Assert.AreEqual(111000, wp.Offset); + } + + [TestMethod] + public void ListOfLongs() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfLongs, 34500); + wp.Offset = 8100999; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfLongs, wp.ListKind); + Assert.AreEqual(34500, wp.ListElementCount); + Assert.AreEqual(8100999, wp.Offset); + } + + [TestMethod] + public void ListOfPointers() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfPointers, 12999777); + wp.Offset = -11222000; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfPointers, wp.ListKind); + Assert.AreEqual(12999777, wp.ListElementCount); + Assert.AreEqual(-11222000, wp.Offset); + } + + [TestMethod] + public void ListOfStructs() + { + var wp = default(WirePointer); + wp.BeginList(ListKind.ListOfStructs, 77000); + wp.Offset = -99888; + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.List, wp.Kind); + Assert.AreEqual(ListKind.ListOfStructs, wp.ListKind); + Assert.AreEqual(77000, wp.ListElementCount); + Assert.AreEqual(-99888, wp.Offset); + } + + [TestMethod] + public void Far() + { + var wp = default(WirePointer); + wp.SetFarPointer(29, 777, false); + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.Far, wp.Kind); + Assert.IsFalse(wp.IsDoubleFar); + Assert.AreEqual(29u, wp.TargetSegmentIndex); + Assert.AreEqual(777, wp.LandingPadOffset); + } + + [TestMethod] + public void DoubleFar() + { + var wp = default(WirePointer); + wp.SetFarPointer(92, 891, true); + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.Far, wp.Kind); + Assert.IsTrue(wp.IsDoubleFar); + Assert.AreEqual(92u, wp.TargetSegmentIndex); + Assert.AreEqual(891, wp.LandingPadOffset); + } + + [TestMethod] + public void Capability() + { + var wp = default(WirePointer); + wp.SetCapability(123456); + ulong v = wp; + + wp = v; + Assert.AreEqual(PointerKind.Other, wp.Kind); + Assert.AreEqual(0u, wp.OtherPointerKind); + Assert.AreEqual(123456u, wp.CapabilityIndex); + } + + [TestMethod] + public void OffsetOutOfBounds() + { + var wp = default(WirePointer); + wp.BeginStruct(12345, 54321); + Assert.ThrowsException(() => wp.Offset = 1 << 30); + Assert.ThrowsException(() => wp.Offset = int.MinValue); + } + + [TestMethod] + public void ElementCountOutOfBounds() + { + var wp = default(WirePointer); + Assert.ThrowsException( + () => wp.BeginList(ListKind.ListOfBytes, 1 << 29)); + wp.BeginList(ListKind.ListOfInts, 1 << 29 - 1); + Assert.ThrowsException( + () => wp.BeginList(ListKind.ListOfBytes, -1)); + } + + [TestMethod] + public void FarPointerOffsetOutOfBounds() + { + var wp = default(WirePointer); + Assert.ThrowsException( + () => wp.SetFarPointer(1, 1 << 29, false)); + } + } +} diff --git a/Capnp.Net.Runtime.Tests/test.cs b/Capnp.Net.Runtime.Tests/test.cs new file mode 100644 index 0000000..d20da0b --- /dev/null +++ b/Capnp.Net.Runtime.Tests/test.cs @@ -0,0 +1,16200 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnproto_test.Capnp.Test +{ + public enum TestEnum : ushort + { + foo, + bar, + baz, + qux, + quux, + corge, + grault, + garply + } + + public class TestAllTypes : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BoolField = reader.BoolField; + Int8Field = reader.Int8Field; + Int16Field = reader.Int16Field; + Int32Field = reader.Int32Field; + Int64Field = reader.Int64Field; + UInt8Field = reader.UInt8Field; + UInt16Field = reader.UInt16Field; + UInt32Field = reader.UInt32Field; + UInt64Field = reader.UInt64Field; + Float32Field = reader.Float32Field; + Float64Field = reader.Float64Field; + TextField = reader.TextField; + DataField = reader.DataField; + StructField = CapnpSerializable.Create(reader.StructField); + EnumField = reader.EnumField; + VoidList = reader.VoidList; + BoolList = reader.BoolList; + Int8List = reader.Int8List; + Int16List = reader.Int16List; + Int32List = reader.Int32List; + Int64List = reader.Int64List; + UInt8List = reader.UInt8List; + UInt16List = reader.UInt16List; + UInt32List = reader.UInt32List; + UInt64List = reader.UInt64List; + Float32List = reader.Float32List; + Float64List = reader.Float64List; + TextList = reader.TextList; + DataList = reader.DataList; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + EnumList = reader.EnumList; + InterfaceList = reader.InterfaceList; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BoolField = BoolField; + writer.Int8Field = Int8Field; + writer.Int16Field = Int16Field; + writer.Int32Field = Int32Field; + writer.Int64Field = Int64Field; + writer.UInt8Field = UInt8Field; + writer.UInt16Field = UInt16Field; + writer.UInt32Field = UInt32Field; + writer.UInt64Field = UInt64Field; + writer.Float32Field = Float32Field; + writer.Float64Field = Float64Field; + writer.TextField = TextField; + writer.DataField.Init(DataField); + StructField?.serialize(writer.StructField); + writer.EnumField = EnumField; + writer.VoidList.Init(VoidList); + writer.BoolList.Init(BoolList); + writer.Int8List.Init(Int8List); + writer.Int16List.Init(Int16List); + writer.Int32List.Init(Int32List); + writer.Int64List.Init(Int64List); + writer.UInt8List.Init(UInt8List); + writer.UInt16List.Init(UInt16List); + writer.UInt32List.Init(UInt32List); + writer.UInt64List.Init(UInt64List); + writer.Float32List.Init(Float32List); + writer.Float64List.Init(Float64List); + writer.TextList.Init(TextList); + writer.DataList.Init(DataList, (_s1, _v1) => _s1.Init(_v1)); + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + writer.EnumList.Init(EnumList); + writer.InterfaceList.Init(InterfaceList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool BoolField + { + get; + set; + } + + public sbyte Int8Field + { + get; + set; + } + + public short Int16Field + { + get; + set; + } + + public int Int32Field + { + get; + set; + } + + public long Int64Field + { + get; + set; + } + + public byte UInt8Field + { + get; + set; + } + + public ushort UInt16Field + { + get; + set; + } + + public uint UInt32Field + { + get; + set; + } + + public ulong UInt64Field + { + get; + set; + } + + public float Float32Field + { + get; + set; + } + + public double Float64Field + { + get; + set; + } + + public string TextField + { + get; + set; + } + + public IReadOnlyList DataField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes StructField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get; + set; + } + + public int VoidList + { + get; + set; + } + + public IReadOnlyList BoolList + { + get; + set; + } + + public IReadOnlyList Int8List + { + get; + set; + } + + public IReadOnlyList Int16List + { + get; + set; + } + + public IReadOnlyList Int32List + { + get; + set; + } + + public IReadOnlyList Int64List + { + get; + set; + } + + public IReadOnlyList UInt8List + { + get; + set; + } + + public IReadOnlyList UInt16List + { + get; + set; + } + + public IReadOnlyList UInt32List + { + get; + set; + } + + public IReadOnlyList UInt64List + { + get; + set; + } + + public IReadOnlyList Float32List + { + get; + set; + } + + public IReadOnlyList Float64List + { + get; + set; + } + + public IReadOnlyList TextList + { + get; + set; + } + + public IReadOnlyList> DataList + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public IReadOnlyList EnumList + { + get; + set; + } + + public int InterfaceList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BoolField => ctx.ReadDataBool(0UL, false); + public sbyte Int8Field => ctx.ReadDataSByte(8UL, (sbyte)0); + public short Int16Field => ctx.ReadDataShort(16UL, (short)0); + public int Int32Field => ctx.ReadDataInt(32UL, 0); + public long Int64Field => ctx.ReadDataLong(64UL, 0L); + public byte UInt8Field => ctx.ReadDataByte(128UL, (byte)0); + public ushort UInt16Field => ctx.ReadDataUShort(144UL, (ushort)0); + public uint UInt32Field => ctx.ReadDataUInt(160UL, 0U); + public ulong UInt64Field => ctx.ReadDataULong(192UL, 0UL); + public float Float32Field => ctx.ReadDataFloat(256UL, 0F); + public double Float64Field => ctx.ReadDataDouble(320UL, 0); + public string TextField => ctx.ReadText(0, ""); + public IReadOnlyList DataField => ctx.ReadList(1).CastByte(); + public Capnproto_test.Capnp.Test.TestAllTypes.READER StructField => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestEnum EnumField => (Capnproto_test.Capnp.Test.TestEnum)ctx.ReadDataUShort(288UL, (ushort)0); + public int VoidList => ctx.ReadList(3).Count; + public IReadOnlyList BoolList => ctx.ReadList(4).CastBool(); + public IReadOnlyList Int8List => ctx.ReadList(5).CastSByte(); + public IReadOnlyList Int16List => ctx.ReadList(6).CastShort(); + public IReadOnlyList Int32List => ctx.ReadList(7).CastInt(); + public IReadOnlyList Int64List => ctx.ReadList(8).CastLong(); + public IReadOnlyList UInt8List => ctx.ReadList(9).CastByte(); + public IReadOnlyList UInt16List => ctx.ReadList(10).CastUShort(); + public IReadOnlyList UInt32List => ctx.ReadList(11).CastUInt(); + public IReadOnlyList UInt64List => ctx.ReadList(12).CastULong(); + public IReadOnlyList Float32List => ctx.ReadList(13).CastFloat(); + public IReadOnlyList Float64List => ctx.ReadList(14).CastDouble(); + public IReadOnlyList TextList => ctx.ReadList(15).CastText2(); + public IReadOnlyList> DataList => ctx.ReadList(16).CastData(); + public IReadOnlyList StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public IReadOnlyList EnumList => ctx.ReadList(18).CastEnums(_0 => (Capnproto_test.Capnp.Test.TestEnum)_0); + public int InterfaceList => ctx.ReadList(19).Count; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 20); + } + + public bool BoolField + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public sbyte Int8Field + { + get => this.ReadDataSByte(8UL, (sbyte)0); + set => this.WriteData(8UL, value, (sbyte)0); + } + + public short Int16Field + { + get => this.ReadDataShort(16UL, (short)0); + set => this.WriteData(16UL, value, (short)0); + } + + public int Int32Field + { + get => this.ReadDataInt(32UL, 0); + set => this.WriteData(32UL, value, 0); + } + + public long Int64Field + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + + public byte UInt8Field + { + get => this.ReadDataByte(128UL, (byte)0); + set => this.WriteData(128UL, value, (byte)0); + } + + public ushort UInt16Field + { + get => this.ReadDataUShort(144UL, (ushort)0); + set => this.WriteData(144UL, value, (ushort)0); + } + + public uint UInt32Field + { + get => this.ReadDataUInt(160UL, 0U); + set => this.WriteData(160UL, value, 0U); + } + + public ulong UInt64Field + { + get => this.ReadDataULong(192UL, 0UL); + set => this.WriteData(192UL, value, 0UL); + } + + public float Float32Field + { + get => this.ReadDataFloat(256UL, 0F); + set => this.WriteData(256UL, value, 0F); + } + + public double Float64Field + { + get => this.ReadDataDouble(320UL, 0); + set => this.WriteData(320UL, value, 0); + } + + public string TextField + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfPrimitivesSerializer DataField + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get => (Capnproto_test.Capnp.Test.TestEnum)this.ReadDataUShort(288UL, (ushort)0); + set => this.WriteData(288UL, (ushort)value, (ushort)0); + } + + public ListOfEmptySerializer VoidList + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfBitsSerializer BoolList + { + get => BuildPointer(4); + set => Link(4, value); + } + + public ListOfPrimitivesSerializer Int8List + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfPrimitivesSerializer Int16List + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPrimitivesSerializer Int32List + { + get => BuildPointer>(7); + set => Link(7, value); + } + + public ListOfPrimitivesSerializer Int64List + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPrimitivesSerializer UInt8List + { + get => BuildPointer>(9); + set => Link(9, value); + } + + public ListOfPrimitivesSerializer UInt16List + { + get => BuildPointer>(10); + set => Link(10, value); + } + + public ListOfPrimitivesSerializer UInt32List + { + get => BuildPointer>(11); + set => Link(11, value); + } + + public ListOfPrimitivesSerializer UInt64List + { + get => BuildPointer>(12); + set => Link(12, value); + } + + public ListOfPrimitivesSerializer Float32List + { + get => BuildPointer>(13); + set => Link(13, value); + } + + public ListOfPrimitivesSerializer Float64List + { + get => BuildPointer>(14); + set => Link(14, value); + } + + public ListOfTextSerializer TextList + { + get => BuildPointer(15); + set => Link(15, value); + } + + public ListOfPointersSerializer> DataList + { + get => BuildPointer>>(16); + set => Link(16, value); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(17); + set => Link(17, value); + } + + public ListOfPrimitivesSerializer EnumList + { + get => BuildPointer>(18); + set => Link(18, value); + } + + public ListOfEmptySerializer InterfaceList + { + get => BuildPointer(19); + set => Link(19, value); + } + } + } + + public class TestDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BoolField = reader.BoolField; + Int8Field = reader.Int8Field; + Int16Field = reader.Int16Field; + Int32Field = reader.Int32Field; + Int64Field = reader.Int64Field; + UInt8Field = reader.UInt8Field; + UInt16Field = reader.UInt16Field; + UInt32Field = reader.UInt32Field; + UInt64Field = reader.UInt64Field; + Float32Field = reader.Float32Field; + Float64Field = reader.Float64Field; + TextField = reader.TextField; + DataField = reader.DataField; + StructField = CapnpSerializable.Create(reader.StructField); + EnumField = reader.EnumField; + VoidList = reader.VoidList; + BoolList = reader.BoolList; + Int8List = reader.Int8List; + Int16List = reader.Int16List; + Int32List = reader.Int32List; + Int64List = reader.Int64List; + UInt8List = reader.UInt8List; + UInt16List = reader.UInt16List; + UInt32List = reader.UInt32List; + UInt64List = reader.UInt64List; + Float32List = reader.Float32List; + Float64List = reader.Float64List; + TextList = reader.TextList; + DataList = reader.DataList; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + EnumList = reader.EnumList; + InterfaceList = reader.InterfaceList; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BoolField = BoolField; + writer.Int8Field = Int8Field; + writer.Int16Field = Int16Field; + writer.Int32Field = Int32Field; + writer.Int64Field = Int64Field; + writer.UInt8Field = UInt8Field; + writer.UInt16Field = UInt16Field; + writer.UInt32Field = UInt32Field; + writer.UInt64Field = UInt64Field; + writer.Float32Field = Float32Field; + writer.Float64Field = Float64Field; + writer.TextField = TextField; + writer.DataField.Init(DataField); + StructField?.serialize(writer.StructField); + writer.EnumField = EnumField; + writer.VoidList.Init(VoidList); + writer.BoolList.Init(BoolList); + writer.Int8List.Init(Int8List); + writer.Int16List.Init(Int16List); + writer.Int32List.Init(Int32List); + writer.Int64List.Init(Int64List); + writer.UInt8List.Init(UInt8List); + writer.UInt16List.Init(UInt16List); + writer.UInt32List.Init(UInt32List); + writer.UInt64List.Init(UInt64List); + writer.Float32List.Init(Float32List); + writer.Float64List.Init(Float64List); + writer.TextList.Init(TextList); + writer.DataList.Init(DataList, (_s1, _v1) => _s1.Init(_v1)); + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + writer.EnumList.Init(EnumList); + writer.InterfaceList.Init(InterfaceList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + TextField = TextField ?? "foo"; + DataField = DataField ?? new byte[]{98, 97, 114}; + StructField = StructField ?? new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = true, Int8Field = -12, Int16Field = 3456, Int32Field = -78901234, Int64Field = 56789012345678L, UInt8Field = 90, UInt16Field = 1234, UInt32Field = 56789012U, UInt64Field = 345678901234567890UL, Float32Field = -1.25E-10F, Float64Field = 345, TextField = "baz", DataField = new byte[]{113, 117, 120}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "nested", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "really nested", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 3, BoolList = new bool[]{false, true, false, true, true}, Int8List = new sbyte[]{12, -34, -128, 127}, Int16List = new short[]{1234, -5678, -32768, 32767}, Int32List = new int[]{12345678, -90123456, -2147483648, 2147483647}, Int64List = new long[]{123456789012345L, -678901234567890L, -9223372036854775808L, 9223372036854775807L}, UInt8List = new byte[]{12, 34, 0, 255}, UInt16List = new ushort[]{1234, 5678, 0, 65535}, UInt32List = new uint[]{12345678U, 90123456U, 0U, 4294967295U}, UInt64List = new ulong[]{123456789012345UL, 678901234567890UL, 0UL, 18446744073709551615UL}, Float32List = new float[]{0F, 1234567F, 1E+37F, -1E+37F, 1E-37F, -1E-37F}, Float64List = new double[]{0, 123456789012345, 1E+306, -1E+306, 1E-306, -1E-306}, TextList = new string[]{"quux", "corge", "grault"}, DataList = new IReadOnlyList[]{new byte[]{103, 97, 114, 112, 108, 121}, new byte[]{119, 97, 108, 100, 111}, new byte[]{102, 114, 101, 100}}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 1", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 2", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 3", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{Capnproto_test.Capnp.Test.TestEnum.qux, Capnproto_test.Capnp.Test.TestEnum.bar, Capnproto_test.Capnp.Test.TestEnum.grault}, InterfaceList = 0}; + BoolList = BoolList ?? new bool[]{true, false, false, true}; + Int8List = Int8List ?? new sbyte[]{111, -111}; + Int16List = Int16List ?? new short[]{11111, -11111}; + Int32List = Int32List ?? new int[]{111111111, -111111111}; + Int64List = Int64List ?? new long[]{1111111111111111111L, -1111111111111111111L}; + UInt8List = UInt8List ?? new byte[]{111, 222}; + UInt16List = UInt16List ?? new ushort[]{33333, 44444}; + UInt32List = UInt32List ?? new uint[]{3333333333U}; + UInt64List = UInt64List ?? new ulong[]{11111111111111111111UL}; + Float32List = Float32List ?? new float[]{5555.5F, float.PositiveInfinity, float.NegativeInfinity, float.NaN}; + Float64List = Float64List ?? new double[]{7777.75, double.PositiveInfinity, double.NegativeInfinity, double.NaN}; + TextList = TextList ?? new string[]{"plugh", "xyzzy", "thud"}; + DataList = DataList ?? new IReadOnlyList[]{new byte[]{111, 111, 112, 115}, new byte[]{101, 120, 104, 97, 117, 115, 116, 101, 100}, new byte[]{114, 102, 99, 51, 48, 57, 50}}; + StructList = StructList ?? new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 1", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 2", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 3", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}; + EnumList = EnumList ?? new Capnproto_test.Capnp.Test.TestEnum[]{Capnproto_test.Capnp.Test.TestEnum.foo, Capnproto_test.Capnp.Test.TestEnum.garply}; + } + + public bool BoolField + { + get; + set; + } + + = true; + public sbyte Int8Field + { + get; + set; + } + + = -123; + public short Int16Field + { + get; + set; + } + + = -12345; + public int Int32Field + { + get; + set; + } + + = -12345678; + public long Int64Field + { + get; + set; + } + + = -123456789012345L; + public byte UInt8Field + { + get; + set; + } + + = 234; + public ushort UInt16Field + { + get; + set; + } + + = 45678; + public uint UInt32Field + { + get; + set; + } + + = 3456789012U; + public ulong UInt64Field + { + get; + set; + } + + = 12345678901234567890UL; + public float Float32Field + { + get; + set; + } + + = 1234.5F; + public double Float64Field + { + get; + set; + } + + = -1.23E+47; + public string TextField + { + get; + set; + } + + public IReadOnlyList DataField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes StructField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestEnum.corge; + public int VoidList + { + get; + set; + } + + = 6; + public IReadOnlyList BoolList + { + get; + set; + } + + public IReadOnlyList Int8List + { + get; + set; + } + + public IReadOnlyList Int16List + { + get; + set; + } + + public IReadOnlyList Int32List + { + get; + set; + } + + public IReadOnlyList Int64List + { + get; + set; + } + + public IReadOnlyList UInt8List + { + get; + set; + } + + public IReadOnlyList UInt16List + { + get; + set; + } + + public IReadOnlyList UInt32List + { + get; + set; + } + + public IReadOnlyList UInt64List + { + get; + set; + } + + public IReadOnlyList Float32List + { + get; + set; + } + + public IReadOnlyList Float64List + { + get; + set; + } + + public IReadOnlyList TextList + { + get; + set; + } + + public IReadOnlyList> DataList + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public IReadOnlyList EnumList + { + get; + set; + } + + public int InterfaceList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BoolField => ctx.ReadDataBool(0UL, true); + public sbyte Int8Field => ctx.ReadDataSByte(8UL, (sbyte)-123); + public short Int16Field => ctx.ReadDataShort(16UL, (short)-12345); + public int Int32Field => ctx.ReadDataInt(32UL, -12345678); + public long Int64Field => ctx.ReadDataLong(64UL, -123456789012345L); + public byte UInt8Field => ctx.ReadDataByte(128UL, (byte)234); + public ushort UInt16Field => ctx.ReadDataUShort(144UL, (ushort)45678); + public uint UInt32Field => ctx.ReadDataUInt(160UL, 3456789012U); + public ulong UInt64Field => ctx.ReadDataULong(192UL, 12345678901234567890UL); + public float Float32Field => ctx.ReadDataFloat(256UL, 1234.5F); + public double Float64Field => ctx.ReadDataDouble(320UL, -1.23E+47); + public string TextField => ctx.ReadText(0, "foo"); + public IReadOnlyList DataField => ctx.ReadList(1).CastByte(); + public Capnproto_test.Capnp.Test.TestAllTypes.READER StructField => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestEnum EnumField => (Capnproto_test.Capnp.Test.TestEnum)ctx.ReadDataUShort(288UL, (ushort)5); + public int VoidList => ctx.ReadList(3).Count; + public IReadOnlyList BoolList => ctx.ReadList(4).CastBool(); + public IReadOnlyList Int8List => ctx.ReadList(5).CastSByte(); + public IReadOnlyList Int16List => ctx.ReadList(6).CastShort(); + public IReadOnlyList Int32List => ctx.ReadList(7).CastInt(); + public IReadOnlyList Int64List => ctx.ReadList(8).CastLong(); + public IReadOnlyList UInt8List => ctx.ReadList(9).CastByte(); + public IReadOnlyList UInt16List => ctx.ReadList(10).CastUShort(); + public IReadOnlyList UInt32List => ctx.ReadList(11).CastUInt(); + public IReadOnlyList UInt64List => ctx.ReadList(12).CastULong(); + public IReadOnlyList Float32List => ctx.ReadList(13).CastFloat(); + public IReadOnlyList Float64List => ctx.ReadList(14).CastDouble(); + public IReadOnlyList TextList => ctx.ReadList(15).CastText2(); + public IReadOnlyList> DataList => ctx.ReadList(16).CastData(); + public IReadOnlyList StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public IReadOnlyList EnumList => ctx.ReadList(18).CastEnums(_0 => (Capnproto_test.Capnp.Test.TestEnum)_0); + public int InterfaceList => ctx.ReadList(19).Count; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 20); + } + + public bool BoolField + { + get => this.ReadDataBool(0UL, true); + set => this.WriteData(0UL, value, true); + } + + public sbyte Int8Field + { + get => this.ReadDataSByte(8UL, (sbyte)-123); + set => this.WriteData(8UL, value, (sbyte)-123); + } + + public short Int16Field + { + get => this.ReadDataShort(16UL, (short)-12345); + set => this.WriteData(16UL, value, (short)-12345); + } + + public int Int32Field + { + get => this.ReadDataInt(32UL, -12345678); + set => this.WriteData(32UL, value, -12345678); + } + + public long Int64Field + { + get => this.ReadDataLong(64UL, -123456789012345L); + set => this.WriteData(64UL, value, -123456789012345L); + } + + public byte UInt8Field + { + get => this.ReadDataByte(128UL, (byte)234); + set => this.WriteData(128UL, value, (byte)234); + } + + public ushort UInt16Field + { + get => this.ReadDataUShort(144UL, (ushort)45678); + set => this.WriteData(144UL, value, (ushort)45678); + } + + public uint UInt32Field + { + get => this.ReadDataUInt(160UL, 3456789012U); + set => this.WriteData(160UL, value, 3456789012U); + } + + public ulong UInt64Field + { + get => this.ReadDataULong(192UL, 12345678901234567890UL); + set => this.WriteData(192UL, value, 12345678901234567890UL); + } + + public float Float32Field + { + get => this.ReadDataFloat(256UL, 1234.5F); + set => this.WriteData(256UL, value, 1234.5F); + } + + public double Float64Field + { + get => this.ReadDataDouble(320UL, -1.23E+47); + set => this.WriteData(320UL, value, -1.23E+47); + } + + public string TextField + { + get => this.ReadText(0, "foo"); + set => this.WriteText(0, value, "foo"); + } + + public ListOfPrimitivesSerializer DataField + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get => (Capnproto_test.Capnp.Test.TestEnum)this.ReadDataUShort(288UL, (ushort)5); + set => this.WriteData(288UL, (ushort)value, (ushort)5); + } + + public ListOfEmptySerializer VoidList + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfBitsSerializer BoolList + { + get => BuildPointer(4); + set => Link(4, value); + } + + public ListOfPrimitivesSerializer Int8List + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfPrimitivesSerializer Int16List + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPrimitivesSerializer Int32List + { + get => BuildPointer>(7); + set => Link(7, value); + } + + public ListOfPrimitivesSerializer Int64List + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPrimitivesSerializer UInt8List + { + get => BuildPointer>(9); + set => Link(9, value); + } + + public ListOfPrimitivesSerializer UInt16List + { + get => BuildPointer>(10); + set => Link(10, value); + } + + public ListOfPrimitivesSerializer UInt32List + { + get => BuildPointer>(11); + set => Link(11, value); + } + + public ListOfPrimitivesSerializer UInt64List + { + get => BuildPointer>(12); + set => Link(12, value); + } + + public ListOfPrimitivesSerializer Float32List + { + get => BuildPointer>(13); + set => Link(13, value); + } + + public ListOfPrimitivesSerializer Float64List + { + get => BuildPointer>(14); + set => Link(14, value); + } + + public ListOfTextSerializer TextList + { + get => BuildPointer(15); + set => Link(15, value); + } + + public ListOfPointersSerializer> DataList + { + get => BuildPointer>>(16); + set => Link(16, value); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(17); + set => Link(17, value); + } + + public ListOfPrimitivesSerializer EnumList + { + get => BuildPointer>(18); + set => Link(18, value); + } + + public ListOfEmptySerializer InterfaceList + { + get => BuildPointer(19); + set => Link(19, value); + } + } + } + + public class TestAnyPointer : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyPointerField = CapnpSerializable.Create(reader.AnyPointerField); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyPointerField.SetObject(AnyPointerField); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyPointerField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyPointerField => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public DynamicSerializerState AnyPointerField + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class TestAnyOthers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyStructField = CapnpSerializable.Create(reader.AnyStructField); + AnyListField = reader.AnyListField.ToReadOnlyList(_ => (object)_); + CapabilityField = reader.CapabilityField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyStructField.SetObject(AnyStructField); + writer.AnyListField.SetObject(AnyListField); + writer.CapabilityField = CapabilityField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyStructField + { + get; + set; + } + + public IReadOnlyList AnyListField + { + get; + set; + } + + public BareProxy CapabilityField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyStructField => ctx.StructReadPointer(0); + public IReadOnlyList AnyListField => (IReadOnlyList)ctx.ReadList(1); + public BareProxy CapabilityField => ctx.ReadCap(2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public DynamicSerializerState AnyStructField + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState AnyListField + { + get => BuildPointer(1); + set => Link(1, value); + } + + public BareProxy CapabilityField + { + get => ReadCap(2); + set => LinkObject(2, value); + } + } + } + + public class TestOutOfOrder : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Qux = reader.Qux; + Grault = reader.Grault; + Bar = reader.Bar; + Foo = reader.Foo; + Corge = reader.Corge; + Waldo = reader.Waldo; + Quux = reader.Quux; + Garply = reader.Garply; + Baz = reader.Baz; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Qux = Qux; + writer.Grault = Grault; + writer.Bar = Bar; + writer.Foo = Foo; + writer.Corge = Corge; + writer.Waldo = Waldo; + writer.Quux = Quux; + writer.Garply = Garply; + writer.Baz = Baz; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public string Bar + { + get; + set; + } + + public string Foo + { + get; + set; + } + + public string Corge + { + get; + set; + } + + public string Waldo + { + get; + set; + } + + public string Quux + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public string Baz + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Qux => ctx.ReadText(0, ""); + public string Grault => ctx.ReadText(1, ""); + public string Bar => ctx.ReadText(2, ""); + public string Foo => ctx.ReadText(3, ""); + public string Corge => ctx.ReadText(4, ""); + public string Waldo => ctx.ReadText(5, ""); + public string Quux => ctx.ReadText(6, ""); + public string Garply => ctx.ReadText(7, ""); + public string Baz => ctx.ReadText(8, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 9); + } + + public string Qux + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Grault + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public string Bar + { + get => this.ReadText(2, ""); + set => this.WriteText(2, value, ""); + } + + public string Foo + { + get => this.ReadText(3, ""); + set => this.WriteText(3, value, ""); + } + + public string Corge + { + get => this.ReadText(4, ""); + set => this.WriteText(4, value, ""); + } + + public string Waldo + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + + public string Quux + { + get => this.ReadText(6, ""); + set => this.WriteText(6, value, ""); + } + + public string Garply + { + get => this.ReadText(7, ""); + set => this.WriteText(7, value, ""); + } + + public string Baz + { + get => this.ReadText(8, ""); + set => this.WriteText(8, value, ""); + } + } + } + + public class TestUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Union0 = CapnpSerializable.Create(reader.Union0); + Union1 = CapnpSerializable.Create(reader.Union1); + Union2 = CapnpSerializable.Create(reader.Union2); + Union3 = CapnpSerializable.Create(reader.Union3); + Bit0 = reader.Bit0; + Bit2 = reader.Bit2; + Bit3 = reader.Bit3; + Bit4 = reader.Bit4; + Bit5 = reader.Bit5; + Bit6 = reader.Bit6; + Bit7 = reader.Bit7; + Byte0 = reader.Byte0; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Union0?.serialize(writer.Union0); + Union1?.serialize(writer.Union1); + Union2?.serialize(writer.Union2); + Union3?.serialize(writer.Union3); + writer.Bit0 = Bit0; + writer.Bit2 = Bit2; + writer.Bit3 = Bit3; + writer.Bit4 = Bit4; + writer.Bit5 = Bit5; + writer.Bit6 = Bit6; + writer.Bit7 = Bit7; + writer.Byte0 = Byte0; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnion.@union0 Union0 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union1 Union1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union2 Union2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union3 Union3 + { + get; + set; + } + + public bool Bit0 + { + get; + set; + } + + public bool Bit2 + { + get; + set; + } + + public bool Bit3 + { + get; + set; + } + + public bool Bit4 + { + get; + set; + } + + public bool Bit5 + { + get; + set; + } + + public bool Bit6 + { + get; + set; + } + + public bool Bit7 + { + get; + set; + } + + public byte Byte0 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @union0.READER Union0 => new @union0.READER(ctx); + public @union1.READER Union1 => new @union1.READER(ctx); + public @union2.READER Union2 => new @union2.READER(ctx); + public @union3.READER Union3 => new @union3.READER(ctx); + public bool Bit0 => ctx.ReadDataBool(128UL, false); + public bool Bit2 => ctx.ReadDataBool(130UL, false); + public bool Bit3 => ctx.ReadDataBool(131UL, false); + public bool Bit4 => ctx.ReadDataBool(132UL, false); + public bool Bit5 => ctx.ReadDataBool(133UL, false); + public bool Bit6 => ctx.ReadDataBool(134UL, false); + public bool Bit7 => ctx.ReadDataBool(135UL, false); + public byte Byte0 => ctx.ReadDataByte(280UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(8, 2); + } + + public @union0.WRITER Union0 + { + get => Rewrap<@union0.WRITER>(); + } + + public @union1.WRITER Union1 + { + get => Rewrap<@union1.WRITER>(); + } + + public @union2.WRITER Union2 + { + get => Rewrap<@union2.WRITER>(); + } + + public @union3.WRITER Union3 + { + get => Rewrap<@union3.WRITER>(); + } + + public bool Bit0 + { + get => this.ReadDataBool(128UL, false); + set => this.WriteData(128UL, value, false); + } + + public bool Bit2 + { + get => this.ReadDataBool(130UL, false); + set => this.WriteData(130UL, value, false); + } + + public bool Bit3 + { + get => this.ReadDataBool(131UL, false); + set => this.WriteData(131UL, value, false); + } + + public bool Bit4 + { + get => this.ReadDataBool(132UL, false); + set => this.WriteData(132UL, value, false); + } + + public bool Bit5 + { + get => this.ReadDataBool(133UL, false); + set => this.WriteData(133UL, value, false); + } + + public bool Bit6 + { + get => this.ReadDataBool(134UL, false); + set => this.WriteData(134UL, value, false); + } + + public bool Bit7 + { + get => this.ReadDataBool(135UL, false); + set => this.WriteData(135UL, value, false); + } + + public byte Byte0 + { + get => this.ReadDataByte(280UL, (byte)0); + set => this.WriteData(280UL, value, (byte)0); + } + } + + public class @union0 : ICapnpSerializable + { + public enum WHICH : ushort + { + U0f0s0 = 0, + U0f0s1 = 1, + U0f0s8 = 2, + U0f0s16 = 3, + U0f0s32 = 4, + U0f0s64 = 5, + U0f0sp = 6, + U0f1s0 = 7, + U0f1s1 = 8, + U0f1s8 = 9, + U0f1s16 = 10, + U0f1s32 = 11, + U0f1s64 = 12, + U0f1sp = 13, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U0f0s0: + which = reader.which; + break; + case WHICH.U0f0s1: + U0f0s1 = reader.U0f0s1; + break; + case WHICH.U0f0s8: + U0f0s8 = reader.U0f0s8; + break; + case WHICH.U0f0s16: + U0f0s16 = reader.U0f0s16; + break; + case WHICH.U0f0s32: + U0f0s32 = reader.U0f0s32; + break; + case WHICH.U0f0s64: + U0f0s64 = reader.U0f0s64; + break; + case WHICH.U0f0sp: + U0f0sp = reader.U0f0sp; + break; + case WHICH.U0f1s0: + which = reader.which; + break; + case WHICH.U0f1s1: + U0f1s1 = reader.U0f1s1; + break; + case WHICH.U0f1s8: + U0f1s8 = reader.U0f1s8; + break; + case WHICH.U0f1s16: + U0f1s16 = reader.U0f1s16; + break; + case WHICH.U0f1s32: + U0f1s32 = reader.U0f1s32; + break; + case WHICH.U0f1s64: + U0f1s64 = reader.U0f1s64; + break; + case WHICH.U0f1sp: + U0f1sp = reader.U0f1sp; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U0f0s0: + break; + case WHICH.U0f0s1: + _content = false; + break; + case WHICH.U0f0s8: + _content = 0; + break; + case WHICH.U0f0s16: + _content = 0; + break; + case WHICH.U0f0s32: + _content = 0; + break; + case WHICH.U0f0s64: + _content = 0; + break; + case WHICH.U0f0sp: + _content = null; + break; + case WHICH.U0f1s0: + break; + case WHICH.U0f1s1: + _content = false; + break; + case WHICH.U0f1s8: + _content = 0; + break; + case WHICH.U0f1s16: + _content = 0; + break; + case WHICH.U0f1s32: + _content = 0; + break; + case WHICH.U0f1s64: + _content = 0; + break; + case WHICH.U0f1sp: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U0f0s0: + break; + case WHICH.U0f0s1: + writer.U0f0s1 = U0f0s1.Value; + break; + case WHICH.U0f0s8: + writer.U0f0s8 = U0f0s8.Value; + break; + case WHICH.U0f0s16: + writer.U0f0s16 = U0f0s16.Value; + break; + case WHICH.U0f0s32: + writer.U0f0s32 = U0f0s32.Value; + break; + case WHICH.U0f0s64: + writer.U0f0s64 = U0f0s64.Value; + break; + case WHICH.U0f0sp: + writer.U0f0sp = U0f0sp; + break; + case WHICH.U0f1s0: + break; + case WHICH.U0f1s1: + writer.U0f1s1 = U0f1s1.Value; + break; + case WHICH.U0f1s8: + writer.U0f1s8 = U0f1s8.Value; + break; + case WHICH.U0f1s16: + writer.U0f1s16 = U0f1s16.Value; + break; + case WHICH.U0f1s32: + writer.U0f1s32 = U0f1s32.Value; + break; + case WHICH.U0f1s64: + writer.U0f1s64 = U0f1s64.Value; + break; + case WHICH.U0f1sp: + writer.U0f1sp = U0f1sp; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U0f0s1 + { + get => _which == WHICH.U0f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U0f0s1; + _content = value; + } + } + + public sbyte? U0f0s8 + { + get => _which == WHICH.U0f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U0f0s8; + _content = value; + } + } + + public short? U0f0s16 + { + get => _which == WHICH.U0f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U0f0s16; + _content = value; + } + } + + public int? U0f0s32 + { + get => _which == WHICH.U0f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U0f0s32; + _content = value; + } + } + + public long? U0f0s64 + { + get => _which == WHICH.U0f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U0f0s64; + _content = value; + } + } + + public string U0f0sp + { + get => _which == WHICH.U0f0sp ? (string)_content : null; + set + { + _which = WHICH.U0f0sp; + _content = value; + } + } + + public bool? U0f1s1 + { + get => _which == WHICH.U0f1s1 ? (bool? )_content : null; + set + { + _which = WHICH.U0f1s1; + _content = value; + } + } + + public sbyte? U0f1s8 + { + get => _which == WHICH.U0f1s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U0f1s8; + _content = value; + } + } + + public short? U0f1s16 + { + get => _which == WHICH.U0f1s16 ? (short? )_content : null; + set + { + _which = WHICH.U0f1s16; + _content = value; + } + } + + public int? U0f1s32 + { + get => _which == WHICH.U0f1s32 ? (int? )_content : null; + set + { + _which = WHICH.U0f1s32; + _content = value; + } + } + + public long? U0f1s64 + { + get => _which == WHICH.U0f1s64 ? (long? )_content : null; + set + { + _which = WHICH.U0f1s64; + _content = value; + } + } + + public string U0f1sp + { + get => _which == WHICH.U0f1sp ? (string)_content : null; + set + { + _which = WHICH.U0f1sp; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public bool U0f0s1 => which == WHICH.U0f0s1 ? ctx.ReadDataBool(64UL, false) : default; + public sbyte U0f0s8 => which == WHICH.U0f0s8 ? ctx.ReadDataSByte(64UL, (sbyte)0) : default; + public short U0f0s16 => which == WHICH.U0f0s16 ? ctx.ReadDataShort(64UL, (short)0) : default; + public int U0f0s32 => which == WHICH.U0f0s32 ? ctx.ReadDataInt(64UL, 0) : default; + public long U0f0s64 => which == WHICH.U0f0s64 ? ctx.ReadDataLong(64UL, 0L) : default; + public string U0f0sp => which == WHICH.U0f0sp ? ctx.ReadText(0, "") : default; + public bool U0f1s1 => which == WHICH.U0f1s1 ? ctx.ReadDataBool(64UL, false) : default; + public sbyte U0f1s8 => which == WHICH.U0f1s8 ? ctx.ReadDataSByte(64UL, (sbyte)0) : default; + public short U0f1s16 => which == WHICH.U0f1s16 ? ctx.ReadDataShort(64UL, (short)0) : default; + public int U0f1s32 => which == WHICH.U0f1s32 ? ctx.ReadDataInt(64UL, 0) : default; + public long U0f1s64 => which == WHICH.U0f1s64 ? ctx.ReadDataLong(64UL, 0L) : default; + public string U0f1sp => which == WHICH.U0f1sp ? ctx.ReadText(0, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public bool U0f0s1 + { + get => which == WHICH.U0f0s1 ? this.ReadDataBool(64UL, false) : default; + set => this.WriteData(64UL, value, false); + } + + public sbyte U0f0s8 + { + get => which == WHICH.U0f0s8 ? this.ReadDataSByte(64UL, (sbyte)0) : default; + set => this.WriteData(64UL, value, (sbyte)0); + } + + public short U0f0s16 + { + get => which == WHICH.U0f0s16 ? this.ReadDataShort(64UL, (short)0) : default; + set => this.WriteData(64UL, value, (short)0); + } + + public int U0f0s32 + { + get => which == WHICH.U0f0s32 ? this.ReadDataInt(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public long U0f0s64 + { + get => which == WHICH.U0f0s64 ? this.ReadDataLong(64UL, 0L) : default; + set => this.WriteData(64UL, value, 0L); + } + + public string U0f0sp + { + get => which == WHICH.U0f0sp ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + + public bool U0f1s1 + { + get => which == WHICH.U0f1s1 ? this.ReadDataBool(64UL, false) : default; + set => this.WriteData(64UL, value, false); + } + + public sbyte U0f1s8 + { + get => which == WHICH.U0f1s8 ? this.ReadDataSByte(64UL, (sbyte)0) : default; + set => this.WriteData(64UL, value, (sbyte)0); + } + + public short U0f1s16 + { + get => which == WHICH.U0f1s16 ? this.ReadDataShort(64UL, (short)0) : default; + set => this.WriteData(64UL, value, (short)0); + } + + public int U0f1s32 + { + get => which == WHICH.U0f1s32 ? this.ReadDataInt(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public long U0f1s64 + { + get => which == WHICH.U0f1s64 ? this.ReadDataLong(64UL, 0L) : default; + set => this.WriteData(64UL, value, 0L); + } + + public string U0f1sp + { + get => which == WHICH.U0f1sp ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + } + } + + public class @union1 : ICapnpSerializable + { + public enum WHICH : ushort + { + U1f0s0 = 0, + U1f0s1 = 1, + U1f1s1 = 2, + U1f0s8 = 3, + U1f1s8 = 4, + U1f0s16 = 5, + U1f1s16 = 6, + U1f0s32 = 7, + U1f1s32 = 8, + U1f0s64 = 9, + U1f1s64 = 10, + U1f0sp = 11, + U1f1sp = 12, + U1f2s0 = 13, + U1f2s1 = 14, + U1f2s8 = 15, + U1f2s16 = 16, + U1f2s32 = 17, + U1f2s64 = 18, + U1f2sp = 19, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U1f0s0: + which = reader.which; + break; + case WHICH.U1f0s1: + U1f0s1 = reader.U1f0s1; + break; + case WHICH.U1f1s1: + U1f1s1 = reader.U1f1s1; + break; + case WHICH.U1f0s8: + U1f0s8 = reader.U1f0s8; + break; + case WHICH.U1f1s8: + U1f1s8 = reader.U1f1s8; + break; + case WHICH.U1f0s16: + U1f0s16 = reader.U1f0s16; + break; + case WHICH.U1f1s16: + U1f1s16 = reader.U1f1s16; + break; + case WHICH.U1f0s32: + U1f0s32 = reader.U1f0s32; + break; + case WHICH.U1f1s32: + U1f1s32 = reader.U1f1s32; + break; + case WHICH.U1f0s64: + U1f0s64 = reader.U1f0s64; + break; + case WHICH.U1f1s64: + U1f1s64 = reader.U1f1s64; + break; + case WHICH.U1f0sp: + U1f0sp = reader.U1f0sp; + break; + case WHICH.U1f1sp: + U1f1sp = reader.U1f1sp; + break; + case WHICH.U1f2s0: + which = reader.which; + break; + case WHICH.U1f2s1: + U1f2s1 = reader.U1f2s1; + break; + case WHICH.U1f2s8: + U1f2s8 = reader.U1f2s8; + break; + case WHICH.U1f2s16: + U1f2s16 = reader.U1f2s16; + break; + case WHICH.U1f2s32: + U1f2s32 = reader.U1f2s32; + break; + case WHICH.U1f2s64: + U1f2s64 = reader.U1f2s64; + break; + case WHICH.U1f2sp: + U1f2sp = reader.U1f2sp; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U1f0s0: + break; + case WHICH.U1f0s1: + _content = false; + break; + case WHICH.U1f1s1: + _content = false; + break; + case WHICH.U1f0s8: + _content = 0; + break; + case WHICH.U1f1s8: + _content = 0; + break; + case WHICH.U1f0s16: + _content = 0; + break; + case WHICH.U1f1s16: + _content = 0; + break; + case WHICH.U1f0s32: + _content = 0; + break; + case WHICH.U1f1s32: + _content = 0; + break; + case WHICH.U1f0s64: + _content = 0; + break; + case WHICH.U1f1s64: + _content = 0; + break; + case WHICH.U1f0sp: + _content = null; + break; + case WHICH.U1f1sp: + _content = null; + break; + case WHICH.U1f2s0: + break; + case WHICH.U1f2s1: + _content = false; + break; + case WHICH.U1f2s8: + _content = 0; + break; + case WHICH.U1f2s16: + _content = 0; + break; + case WHICH.U1f2s32: + _content = 0; + break; + case WHICH.U1f2s64: + _content = 0; + break; + case WHICH.U1f2sp: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U1f0s0: + break; + case WHICH.U1f0s1: + writer.U1f0s1 = U1f0s1.Value; + break; + case WHICH.U1f1s1: + writer.U1f1s1 = U1f1s1.Value; + break; + case WHICH.U1f0s8: + writer.U1f0s8 = U1f0s8.Value; + break; + case WHICH.U1f1s8: + writer.U1f1s8 = U1f1s8.Value; + break; + case WHICH.U1f0s16: + writer.U1f0s16 = U1f0s16.Value; + break; + case WHICH.U1f1s16: + writer.U1f1s16 = U1f1s16.Value; + break; + case WHICH.U1f0s32: + writer.U1f0s32 = U1f0s32.Value; + break; + case WHICH.U1f1s32: + writer.U1f1s32 = U1f1s32.Value; + break; + case WHICH.U1f0s64: + writer.U1f0s64 = U1f0s64.Value; + break; + case WHICH.U1f1s64: + writer.U1f1s64 = U1f1s64.Value; + break; + case WHICH.U1f0sp: + writer.U1f0sp = U1f0sp; + break; + case WHICH.U1f1sp: + writer.U1f1sp = U1f1sp; + break; + case WHICH.U1f2s0: + break; + case WHICH.U1f2s1: + writer.U1f2s1 = U1f2s1.Value; + break; + case WHICH.U1f2s8: + writer.U1f2s8 = U1f2s8.Value; + break; + case WHICH.U1f2s16: + writer.U1f2s16 = U1f2s16.Value; + break; + case WHICH.U1f2s32: + writer.U1f2s32 = U1f2s32.Value; + break; + case WHICH.U1f2s64: + writer.U1f2s64 = U1f2s64.Value; + break; + case WHICH.U1f2sp: + writer.U1f2sp = U1f2sp; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U1f0s1 + { + get => _which == WHICH.U1f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f0s1; + _content = value; + } + } + + public bool? U1f1s1 + { + get => _which == WHICH.U1f1s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f1s1; + _content = value; + } + } + + public sbyte? U1f0s8 + { + get => _which == WHICH.U1f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f0s8; + _content = value; + } + } + + public sbyte? U1f1s8 + { + get => _which == WHICH.U1f1s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f1s8; + _content = value; + } + } + + public short? U1f0s16 + { + get => _which == WHICH.U1f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f0s16; + _content = value; + } + } + + public short? U1f1s16 + { + get => _which == WHICH.U1f1s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f1s16; + _content = value; + } + } + + public int? U1f0s32 + { + get => _which == WHICH.U1f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f0s32; + _content = value; + } + } + + public int? U1f1s32 + { + get => _which == WHICH.U1f1s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f1s32; + _content = value; + } + } + + public long? U1f0s64 + { + get => _which == WHICH.U1f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f0s64; + _content = value; + } + } + + public long? U1f1s64 + { + get => _which == WHICH.U1f1s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f1s64; + _content = value; + } + } + + public string U1f0sp + { + get => _which == WHICH.U1f0sp ? (string)_content : null; + set + { + _which = WHICH.U1f0sp; + _content = value; + } + } + + public string U1f1sp + { + get => _which == WHICH.U1f1sp ? (string)_content : null; + set + { + _which = WHICH.U1f1sp; + _content = value; + } + } + + public bool? U1f2s1 + { + get => _which == WHICH.U1f2s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f2s1; + _content = value; + } + } + + public sbyte? U1f2s8 + { + get => _which == WHICH.U1f2s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f2s8; + _content = value; + } + } + + public short? U1f2s16 + { + get => _which == WHICH.U1f2s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f2s16; + _content = value; + } + } + + public int? U1f2s32 + { + get => _which == WHICH.U1f2s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f2s32; + _content = value; + } + } + + public long? U1f2s64 + { + get => _which == WHICH.U1f2s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f2s64; + _content = value; + } + } + + public string U1f2sp + { + get => _which == WHICH.U1f2sp ? (string)_content : null; + set + { + _which = WHICH.U1f2sp; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(16U, (ushort)0); + public bool U1f0s1 => which == WHICH.U1f0s1 ? ctx.ReadDataBool(129UL, false) : default; + public bool U1f1s1 => which == WHICH.U1f1s1 ? ctx.ReadDataBool(129UL, false) : default; + public sbyte U1f0s8 => which == WHICH.U1f0s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public sbyte U1f1s8 => which == WHICH.U1f1s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public short U1f0s16 => which == WHICH.U1f0s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public short U1f1s16 => which == WHICH.U1f1s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public int U1f0s32 => which == WHICH.U1f0s32 ? ctx.ReadDataInt(160UL, 0) : default; + public int U1f1s32 => which == WHICH.U1f1s32 ? ctx.ReadDataInt(160UL, 0) : default; + public long U1f0s64 => which == WHICH.U1f0s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public long U1f1s64 => which == WHICH.U1f1s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public string U1f0sp => which == WHICH.U1f0sp ? ctx.ReadText(1, "") : default; + public string U1f1sp => which == WHICH.U1f1sp ? ctx.ReadText(1, "") : default; + public bool U1f2s1 => which == WHICH.U1f2s1 ? ctx.ReadDataBool(129UL, false) : default; + public sbyte U1f2s8 => which == WHICH.U1f2s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public short U1f2s16 => which == WHICH.U1f2s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public int U1f2s32 => which == WHICH.U1f2s32 ? ctx.ReadDataInt(160UL, 0) : default; + public long U1f2s64 => which == WHICH.U1f2s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public string U1f2sp => which == WHICH.U1f2sp ? ctx.ReadText(1, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(16U, (ushort)0); + set => this.WriteData(16U, (ushort)value, (ushort)0); + } + + public bool U1f0s1 + { + get => which == WHICH.U1f0s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public bool U1f1s1 + { + get => which == WHICH.U1f1s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public sbyte U1f0s8 + { + get => which == WHICH.U1f0s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public sbyte U1f1s8 + { + get => which == WHICH.U1f1s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public short U1f0s16 + { + get => which == WHICH.U1f0s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public short U1f1s16 + { + get => which == WHICH.U1f1s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public int U1f0s32 + { + get => which == WHICH.U1f0s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public int U1f1s32 + { + get => which == WHICH.U1f1s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public long U1f0s64 + { + get => which == WHICH.U1f0s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public long U1f1s64 + { + get => which == WHICH.U1f1s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public string U1f0sp + { + get => which == WHICH.U1f0sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public string U1f1sp + { + get => which == WHICH.U1f1sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public bool U1f2s1 + { + get => which == WHICH.U1f2s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public sbyte U1f2s8 + { + get => which == WHICH.U1f2s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public short U1f2s16 + { + get => which == WHICH.U1f2s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public int U1f2s32 + { + get => which == WHICH.U1f2s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public long U1f2s64 + { + get => which == WHICH.U1f2s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public string U1f2sp + { + get => which == WHICH.U1f2sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + } + } + + public class @union2 : ICapnpSerializable + { + public enum WHICH : ushort + { + U2f0s1 = 0, + U2f0s8 = 1, + U2f0s16 = 2, + U2f0s32 = 3, + U2f0s64 = 4, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U2f0s1: + U2f0s1 = reader.U2f0s1; + break; + case WHICH.U2f0s8: + U2f0s8 = reader.U2f0s8; + break; + case WHICH.U2f0s16: + U2f0s16 = reader.U2f0s16; + break; + case WHICH.U2f0s32: + U2f0s32 = reader.U2f0s32; + break; + case WHICH.U2f0s64: + U2f0s64 = reader.U2f0s64; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U2f0s1: + _content = false; + break; + case WHICH.U2f0s8: + _content = 0; + break; + case WHICH.U2f0s16: + _content = 0; + break; + case WHICH.U2f0s32: + _content = 0; + break; + case WHICH.U2f0s64: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U2f0s1: + writer.U2f0s1 = U2f0s1.Value; + break; + case WHICH.U2f0s8: + writer.U2f0s8 = U2f0s8.Value; + break; + case WHICH.U2f0s16: + writer.U2f0s16 = U2f0s16.Value; + break; + case WHICH.U2f0s32: + writer.U2f0s32 = U2f0s32.Value; + break; + case WHICH.U2f0s64: + writer.U2f0s64 = U2f0s64.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U2f0s1 + { + get => _which == WHICH.U2f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U2f0s1; + _content = value; + } + } + + public sbyte? U2f0s8 + { + get => _which == WHICH.U2f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U2f0s8; + _content = value; + } + } + + public short? U2f0s16 + { + get => _which == WHICH.U2f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U2f0s16; + _content = value; + } + } + + public int? U2f0s32 + { + get => _which == WHICH.U2f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U2f0s32; + _content = value; + } + } + + public long? U2f0s64 + { + get => _which == WHICH.U2f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U2f0s64; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public bool U2f0s1 => which == WHICH.U2f0s1 ? ctx.ReadDataBool(256UL, false) : default; + public sbyte U2f0s8 => which == WHICH.U2f0s8 ? ctx.ReadDataSByte(264UL, (sbyte)0) : default; + public short U2f0s16 => which == WHICH.U2f0s16 ? ctx.ReadDataShort(288UL, (short)0) : default; + public int U2f0s32 => which == WHICH.U2f0s32 ? ctx.ReadDataInt(320UL, 0) : default; + public long U2f0s64 => which == WHICH.U2f0s64 ? ctx.ReadDataLong(384UL, 0L) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public bool U2f0s1 + { + get => which == WHICH.U2f0s1 ? this.ReadDataBool(256UL, false) : default; + set => this.WriteData(256UL, value, false); + } + + public sbyte U2f0s8 + { + get => which == WHICH.U2f0s8 ? this.ReadDataSByte(264UL, (sbyte)0) : default; + set => this.WriteData(264UL, value, (sbyte)0); + } + + public short U2f0s16 + { + get => which == WHICH.U2f0s16 ? this.ReadDataShort(288UL, (short)0) : default; + set => this.WriteData(288UL, value, (short)0); + } + + public int U2f0s32 + { + get => which == WHICH.U2f0s32 ? this.ReadDataInt(320UL, 0) : default; + set => this.WriteData(320UL, value, 0); + } + + public long U2f0s64 + { + get => which == WHICH.U2f0s64 ? this.ReadDataLong(384UL, 0L) : default; + set => this.WriteData(384UL, value, 0L); + } + } + } + + public class @union3 : ICapnpSerializable + { + public enum WHICH : ushort + { + U3f0s1 = 0, + U3f0s8 = 1, + U3f0s16 = 2, + U3f0s32 = 3, + U3f0s64 = 4, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U3f0s1: + U3f0s1 = reader.U3f0s1; + break; + case WHICH.U3f0s8: + U3f0s8 = reader.U3f0s8; + break; + case WHICH.U3f0s16: + U3f0s16 = reader.U3f0s16; + break; + case WHICH.U3f0s32: + U3f0s32 = reader.U3f0s32; + break; + case WHICH.U3f0s64: + U3f0s64 = reader.U3f0s64; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U3f0s1: + _content = false; + break; + case WHICH.U3f0s8: + _content = 0; + break; + case WHICH.U3f0s16: + _content = 0; + break; + case WHICH.U3f0s32: + _content = 0; + break; + case WHICH.U3f0s64: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U3f0s1: + writer.U3f0s1 = U3f0s1.Value; + break; + case WHICH.U3f0s8: + writer.U3f0s8 = U3f0s8.Value; + break; + case WHICH.U3f0s16: + writer.U3f0s16 = U3f0s16.Value; + break; + case WHICH.U3f0s32: + writer.U3f0s32 = U3f0s32.Value; + break; + case WHICH.U3f0s64: + writer.U3f0s64 = U3f0s64.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U3f0s1 + { + get => _which == WHICH.U3f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U3f0s1; + _content = value; + } + } + + public sbyte? U3f0s8 + { + get => _which == WHICH.U3f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U3f0s8; + _content = value; + } + } + + public short? U3f0s16 + { + get => _which == WHICH.U3f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U3f0s16; + _content = value; + } + } + + public int? U3f0s32 + { + get => _which == WHICH.U3f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U3f0s32; + _content = value; + } + } + + public long? U3f0s64 + { + get => _which == WHICH.U3f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U3f0s64; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public bool U3f0s1 => which == WHICH.U3f0s1 ? ctx.ReadDataBool(257UL, false) : default; + public sbyte U3f0s8 => which == WHICH.U3f0s8 ? ctx.ReadDataSByte(272UL, (sbyte)0) : default; + public short U3f0s16 => which == WHICH.U3f0s16 ? ctx.ReadDataShort(304UL, (short)0) : default; + public int U3f0s32 => which == WHICH.U3f0s32 ? ctx.ReadDataInt(352UL, 0) : default; + public long U3f0s64 => which == WHICH.U3f0s64 ? ctx.ReadDataLong(448UL, 0L) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public bool U3f0s1 + { + get => which == WHICH.U3f0s1 ? this.ReadDataBool(257UL, false) : default; + set => this.WriteData(257UL, value, false); + } + + public sbyte U3f0s8 + { + get => which == WHICH.U3f0s8 ? this.ReadDataSByte(272UL, (sbyte)0) : default; + set => this.WriteData(272UL, value, (sbyte)0); + } + + public short U3f0s16 + { + get => which == WHICH.U3f0s16 ? this.ReadDataShort(304UL, (short)0) : default; + set => this.WriteData(304UL, value, (short)0); + } + + public int U3f0s32 + { + get => which == WHICH.U3f0s32 ? this.ReadDataInt(352UL, 0) : default; + set => this.WriteData(352UL, value, 0); + } + + public long U3f0s64 + { + get => which == WHICH.U3f0s64 ? this.ReadDataLong(448UL, 0L) : default; + set => this.WriteData(448UL, value, 0L); + } + } + } + } + + public class TestUnnamedUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + Before = reader.Before; + Middle = reader.Middle; + After = reader.After; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = 0; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + + writer.Before = Before; + writer.Middle = Middle; + writer.After = After; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Before + { + get; + set; + } + + public ushort? Foo + { + get => _which == WHICH.Foo ? (ushort? )_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public ushort Middle + { + get; + set; + } + + public uint? Bar + { + get => _which == WHICH.Bar ? (uint? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public string After + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public string Before => ctx.ReadText(0, ""); + public ushort Foo => which == WHICH.Foo ? ctx.ReadDataUShort(0UL, (ushort)0) : default; + public ushort Middle => ctx.ReadDataUShort(16UL, (ushort)0); + public uint Bar => which == WHICH.Bar ? ctx.ReadDataUInt(64UL, 0U) : default; + public string After => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 2); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public string Before + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ushort Foo + { + get => which == WHICH.Foo ? this.ReadDataUShort(0UL, (ushort)0) : default; + set => this.WriteData(0UL, value, (ushort)0); + } + + public ushort Middle + { + get => this.ReadDataUShort(16UL, (ushort)0); + set => this.WriteData(16UL, value, (ushort)0); + } + + public uint Bar + { + get => which == WHICH.Bar ? this.ReadDataUInt(64UL, 0U) : default; + set => this.WriteData(64UL, value, 0U); + } + + public string After + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + + public class TestUnionInUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Outer = CapnpSerializable.Create(reader.Outer); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Outer?.serialize(writer.Outer); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnionInUnion.@outer Outer + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @outer.READER Outer => new @outer.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 0); + } + + public @outer.WRITER Outer + { + get => Rewrap<@outer.WRITER>(); + } + } + + public class @outer : ICapnpSerializable + { + public enum WHICH : ushort + { + Inner = 0, + Baz = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Inner: + Inner = CapnpSerializable.Create(reader.Inner); + break; + case WHICH.Baz: + Baz = reader.Baz; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Inner: + _content = null; + break; + case WHICH.Baz: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Inner: + Inner?.serialize(writer.Inner); + break; + case WHICH.Baz: + writer.Baz = Baz.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnionInUnion.@outer.@inner Inner + { + get => _which == WHICH.Inner ? (Capnproto_test.Capnp.Test.TestUnionInUnion.@outer.@inner)_content : null; + set + { + _which = WHICH.Inner; + _content = value; + } + } + + public int? Baz + { + get => _which == WHICH.Baz ? (int? )_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public @inner.READER Inner => which == WHICH.Inner ? new @inner.READER(ctx) : default; + public int Baz => which == WHICH.Baz ? ctx.ReadDataInt(0UL, 0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public @inner.WRITER Inner + { + get => which == WHICH.Inner ? Rewrap<@inner.WRITER>() : default; + } + + public int Baz + { + get => which == WHICH.Baz ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + } + + public class @inner : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = 0; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int? Foo + { + get => _which == WHICH.Foo ? (int? )_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public int? Bar + { + get => _which == WHICH.Bar ? (int? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public int Foo => which == WHICH.Foo ? ctx.ReadDataInt(0UL, 0) : default; + public int Bar => which == WHICH.Bar ? ctx.ReadDataInt(0UL, 0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public int Foo + { + get => which == WHICH.Foo ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + + public int Bar + { + get => which == WHICH.Bar ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + } + } + } + } + + public class TestGroups : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Groups = CapnpSerializable.Create(reader.Groups); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Groups?.serialize(writer.Groups); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups Groups + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @groups.READER Groups => new @groups.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 2); + } + + public @groups.WRITER Groups + { + get => Rewrap<@groups.WRITER>(); + } + } + + public class @groups : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Baz = 1, + Bar = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = CapnpSerializable.Create(reader.Foo); + break; + case WHICH.Baz: + Baz = CapnpSerializable.Create(reader.Baz); + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Baz: + _content = null; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + Foo?.serialize(writer.Foo); + break; + case WHICH.Baz: + Baz?.serialize(writer.Baz); + break; + case WHICH.Bar: + Bar?.serialize(writer.Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@foo Foo + { + get => _which == WHICH.Foo ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@foo)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@baz Baz + { + get => _which == WHICH.Baz ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@baz)_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@bar Bar + { + get => _which == WHICH.Bar ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@bar)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public @foo.READER Foo => which == WHICH.Foo ? new @foo.READER(ctx) : default; + public @baz.READER Baz => which == WHICH.Baz ? new @baz.READER(ctx) : default; + public @bar.READER Bar => which == WHICH.Bar ? new @bar.READER(ctx) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public @foo.WRITER Foo + { + get => which == WHICH.Foo ? Rewrap<@foo.WRITER>() : default; + } + + public @baz.WRITER Baz + { + get => which == WHICH.Baz ? Rewrap<@baz.WRITER>() : default; + } + + public @bar.WRITER Bar + { + get => which == WHICH.Bar ? Rewrap<@bar.WRITER>() : default; + } + } + + public class @foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public long Grault + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public long Grault => ctx.ReadDataLong(64UL, 0L); + public string Garply => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public long Grault + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + + public string Garply + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class @baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public string Grault => ctx.ReadText(0, ""); + public string Garply => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Grault + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Garply + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + + public class @bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public long Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public string Grault => ctx.ReadText(0, ""); + public long Garply => ctx.ReadDataLong(64UL, 0L); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Grault + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public long Garply + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + } + } + } + } + + public class TestInterleavedGroups : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Group1 = CapnpSerializable.Create(reader.Group1); + Group2 = CapnpSerializable.Create(reader.Group2); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Group1?.serialize(writer.Group1); + Group2?.serialize(writer.Group2); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1 Group1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2 Group2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @group1.READER Group1 => new @group1.READER(ctx); + public @group2.READER Group2 => new @group2.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 6); + } + + public @group1.WRITER Group1 + { + get => Rewrap<@group1.WRITER>(); + } + + public @group2.WRITER Group2 + { + get => Rewrap<@group2.WRITER>(); + } + } + + public class @group1 : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Fred = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = CapnpSerializable.Create(reader.Corge); + break; + case WHICH.Fred: + Fred = reader.Fred; + break; + } + + Foo = reader.Foo; + Bar = reader.Bar; + Waldo = reader.Waldo; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = 0; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Fred: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux.Value; + break; + case WHICH.Corge: + Corge?.serialize(writer.Corge); + break; + case WHICH.Fred: + writer.Fred = Fred; + break; + } + + writer.Foo = Foo; + writer.Bar = Bar; + writer.Waldo = Waldo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Foo + { + get; + set; + } + + public ulong Bar + { + get; + set; + } + + public ushort? Qux + { + get => _which == WHICH.Qux ? (ushort? )_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1.@corge Corge + { + get => _which == WHICH.Corge ? (Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1.@corge)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public string Waldo + { + get; + set; + } + + public string Fred + { + get => _which == WHICH.Fred ? (string)_content : null; + set + { + _which = WHICH.Fred; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(224U, (ushort)0); + public uint Foo => ctx.ReadDataUInt(0UL, 0U); + public ulong Bar => ctx.ReadDataULong(64UL, 0UL); + public ushort Qux => which == WHICH.Qux ? ctx.ReadDataUShort(192UL, (ushort)0) : default; + public @corge.READER Corge => which == WHICH.Corge ? new @corge.READER(ctx) : default; + public string Waldo => ctx.ReadText(0, ""); + public string Fred => which == WHICH.Fred ? ctx.ReadText(2, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(224U, (ushort)0); + set => this.WriteData(224U, (ushort)value, (ushort)0); + } + + public uint Foo + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public ulong Bar + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public ushort Qux + { + get => which == WHICH.Qux ? this.ReadDataUShort(192UL, (ushort)0) : default; + set => this.WriteData(192UL, value, (ushort)0); + } + + public @corge.WRITER Corge + { + get => which == WHICH.Corge ? Rewrap<@corge.WRITER>() : default; + } + + public string Waldo + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Fred + { + get => which == WHICH.Fred ? this.ReadText(2, "") : default; + set => this.WriteText(2, value, ""); + } + } + + public class @corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Grault = reader.Grault; + Garply = reader.Garply; + Plugh = reader.Plugh; + Xyzzy = reader.Xyzzy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Grault = Grault; + writer.Garply = Garply; + writer.Plugh = Plugh; + writer.Xyzzy = Xyzzy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Grault + { + get; + set; + } + + public ushort Garply + { + get; + set; + } + + public string Plugh + { + get; + set; + } + + public string Xyzzy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Grault => ctx.ReadDataULong(256UL, 0UL); + public ushort Garply => ctx.ReadDataUShort(192UL, (ushort)0); + public string Plugh => ctx.ReadText(2, ""); + public string Xyzzy => ctx.ReadText(4, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong Grault + { + get => this.ReadDataULong(256UL, 0UL); + set => this.WriteData(256UL, value, 0UL); + } + + public ushort Garply + { + get => this.ReadDataUShort(192UL, (ushort)0); + set => this.WriteData(192UL, value, (ushort)0); + } + + public string Plugh + { + get => this.ReadText(2, ""); + set => this.WriteText(2, value, ""); + } + + public string Xyzzy + { + get => this.ReadText(4, ""); + set => this.WriteText(4, value, ""); + } + } + } + } + + public class @group2 : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Fred = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = CapnpSerializable.Create(reader.Corge); + break; + case WHICH.Fred: + Fred = reader.Fred; + break; + } + + Foo = reader.Foo; + Bar = reader.Bar; + Waldo = reader.Waldo; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = 0; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Fred: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux.Value; + break; + case WHICH.Corge: + Corge?.serialize(writer.Corge); + break; + case WHICH.Fred: + writer.Fred = Fred; + break; + } + + writer.Foo = Foo; + writer.Bar = Bar; + writer.Waldo = Waldo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Foo + { + get; + set; + } + + public ulong Bar + { + get; + set; + } + + public ushort? Qux + { + get => _which == WHICH.Qux ? (ushort? )_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2.@corge Corge + { + get => _which == WHICH.Corge ? (Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2.@corge)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public string Waldo + { + get; + set; + } + + public string Fred + { + get => _which == WHICH.Fred ? (string)_content : null; + set + { + _which = WHICH.Fred; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(240U, (ushort)0); + public uint Foo => ctx.ReadDataUInt(32UL, 0U); + public ulong Bar => ctx.ReadDataULong(128UL, 0UL); + public ushort Qux => which == WHICH.Qux ? ctx.ReadDataUShort(208UL, (ushort)0) : default; + public @corge.READER Corge => which == WHICH.Corge ? new @corge.READER(ctx) : default; + public string Waldo => ctx.ReadText(1, ""); + public string Fred => which == WHICH.Fred ? ctx.ReadText(3, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(240U, (ushort)0); + set => this.WriteData(240U, (ushort)value, (ushort)0); + } + + public uint Foo + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + + public ulong Bar + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + + public ushort Qux + { + get => which == WHICH.Qux ? this.ReadDataUShort(208UL, (ushort)0) : default; + set => this.WriteData(208UL, value, (ushort)0); + } + + public @corge.WRITER Corge + { + get => which == WHICH.Corge ? Rewrap<@corge.WRITER>() : default; + } + + public string Waldo + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public string Fred + { + get => which == WHICH.Fred ? this.ReadText(3, "") : default; + set => this.WriteText(3, value, ""); + } + } + + public class @corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Grault = reader.Grault; + Garply = reader.Garply; + Plugh = reader.Plugh; + Xyzzy = reader.Xyzzy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Grault = Grault; + writer.Garply = Garply; + writer.Plugh = Plugh; + writer.Xyzzy = Xyzzy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Grault + { + get; + set; + } + + public ushort Garply + { + get; + set; + } + + public string Plugh + { + get; + set; + } + + public string Xyzzy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Grault => ctx.ReadDataULong(320UL, 0UL); + public ushort Garply => ctx.ReadDataUShort(208UL, (ushort)0); + public string Plugh => ctx.ReadText(3, ""); + public string Xyzzy => ctx.ReadText(5, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong Grault + { + get => this.ReadDataULong(320UL, 0UL); + set => this.WriteData(320UL, value, 0UL); + } + + public ushort Garply + { + get => this.ReadDataUShort(208UL, (ushort)0); + set => this.WriteData(208UL, value, (ushort)0); + } + + public string Plugh + { + get => this.ReadText(3, ""); + set => this.WriteText(3, value, ""); + } + + public string Xyzzy + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + } + } + } + } + + public class TestUnionDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S16s8s64s8Set = CapnpSerializable.Create(reader.S16s8s64s8Set); + S0sps1s32Set = CapnpSerializable.Create(reader.S0sps1s32Set); + Unnamed1 = CapnpSerializable.Create(reader.Unnamed1); + Unnamed2 = CapnpSerializable.Create(reader.Unnamed2); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + S16s8s64s8Set?.serialize(writer.S16s8s64s8Set); + S0sps1s32Set?.serialize(writer.S0sps1s32Set); + Unnamed1?.serialize(writer.Unnamed1); + Unnamed2?.serialize(writer.Unnamed2); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + S16s8s64s8Set = S16s8s64s8Set ?? new Capnproto_test.Capnp.Test.TestUnion() + {Union0 = new Capnproto_test.Capnp.Test.TestUnion.@union0() + {}, Union1 = new Capnproto_test.Capnp.Test.TestUnion.@union1() + {}, Union2 = new Capnproto_test.Capnp.Test.TestUnion.@union2() + {}, Union3 = new Capnproto_test.Capnp.Test.TestUnion.@union3() + {}, Bit0 = false, Bit2 = false, Bit3 = false, Bit4 = false, Bit5 = false, Bit6 = false, Bit7 = false, Byte0 = 0}; + S0sps1s32Set = S0sps1s32Set ?? new Capnproto_test.Capnp.Test.TestUnion() + {Union0 = new Capnproto_test.Capnp.Test.TestUnion.@union0() + {}, Union1 = new Capnproto_test.Capnp.Test.TestUnion.@union1() + {}, Union2 = new Capnproto_test.Capnp.Test.TestUnion.@union2() + {}, Union3 = new Capnproto_test.Capnp.Test.TestUnion.@union3() + {}, Bit0 = false, Bit2 = false, Bit3 = false, Bit4 = false, Bit5 = false, Bit6 = false, Bit7 = false, Byte0 = 0}; + Unnamed1 = Unnamed1 ?? new Capnproto_test.Capnp.Test.TestUnnamedUnion() + {Before = null, Middle = 0, After = null}; + Unnamed2 = Unnamed2 ?? new Capnproto_test.Capnp.Test.TestUnnamedUnion() + {Before = "foo", Middle = 0, After = "bar"}; + } + + public Capnproto_test.Capnp.Test.TestUnion S16s8s64s8Set + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion S0sps1s32Set + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion Unnamed1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion Unnamed2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestUnion.READER S16s8s64s8Set => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnion.READER S0sps1s32Set => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnnamedUnion.READER Unnamed1 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestUnnamedUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnnamedUnion.READER Unnamed2 => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestUnnamedUnion.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public Capnproto_test.Capnp.Test.TestUnion.WRITER S16s8s64s8Set + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestUnion.WRITER S0sps1s32Set + { + get => BuildPointer(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed1 + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed2 + { + get => BuildPointer(3); + set => Link(3, value); + } + } + } + + public class TestNestedTypes : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheNestedStruct = CapnpSerializable.Create(reader.TheNestedStruct); + OuterNestedEnum = reader.OuterNestedEnum; + InnerNestedEnum = reader.InnerNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + TheNestedStruct?.serialize(writer.TheNestedStruct); + writer.OuterNestedEnum = OuterNestedEnum; + writer.InnerNestedEnum = InnerNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct TheNestedStruct + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.READER TheNestedStruct => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.READER.create); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)1); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.WRITER TheNestedStruct + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(0UL, (ushort)1); + set => this.WriteData(0UL, (ushort)value, (ushort)1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(16UL, (ushort)2); + set => this.WriteData(16UL, (ushort)value, (ushort)2); + } + } + + public enum NestedEnum : ushort + { + foo, + bar + } + + public class NestedStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + OuterNestedEnum = reader.OuterNestedEnum; + InnerNestedEnum = reader.InnerNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.OuterNestedEnum = OuterNestedEnum; + writer.InnerNestedEnum = InnerNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)1); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(0UL, (ushort)1); + set => this.WriteData(0UL, (ushort)value, (ushort)1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(16UL, (ushort)2); + set => this.WriteData(16UL, (ushort)value, (ushort)2); + } + } + + public enum NestedEnum : ushort + { + baz, + qux, + quux + } + } + } + + public class TestUsing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + InnerNestedEnum = reader.InnerNestedEnum; + OuterNestedEnum = reader.OuterNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.InnerNestedEnum = InnerNestedEnum; + writer.OuterNestedEnum = OuterNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)2); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(0UL, (ushort)2); + set => this.WriteData(0UL, (ushort)value, (ushort)2); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(16UL, (ushort)1); + set => this.WriteData(16UL, (ushort)value, (ushort)1); + } + } + } + + public class TestLists : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + List0 = reader.List0.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List1 = reader.List1.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List8 = reader.List8.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List16 = reader.List16.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List32 = reader.List32.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List64 = reader.List64.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + ListP = reader.ListP.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Int32ListList = reader.Int32ListList; + TextListList = reader.TextListList; + StructListList = reader.StructListList.ToReadOnlyList(_2 => _2.ToReadOnlyList(_ => CapnpSerializable.Create(_))); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.List0.Init(List0, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List1.Init(List1, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List8.Init(List8, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List16.Init(List16, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List32.Init(List32, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List64.Init(List64, (_s1, _v1) => _v1?.serialize(_s1)); + writer.ListP.Init(ListP, (_s1, _v1) => _v1?.serialize(_s1)); + writer.Int32ListList.Init(Int32ListList, (_s2, _v2) => _s2.Init(_v2)); + writer.TextListList.Init(TextListList, (_s2, _v2) => _s2.Init(_v2)); + writer.StructListList.Init(StructListList, (_s2, _v2) => _s2.Init(_v2, (_s1, _v1) => _v1?.serialize(_s1))); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList List0 + { + get; + set; + } + + public IReadOnlyList List1 + { + get; + set; + } + + public IReadOnlyList List8 + { + get; + set; + } + + public IReadOnlyList List16 + { + get; + set; + } + + public IReadOnlyList List32 + { + get; + set; + } + + public IReadOnlyList List64 + { + get; + set; + } + + public IReadOnlyList ListP + { + get; + set; + } + + public IReadOnlyList> Int32ListList + { + get; + set; + } + + public IReadOnlyList> TextListList + { + get; + set; + } + + public IReadOnlyList> StructListList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList List0 => ctx.ReadList(0).Cast(Capnproto_test.Capnp.Test.TestLists.Struct0.READER.create); + public IReadOnlyList List1 => ctx.ReadList(1).Cast(Capnproto_test.Capnp.Test.TestLists.Struct1.READER.create); + public IReadOnlyList List8 => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestLists.Struct8.READER.create); + public IReadOnlyList List16 => ctx.ReadList(3).Cast(Capnproto_test.Capnp.Test.TestLists.Struct16.READER.create); + public IReadOnlyList List32 => ctx.ReadList(4).Cast(Capnproto_test.Capnp.Test.TestLists.Struct32.READER.create); + public IReadOnlyList List64 => ctx.ReadList(5).Cast(Capnproto_test.Capnp.Test.TestLists.Struct64.READER.create); + public IReadOnlyList ListP => ctx.ReadList(6).Cast(Capnproto_test.Capnp.Test.TestLists.StructP.READER.create); + public IReadOnlyList> Int32ListList => ctx.ReadList(7).Cast(_0 => _0.RequireList().CastInt()); + public IReadOnlyList> TextListList => ctx.ReadList(8).Cast(_0 => _0.RequireList().CastText2()); + public IReadOnlyList> StructListList => ctx.ReadList(9).Cast(_0 => _0.RequireList().Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create)); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 10); + } + + public ListOfStructsSerializer List0 + { + get => BuildPointer>(0); + set => Link(0, value); + } + + public ListOfStructsSerializer List1 + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ListOfStructsSerializer List8 + { + get => BuildPointer>(2); + set => Link(2, value); + } + + public ListOfStructsSerializer List16 + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public ListOfStructsSerializer List32 + { + get => BuildPointer>(4); + set => Link(4, value); + } + + public ListOfStructsSerializer List64 + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfStructsSerializer ListP + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPointersSerializer> Int32ListList + { + get => BuildPointer>>(7); + set => Link(7, value); + } + + public ListOfPointersSerializer TextListList + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPointersSerializer> StructListList + { + get => BuildPointer>>(9); + set => Link(9, value); + } + } + + public class Struct0 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Struct1 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool F => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public bool F + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Struct8 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte F => ctx.ReadDataByte(0UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public byte F + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + } + } + + public class Struct16 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort F => ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public ushort F + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + } + } + + public class Struct32 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint F => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint F + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Struct64 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong F => ctx.ReadDataULong(0UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public ulong F + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + } + } + + public class StructP : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string F => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string F + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct0c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct1c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool F => ctx.ReadDataBool(0UL, false); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public bool F + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct8c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte F => ctx.ReadDataByte(0UL, (byte)0); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public byte F + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct16c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort F => ctx.ReadDataUShort(0UL, (ushort)0); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ushort F + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct32c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint F => ctx.ReadDataUInt(0UL, 0U); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint F + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct64c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong F => ctx.ReadDataULong(0UL, 0UL); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ulong F + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class StructPc : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string F + { + get; + set; + } + + public ulong Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string F => ctx.ReadText(0, ""); + public ulong Pad => ctx.ReadDataULong(0UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string F + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ulong Pad + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + } + } + } + + public class TestFieldZeroIsBit : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Bit = reader.Bit; + SecondBit = reader.SecondBit; + ThirdField = reader.ThirdField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Bit = Bit; + writer.SecondBit = SecondBit; + writer.ThirdField = ThirdField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool Bit + { + get; + set; + } + + public bool SecondBit + { + get; + set; + } + + = true; + public byte ThirdField + { + get; + set; + } + + = 123; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool Bit => ctx.ReadDataBool(0UL, false); + public bool SecondBit => ctx.ReadDataBool(1UL, true); + public byte ThirdField => ctx.ReadDataByte(8UL, (byte)123); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public bool Bit + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public bool SecondBit + { + get => this.ReadDataBool(1UL, true); + set => this.WriteData(1UL, value, true); + } + + public byte ThirdField + { + get => this.ReadDataByte(8UL, (byte)123); + set => this.WriteData(8UL, value, (byte)123); + } + } + } + + public class TestListDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Lists = CapnpSerializable.Create(reader.Lists); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Lists?.serialize(writer.Lists); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + Lists = Lists ?? new Capnproto_test.Capnp.Test.TestLists() + {List0 = new Capnproto_test.Capnp.Test.TestLists.Struct0[]{new Capnproto_test.Capnp.Test.TestLists.Struct0() + {}, new Capnproto_test.Capnp.Test.TestLists.Struct0() + {}}, List1 = new Capnproto_test.Capnp.Test.TestLists.Struct1[]{new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = false}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}}, List8 = new Capnproto_test.Capnp.Test.TestLists.Struct8[]{new Capnproto_test.Capnp.Test.TestLists.Struct8() + {F = 123}, new Capnproto_test.Capnp.Test.TestLists.Struct8() + {F = 45}}, List16 = new Capnproto_test.Capnp.Test.TestLists.Struct16[]{new Capnproto_test.Capnp.Test.TestLists.Struct16() + {F = 12345}, new Capnproto_test.Capnp.Test.TestLists.Struct16() + {F = 6789}}, List32 = new Capnproto_test.Capnp.Test.TestLists.Struct32[]{new Capnproto_test.Capnp.Test.TestLists.Struct32() + {F = 123456789U}, new Capnproto_test.Capnp.Test.TestLists.Struct32() + {F = 234567890U}}, List64 = new Capnproto_test.Capnp.Test.TestLists.Struct64[]{new Capnproto_test.Capnp.Test.TestLists.Struct64() + {F = 1234567890123456UL}, new Capnproto_test.Capnp.Test.TestLists.Struct64() + {F = 2345678901234567UL}}, ListP = new Capnproto_test.Capnp.Test.TestLists.StructP[]{new Capnproto_test.Capnp.Test.TestLists.StructP() + {F = "foo"}, new Capnproto_test.Capnp.Test.TestLists.StructP() + {F = "bar"}}, Int32ListList = new IReadOnlyList[]{new int[]{1, 2, 3}, new int[]{4, 5}, new int[]{12341234}}, TextListList = new IReadOnlyList[]{new string[]{"foo", "bar"}, new string[]{"baz"}, new string[]{"qux", "corge"}}, StructListList = new IReadOnlyList[]{new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 123, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 456, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}, new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 789, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}}}; + } + + public Capnproto_test.Capnp.Test.TestLists Lists + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestLists.READER Lists => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestLists.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestLists.WRITER Lists + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class TestLateUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = reader.Foo; + Bar = reader.Bar; + Baz = reader.Baz; + TheUnion = CapnpSerializable.Create(reader.TheUnion); + AnotherUnion = CapnpSerializable.Create(reader.AnotherUnion); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo = Foo; + writer.Bar = Bar; + writer.Baz = Baz; + TheUnion?.serialize(writer.TheUnion); + AnotherUnion?.serialize(writer.AnotherUnion); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Foo + { + get; + set; + } + + public string Bar + { + get; + set; + } + + public short Baz + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestLateUnion.@theUnion TheUnion + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestLateUnion.@anotherUnion AnotherUnion + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Foo => ctx.ReadDataInt(0UL, 0); + public string Bar => ctx.ReadText(0, ""); + public short Baz => ctx.ReadDataShort(32UL, (short)0); + public @theUnion.READER TheUnion => new @theUnion.READER(ctx); + public @anotherUnion.READER AnotherUnion => new @anotherUnion.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 3); + } + + public int Foo + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Bar + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public short Baz + { + get => this.ReadDataShort(32UL, (short)0); + set => this.WriteData(32UL, value, (short)0); + } + + public @theUnion.WRITER TheUnion + { + get => Rewrap<@theUnion.WRITER>(); + } + + public @anotherUnion.WRITER AnotherUnion + { + get => Rewrap<@anotherUnion.WRITER>(); + } + } + + public class @theUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Grault = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = reader.Corge; + break; + case WHICH.Grault: + Grault = reader.Grault; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = null; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Grault: + _content = 0F; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux; + break; + case WHICH.Corge: + writer.Corge.Init(Corge); + break; + case WHICH.Grault: + writer.Grault = Grault.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get => _which == WHICH.Qux ? (string)_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public IReadOnlyList Corge + { + get => _which == WHICH.Corge ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public float? Grault + { + get => _which == WHICH.Grault ? (float? )_content : null; + set + { + _which = WHICH.Grault; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public string Qux => which == WHICH.Qux ? ctx.ReadText(1, "") : default; + public IReadOnlyList Corge => which == WHICH.Corge ? ctx.ReadList(1).CastInt() : default; + public float Grault => which == WHICH.Grault ? ctx.ReadDataFloat(64UL, 0F) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public string Qux + { + get => which == WHICH.Qux ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public ListOfPrimitivesSerializer Corge + { + get => which == WHICH.Corge ? BuildPointer>(1) : default; + set => Link(1, value); + } + + public float Grault + { + get => which == WHICH.Grault ? this.ReadDataFloat(64UL, 0F) : default; + set => this.WriteData(64UL, value, 0F); + } + } + } + + public class @anotherUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Grault = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = reader.Corge; + break; + case WHICH.Grault: + Grault = reader.Grault; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = null; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Grault: + _content = 0F; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux; + break; + case WHICH.Corge: + writer.Corge.Init(Corge); + break; + case WHICH.Grault: + writer.Grault = Grault.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get => _which == WHICH.Qux ? (string)_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public IReadOnlyList Corge + { + get => _which == WHICH.Corge ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public float? Grault + { + get => _which == WHICH.Grault ? (float? )_content : null; + set + { + _which = WHICH.Grault; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(96U, (ushort)0); + public string Qux => which == WHICH.Qux ? ctx.ReadText(2, "") : default; + public IReadOnlyList Corge => which == WHICH.Corge ? ctx.ReadList(2).CastInt() : default; + public float Grault => which == WHICH.Grault ? ctx.ReadDataFloat(128UL, 0F) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(96U, (ushort)0); + set => this.WriteData(96U, (ushort)value, (ushort)0); + } + + public string Qux + { + get => which == WHICH.Qux ? this.ReadText(2, "") : default; + set => this.WriteText(2, value, ""); + } + + public ListOfPrimitivesSerializer Corge + { + get => which == WHICH.Corge ? BuildPointer>(2) : default; + set => Link(2, value); + } + + public float Grault + { + get => which == WHICH.Grault ? this.ReadDataFloat(128UL, 0F) : default; + set => this.WriteData(128UL, value, 0F); + } + } + } + } + + public class TestOldVersion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Old1 = reader.Old1; + Old2 = reader.Old2; + Old3 = CapnpSerializable.Create(reader.Old3); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Old1 = Old1; + writer.Old2 = Old2; + Old3?.serialize(writer.Old3); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public long Old1 + { + get; + set; + } + + public string Old2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestOldVersion Old3 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public long Old1 => ctx.ReadDataLong(0UL, 0L); + public string Old2 => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestOldVersion.READER Old3 => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestOldVersion.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public long Old1 + { + get => this.ReadDataLong(0UL, 0L); + set => this.WriteData(0UL, value, 0L); + } + + public string Old2 + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestOldVersion.WRITER Old3 + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class TestNewVersion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Old1 = reader.Old1; + Old2 = reader.Old2; + Old3 = CapnpSerializable.Create(reader.Old3); + New1 = reader.New1; + New2 = reader.New2; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Old1 = Old1; + writer.Old2 = Old2; + Old3?.serialize(writer.Old3); + writer.New1 = New1; + writer.New2 = New2; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + New2 = New2 ?? "baz"; + } + + public long Old1 + { + get; + set; + } + + public string Old2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNewVersion Old3 + { + get; + set; + } + + public long New1 + { + get; + set; + } + + = 987L; + public string New2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public long Old1 => ctx.ReadDataLong(0UL, 0L); + public string Old2 => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestNewVersion.READER Old3 => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestNewVersion.READER.create); + public long New1 => ctx.ReadDataLong(64UL, 987L); + public string New2 => ctx.ReadText(2, "baz"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 3); + } + + public long Old1 + { + get => this.ReadDataLong(0UL, 0L); + set => this.WriteData(0UL, value, 0L); + } + + public string Old2 + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestNewVersion.WRITER Old3 + { + get => BuildPointer(1); + set => Link(1, value); + } + + public long New1 + { + get => this.ReadDataLong(64UL, 987L); + set => this.WriteData(64UL, value, 987L); + } + + public string New2 + { + get => this.ReadText(2, "baz"); + set => this.WriteText(2, value, "baz"); + } + } + } + + public class TestOldUnionVersion : ICapnpSerializable + { + public enum WHICH : ushort + { + A = 0, + B = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A: + which = reader.which; + break; + case WHICH.B: + B = reader.B; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A: + break; + case WHICH.B: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A: + break; + case WHICH.B: + writer.B = B.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong? B + { + get => _which == WHICH.B ? (ulong? )_content : null; + set + { + _which = WHICH.B; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public ulong B => which == WHICH.B ? ctx.ReadDataULong(64UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public ulong B + { + get => which == WHICH.B ? this.ReadDataULong(64UL, 0UL) : default; + set => this.WriteData(64UL, value, 0UL); + } + } + } + + public class TestNewUnionVersion : ICapnpSerializable + { + public enum WHICH : ushort + { + A = 0, + B = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A: + A = CapnpSerializable.Create(reader.A); + break; + case WHICH.B: + B = reader.B; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A: + _content = null; + break; + case WHICH.B: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A: + A?.serialize(writer.A); + break; + case WHICH.B: + writer.B = B.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNewUnionVersion.@a A + { + get => _which == WHICH.A ? (Capnproto_test.Capnp.Test.TestNewUnionVersion.@a)_content : null; + set + { + _which = WHICH.A; + _content = value; + } + } + + public ulong? B + { + get => _which == WHICH.B ? (ulong? )_content : null; + set + { + _which = WHICH.B; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public @a.READER A => which == WHICH.A ? new @a.READER(ctx) : default; + public ulong B => which == WHICH.B ? ctx.ReadDataULong(64UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public @a.WRITER A + { + get => which == WHICH.A ? Rewrap<@a.WRITER>() : default; + } + + public ulong B + { + get => which == WHICH.B ? this.ReadDataULong(64UL, 0UL) : default; + set => this.WriteData(64UL, value, 0UL); + } + } + + public class @a : ICapnpSerializable + { + public enum WHICH : ushort + { + A0 = 0, + A1 = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A0: + which = reader.which; + break; + case WHICH.A1: + A1 = reader.A1; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A0: + break; + case WHICH.A1: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A0: + break; + case WHICH.A1: + writer.A1 = A1.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong? A1 + { + get => _which == WHICH.A1 ? (ulong? )_content : null; + set + { + _which = WHICH.A1; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public ulong A1 => which == WHICH.A1 ? ctx.ReadDataULong(128UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public ulong A1 + { + get => which == WHICH.A1 ? this.ReadDataULong(128UL, 0UL) : default; + set => this.WriteData(128UL, value, 0UL); + } + } + } + } + + public class TestStructUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Un = CapnpSerializable.Create(reader.Un); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Un?.serialize(writer.Un); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestStructUnion.@un Un + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @un.READER Un => new @un.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public @un.WRITER Un + { + get => Rewrap<@un.WRITER>(); + } + } + + public class @un : ICapnpSerializable + { + public enum WHICH : ushort + { + Struct = 0, + Object = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Struct: + Struct = CapnpSerializable.Create(reader.Struct); + break; + case WHICH.Object: + Object = CapnpSerializable.Create(reader.Object); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Struct: + _content = null; + break; + case WHICH.Object: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Struct: + Struct?.serialize(writer.Struct); + break; + case WHICH.Object: + Object?.serialize(writer.Object); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct Struct + { + get => _which == WHICH.Struct ? (Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct)_content : null; + set + { + _which = WHICH.Struct; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestAnyPointer Object + { + get => _which == WHICH.Object ? (Capnproto_test.Capnp.Test.TestAnyPointer)_content : null; + set + { + _which = WHICH.Object; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.READER Struct => which == WHICH.Struct ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.READER.create) : default; + public Capnproto_test.Capnp.Test.TestAnyPointer.READER Object => which == WHICH.Object ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAnyPointer.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.WRITER Struct + { + get => which == WHICH.Struct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestAnyPointer.WRITER Object + { + get => which == WHICH.Object ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class SomeStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + SomeText = reader.SomeText; + MoreText = reader.MoreText; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.SomeText = SomeText; + writer.MoreText = MoreText; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string SomeText + { + get; + set; + } + + public string MoreText + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string SomeText => ctx.ReadText(0, ""); + public string MoreText => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string SomeText + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string MoreText + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + } + + public class TestPrintInlineStructs : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + SomeText = reader.SomeText; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.SomeText = SomeText; + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string SomeText + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string SomeText => ctx.ReadText(0, ""); + public IReadOnlyList StructList => ctx.ReadList(1).Cast(Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string SomeText + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + + public class InlineStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Int32Field = reader.Int32Field; + TextField = reader.TextField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Int32Field = Int32Field; + writer.TextField = TextField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Int32Field + { + get; + set; + } + + public string TextField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Int32Field => ctx.ReadDataInt(0UL, 0); + public string TextField => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int Int32Field + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string TextField + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + + public class TestWholeFloatDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Field = reader.Field; + BigField = reader.BigField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Field = Field; + writer.BigField = BigField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public float Field + { + get; + set; + } + + = 123F; + public float BigField + { + get; + set; + } + + = 2E+30F; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public float Field => ctx.ReadDataFloat(0UL, 123F); + public float BigField => ctx.ReadDataFloat(32UL, 2E+30F); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public float Field + { + get => this.ReadDataFloat(0UL, 123F); + set => this.WriteData(0UL, value, 123F); + } + + public float BigField + { + get => this.ReadDataFloat(32UL, 2E+30F); + set => this.WriteData(32UL, value, 2E+30F); + } + } + } + + public class TestGenerics : ICapnpSerializable where TFoo : class where TBar : class + { + public enum WHICH : ushort + { + Uv = 0, + Ug = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Uv: + which = reader.which; + break; + case WHICH.Ug: + Ug = CapnpSerializable.Create.@ug>(reader.Ug); + break; + } + + Foo = CapnpSerializable.Create(reader.Foo); + Rev = CapnpSerializable.Create>(reader.Rev); + List = reader.List.ToReadOnlyList(_ => CapnpSerializable.Create.Inner>(_)); + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Uv: + break; + case WHICH.Ug: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Uv: + break; + case WHICH.Ug: + Ug?.serialize(writer.Ug); + break; + } + + writer.Foo.SetObject(Foo); + Rev?.serialize(writer.Rev); + writer.List.Init(List, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Rev + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.@ug Ug + { + get => _which == WHICH.Ug ? (Capnproto_test.Capnp.Test.TestGenerics.@ug)_content : null; + set + { + _which = WHICH.Ug; + _content = value; + } + } + + public IReadOnlyList.Inner> List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public DeserializerState Foo => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.READER Rev => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public @ug.READER Ug => which == WHICH.Ug ? new @ug.READER(ctx) : default; + public IReadOnlyList.Inner.READER> List => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 3); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Rev + { + get => BuildPointer.WRITER>(1); + set => Link(1, value); + } + + public @ug.WRITER Ug + { + get => which == WHICH.Ug ? Rewrap<@ug.WRITER>() : default; + } + + public ListOfStructsSerializer.Inner.WRITER> List + { + get => BuildPointer.Inner.WRITER>>(2); + set => Link(2, value); + } + } + + public class @ug : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Ugfoo = reader.Ugfoo; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Ugfoo = Ugfoo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Ugfoo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Ugfoo => ctx.ReadDataInt(32UL, 0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Ugfoo + { + get => this.ReadDataInt(32UL, 0); + set => this.WriteData(32UL, value, 0); + } + } + } + + public class Inner : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public TBar Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Inner2 : ICapnpSerializable where TBaz : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Bar = CapnpSerializable.Create(reader.Bar); + Baz = CapnpSerializable.Create(reader.Baz); + InnerBound = CapnpSerializable.Create.Inner>(reader.InnerBound); + InnerUnbound = CapnpSerializable.Create.Inner>(reader.InnerUnbound); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Bar.SetObject(Bar); + writer.Baz.SetObject(Baz); + InnerBound?.serialize(writer.InnerBound); + InnerUnbound?.serialize(writer.InnerUnbound); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TBar Bar + { + get; + set; + } + + public TBaz Baz + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner InnerBound + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner InnerUnbound + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Bar => ctx.StructReadPointer(0); + public DeserializerState Baz => ctx.StructReadPointer(1); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER InnerBound => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER InnerUnbound => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Baz + { + get => BuildPointer(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER InnerBound + { + get => BuildPointer.Inner.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER InnerUnbound + { + get => BuildPointer.Inner.WRITER>(3); + set => Link(3, value); + } + } + + public class DeepNest : ICapnpSerializable where TQux : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + Baz = CapnpSerializable.Create(reader.Baz); + Qux = CapnpSerializable.Create(reader.Qux); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + writer.Baz.SetObject(Baz); + writer.Qux.SetObject(Qux); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public TBar Bar + { + get; + set; + } + + public TBaz Baz + { + get; + set; + } + + public TQux Qux + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + public DeserializerState Baz => ctx.StructReadPointer(2); + public DeserializerState Qux => ctx.StructReadPointer(3); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + + public DynamicSerializerState Baz + { + get => BuildPointer(2); + set => Link(2, value); + } + + public DynamicSerializerState Qux + { + get => BuildPointer(3); + set => Link(3, value); + } + } + + [Proxy(typeof(DeepNestInterfaceProxy<>)), Skeleton(typeof(DeepNestInterfaceSkeleton<>))] + public interface IDeepNestInterface : IDisposable + { + Task Call(CancellationToken cancellationToken_ = default); + } + + public class DeepNestInterfaceProxy : Proxy, IDeepNestInterface where TQuux : class + { + public async Task Call(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Inner2.DeepNest.DeepNestInterface.Params_call.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestGenerics.Inner2.DeepNest.DeepNestInterface.Params_call() + {}; + arg_.serialize(in_); + var d_ = await Call(9816138025992274567UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create.Inner2.DeepNest.DeepNestInterface.Result_call>(d_); + return; + } + } + + public class DeepNestInterfaceSkeleton : Skeleton> where TQuux : class + { + public DeepNestInterfaceSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 9816138025992274567UL; + async Task Call(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Call(cancellationToken_); + var s_ = SerializerState.CreateForRpc.Inner2.DeepNest.DeepNestInterface.Result_call.WRITER>(); + return s_; + } + } + + public static class DeepNestInterface + where TQuux : class + { + public class Params_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + } + } + + [Proxy(typeof(InterfaceProxy<>)), Skeleton(typeof(InterfaceSkeleton<>))] + public interface IInterface : IDisposable + { + Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics)> Call(Capnproto_test.Capnp.Test.TestGenerics.Inner2 arg_, CancellationToken cancellationToken_ = default); + } + + public class InterfaceProxy : Proxy, IInterface where TQux : class + { + public Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics)> Call(Capnproto_test.Capnp.Test.TestGenerics.Inner2 arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Inner2.WRITER>(); + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(14548678385738242652UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create.Interface.Result_call>(d_); + return (r_.Qux, r_.Gen); + } + + ); + } + } + + public class InterfaceSkeleton : Skeleton> where TQux : class + { + public InterfaceSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 14548678385738242652UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Call(CapnpSerializable.Create.Inner2>(d_), cancellationToken_), (qux, gen) => + { + var s_ = SerializerState.CreateForRpc.Interface.Result_call.WRITER>(); + var r_ = new Capnproto_test.Capnp.Test.TestGenerics.Interface.Result_call{Qux = qux, Gen = gen}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class Interface + where TQux : class + { + public class Result_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Qux = CapnpSerializable.Create(reader.Qux); + Gen = CapnpSerializable.Create>(reader.Gen); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Qux.SetObject(Qux); + Gen?.serialize(writer.Gen); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TQux Qux + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Gen + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Qux => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.READER Gen => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Qux + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Gen + { + get => BuildPointer.WRITER>(1); + set => Link(1, value); + } + } + } + } + + public class UseAliases : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Inner = CapnpSerializable.Create.Inner>(reader.Inner); + Inner2 = CapnpSerializable.Create.Inner2>(reader.Inner2); + Inner2Bind = CapnpSerializable.Create.Inner2>(reader.Inner2Bind); + Inner2Text = CapnpSerializable.Create.Inner2>(reader.Inner2Text); + RevFoo = CapnpSerializable.Create(reader.RevFoo); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + Inner?.serialize(writer.Inner); + Inner2?.serialize(writer.Inner2); + Inner2Bind?.serialize(writer.Inner2Bind); + Inner2Text?.serialize(writer.Inner2Text); + writer.RevFoo.SetObject(RevFoo); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner Inner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2Bind + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2Text + { + get; + set; + } + + public TBar RevFoo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2Bind => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2Text => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public DeserializerState RevFoo => ctx.StructReadPointer(5); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 6); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER Inner + { + get => BuildPointer.Inner.WRITER>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2 + { + get => BuildPointer.Inner2.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2Bind + { + get => BuildPointer.Inner2.WRITER>(3); + set => Link(3, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2Text + { + get => BuildPointer.Inner2.WRITER>(4); + set => Link(4, value); + } + + public DynamicSerializerState RevFoo + { + get => BuildPointer(5); + set => Link(5, value); + } + } + } + } + + public class TestGenericsWrapper : ICapnpSerializable where TFoo : class where TBar : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Value = CapnpSerializable.Create>(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGenerics Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenerics.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Value + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + } + } + + public class TestGenericsWrapper2 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Value = CapnpSerializable.Create>(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER Value + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + } + } + + [Proxy(typeof(TestImplicitMethodParamsProxy)), Skeleton(typeof(TestImplicitMethodParamsSkeleton))] + public interface ITestImplicitMethodParams : IDisposable + { + Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class; + } + + public class TestImplicitMethodParamsProxy : Proxy, ITestImplicitMethodParams + { + public Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class + { + var in_ = SerializerState.CreateForRpc.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParams.Params_call() + {Foo = foo, Bar = bar}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(10058534285777328794UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create>(d_); + return r_; + } + + ); + } + } + + public class TestImplicitMethodParamsSkeleton : Skeleton + { + public TestImplicitMethodParamsSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 10058534285777328794UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + where TT : class where TU : class + { + var in_ = CapnpSerializable.Create>(d_); + return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc.WRITER>(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestImplicitMethodParams + { + public class Params_call : ICapnpSerializable where TT : class where TU : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TT Foo + { + get; + set; + } + + public TU Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + [Proxy(typeof(TestImplicitMethodParamsInGenericProxy<>)), Skeleton(typeof(TestImplicitMethodParamsInGenericSkeleton<>))] + public interface ITestImplicitMethodParamsInGeneric : IDisposable + { + Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class; + } + + public class TestImplicitMethodParamsInGenericProxy : Proxy, ITestImplicitMethodParamsInGeneric where TV : class + { + public Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class + { + var in_ = SerializerState.CreateForRpc.Params_call.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParamsInGeneric.Params_call() + {Foo = foo, Bar = bar}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(16112979978201007305UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create>(d_); + return r_; + } + + ); + } + } + + public class TestImplicitMethodParamsInGenericSkeleton : Skeleton> where TV : class + { + public TestImplicitMethodParamsInGenericSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 16112979978201007305UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + where TT : class where TU : class + { + var in_ = CapnpSerializable.Create.Params_call>(d_); + return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc.WRITER>(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestImplicitMethodParamsInGeneric + where TV : class + { + public class Params_call : ICapnpSerializable where TT : class where TU : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TT Foo + { + get; + set; + } + + public TU Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + public class TestGenericsUnion : ICapnpSerializable where TFoo : class where TBar : class + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = CapnpSerializable.Create(reader.Foo); + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo.SetObject(Foo); + break; + case WHICH.Bar: + writer.Bar.SetObject(Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get => _which == WHICH.Foo ? (TFoo)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public TBar Bar + { + get => _which == WHICH.Bar ? (TBar)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public DeserializerState Foo => which == WHICH.Foo ? ctx.StructReadPointer(0) : default; + public DeserializerState Bar => which == WHICH.Bar ? ctx.StructReadPointer(0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState Foo + { + get => which == WHICH.Foo ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => which == WHICH.Bar ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class TestUseGenerics : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Basic = CapnpSerializable.Create>(reader.Basic); + Inner = CapnpSerializable.Create.Inner>(reader.Inner); + Inner2 = CapnpSerializable.Create.Inner2>(reader.Inner2); + Unspecified = CapnpSerializable.Create>(reader.Unspecified); + UnspecifiedInner = CapnpSerializable.Create.Inner2>(reader.UnspecifiedInner); + Default = CapnpSerializable.Create>(reader.Default); + DefaultInner = CapnpSerializable.Create.Inner>(reader.DefaultInner); + DefaultUser = CapnpSerializable.Create(reader.DefaultUser); + Wrapper = CapnpSerializable.Create>(reader.Wrapper); + DefaultWrapper = CapnpSerializable.Create>(reader.DefaultWrapper); + DefaultWrapper2 = CapnpSerializable.Create(reader.DefaultWrapper2); + AliasFoo = CapnpSerializable.Create(reader.AliasFoo); + AliasInner = CapnpSerializable.Create.Inner>(reader.AliasInner); + AliasInner2 = CapnpSerializable.Create.Inner2>(reader.AliasInner2); + AliasInner2Bind = CapnpSerializable.Create.Inner2>>(reader.AliasInner2Bind); + AliasInner2Text = CapnpSerializable.Create.Inner2>(reader.AliasInner2Text); + AliasRev = reader.AliasRev; + UseAliases = CapnpSerializable.Create>.UseAliases>(reader.UseAliases); + Cap = CapnpSerializable.Create>(reader.Cap); + GenericCap = reader.GenericCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Basic?.serialize(writer.Basic); + Inner?.serialize(writer.Inner); + Inner2?.serialize(writer.Inner2); + Unspecified?.serialize(writer.Unspecified); + UnspecifiedInner?.serialize(writer.UnspecifiedInner); + Default?.serialize(writer.Default); + DefaultInner?.serialize(writer.DefaultInner); + DefaultUser?.serialize(writer.DefaultUser); + Wrapper?.serialize(writer.Wrapper); + DefaultWrapper?.serialize(writer.DefaultWrapper); + DefaultWrapper2?.serialize(writer.DefaultWrapper2); + AliasFoo?.serialize(writer.AliasFoo); + AliasInner?.serialize(writer.AliasInner); + AliasInner2?.serialize(writer.AliasInner2); + AliasInner2Bind?.serialize(writer.AliasInner2Bind); + AliasInner2Text?.serialize(writer.AliasInner2Text); + writer.AliasRev = AliasRev; + UseAliases?.serialize(writer.UseAliases); + Cap?.serialize(writer.Cap); + writer.GenericCap = GenericCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + Default = Default ?? new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}; + DefaultInner = DefaultInner ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = "text"}; + DefaultUser = DefaultUser ?? new Capnproto_test.Capnp.Test.TestUseGenerics() + {Basic = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, Inner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, Inner2 = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, Unspecified = new Capnproto_test.Capnp.Test.TestGenerics() + {}, UnspecifiedInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, Default = new Capnproto_test.Capnp.Test.TestGenerics() + {}, DefaultInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, DefaultUser = new Capnproto_test.Capnp.Test.TestUseGenerics() + {}, Wrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {}, DefaultWrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {}, DefaultWrapper2 = new Capnproto_test.Capnp.Test.TestGenericsWrapper2() + {}, AliasFoo = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, AliasInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, AliasInner2 = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, AliasInner2Bind = new Capnproto_test.Capnp.Test.TestGenerics.Inner2>() + {}, AliasInner2Text = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, AliasRev = null, UseAliases = new Capnproto_test.Capnp.Test.TestGenerics>.UseAliases() + {}, Cap = new Capnproto_test.Capnp.Test.TestGenerics() + {}}; + DefaultWrapper = DefaultWrapper ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {Value = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}}; + DefaultWrapper2 = DefaultWrapper2 ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper2() + {Value = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {Value = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}}}; + AliasFoo = AliasFoo ?? new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}; + AliasInner = AliasInner ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}; + AliasInner2 = AliasInner2 ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasInner2Bind = AliasInner2Bind ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2>() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, Baz = new uint[]{12U, 34U}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasInner2Text = AliasInner2Text ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasRev = AliasRev ?? "text"; + UseAliases = UseAliases ?? new Capnproto_test.Capnp.Test.TestGenerics>.UseAliases() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Inner = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, Inner2 = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, Inner2Bind = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, Inner2Text = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, RevFoo = new uint[]{12U, 34U, 56U}}; + } + + public Capnproto_test.Capnp.Test.TestGenerics Basic + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner Inner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Unspecified + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 UnspecifiedInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Default + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner DefaultInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUseGenerics DefaultUser + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper Wrapper + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper DefaultWrapper + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper2 DefaultWrapper2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes AliasFoo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner AliasInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 AliasInner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2> AliasInner2Bind + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 AliasInner2Text + { + get; + set; + } + + public string AliasRev + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases UseAliases + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Cap + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenerics.READER Basic => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Unspecified => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER UnspecifiedInner => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Default => ctx.ReadStruct(5, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER DefaultInner => ctx.ReadStruct(6, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestUseGenerics.READER DefaultUser => ctx.ReadStruct(7, Capnproto_test.Capnp.Test.TestUseGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER Wrapper => ctx.ReadStruct(8, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER DefaultWrapper => ctx.ReadStruct(9, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper2.READER DefaultWrapper2 => ctx.ReadStruct(10, Capnproto_test.Capnp.Test.TestGenericsWrapper2.READER.create); + public Capnproto_test.Capnp.Test.TestAllTypes.READER AliasFoo => ctx.ReadStruct(11, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER AliasInner => ctx.ReadStruct(12, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER AliasInner2 => ctx.ReadStruct(13, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2>.READER AliasInner2Bind => ctx.ReadStruct(14, Capnproto_test.Capnp.Test.TestGenerics.Inner2>.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER AliasInner2Text => ctx.ReadStruct(15, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public string AliasRev => ctx.ReadText(16, "text"); + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.READER UseAliases => ctx.ReadStruct(17, Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Cap => ctx.ReadStruct(18, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap => ctx.ReadCap>.IInterface>>(19); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 20); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Basic + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER Inner + { + get => BuildPointer.Inner.WRITER>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2 + { + get => BuildPointer.Inner2.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Unspecified + { + get => BuildPointer.WRITER>(3); + set => Link(3, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER UnspecifiedInner + { + get => BuildPointer.Inner2.WRITER>(4); + set => Link(4, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Default + { + get => BuildPointer.WRITER>(5); + set => Link(5, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER DefaultInner + { + get => BuildPointer.Inner.WRITER>(6); + set => Link(6, value); + } + + public Capnproto_test.Capnp.Test.TestUseGenerics.WRITER DefaultUser + { + get => BuildPointer(7); + set => Link(7, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER Wrapper + { + get => BuildPointer.WRITER>(8); + set => Link(8, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER DefaultWrapper + { + get => BuildPointer.WRITER>(9); + set => Link(9, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper2.WRITER DefaultWrapper2 + { + get => BuildPointer(10); + set => Link(10, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER AliasFoo + { + get => BuildPointer(11); + set => Link(11, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER AliasInner + { + get => BuildPointer.Inner.WRITER>(12); + set => Link(12, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER AliasInner2 + { + get => BuildPointer.Inner2.WRITER>(13); + set => Link(13, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2>.WRITER AliasInner2Bind + { + get => BuildPointer.Inner2>.WRITER>(14); + set => Link(14, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER AliasInner2Text + { + get => BuildPointer.Inner2.WRITER>(15); + set => Link(15, value); + } + + public string AliasRev + { + get => this.ReadText(16, "text"); + set => this.WriteText(16, value, "text"); + } + + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.WRITER UseAliases + { + get => BuildPointer>.UseAliases.WRITER>(17); + set => Link(17, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Cap + { + get => BuildPointer.WRITER>(18); + set => Link(18, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap + { + get => ReadCap>.IInterface>>(19); + set => LinkObject(19, value); + } + } + } + + public class TestEmptyStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestConstants : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestAnyPointerConstants : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyKindAsStruct = CapnpSerializable.Create(reader.AnyKindAsStruct); + AnyStructAsStruct = CapnpSerializable.Create(reader.AnyStructAsStruct); + AnyKindAsList = CapnpSerializable.Create(reader.AnyKindAsList); + AnyListAsList = reader.AnyListAsList.ToReadOnlyList(_ => (object)_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyKindAsStruct.SetObject(AnyKindAsStruct); + writer.AnyStructAsStruct.SetObject(AnyStructAsStruct); + writer.AnyKindAsList.SetObject(AnyKindAsList); + writer.AnyListAsList.SetObject(AnyListAsList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyKindAsStruct + { + get; + set; + } + + public AnyPointer AnyStructAsStruct + { + get; + set; + } + + public AnyPointer AnyKindAsList + { + get; + set; + } + + public IReadOnlyList AnyListAsList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyKindAsStruct => ctx.StructReadPointer(0); + public DeserializerState AnyStructAsStruct => ctx.StructReadPointer(1); + public DeserializerState AnyKindAsList => ctx.StructReadPointer(2); + public IReadOnlyList AnyListAsList => (IReadOnlyList)ctx.ReadList(3); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState AnyKindAsStruct + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState AnyStructAsStruct + { + get => BuildPointer(1); + set => Link(1, value); + } + + public DynamicSerializerState AnyKindAsList + { + get => BuildPointer(2); + set => Link(2, value); + } + + public DynamicSerializerState AnyListAsList + { + get => BuildPointer(3); + set => Link(3, value); + } + } + } + + [Proxy(typeof(TestInterfaceProxy)), Skeleton(typeof(TestInterfaceSkeleton))] + public interface ITestInterface : IDisposable + { + Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default); + Task Bar(CancellationToken cancellationToken_ = default); + Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default); + } + + public class TestInterfaceProxy : Proxy, ITestInterface + { + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestInterfaceSkeleton : Skeleton + { + public TestInterfaceSkeleton() + { + SetMethodTable(Foo, Bar, Baz); + } + + public override ulong InterfaceId => 9865999890858873522UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.J, cancellationToken_), x => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestInterface.Result_foo{X = x}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task Bar(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Bar(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Baz(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.Baz(in_.S, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestInterface + { + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + J = reader.J; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.J = J; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint I + { + get; + set; + } + + public bool J + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint I => ctx.ReadDataUInt(0UL, 0U); + public bool J => ctx.ReadDataBool(32UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint I + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool J + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + } + } + + public class Result_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + X = reader.X; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.X = X; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string X + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string X => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string X + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = CapnpSerializable.Create(reader.S); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + S?.serialize(writer.S); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestAllTypes S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestAllTypes.READER S => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER S + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class Result_baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestExtendsProxy)), Skeleton(typeof(TestExtendsSkeleton))] + public interface ITestExtends : Capnproto_test.Capnp.Test.ITestInterface + { + Task Qux(CancellationToken cancellationToken_ = default); + Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default); + Task Grault(CancellationToken cancellationToken_ = default); + } + + public class TestExtendsProxy : Proxy, ITestExtends + { + public async Task Qux(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Grault(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestExtendsSkeleton : Skeleton + { + public TestExtendsSkeleton() + { + SetMethodTable(Qux, Corge, Grault); + } + + public override ulong InterfaceId => 16494920484927878984UL; + async Task Qux(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Qux(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Corge(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Corge(CapnpSerializable.Create(d_), cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task Grault(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Grault(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestExtends + { + public class Params_qux : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_qux : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_grault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestExtends2Proxy)), Skeleton(typeof(TestExtends2Skeleton))] + public interface ITestExtends2 : Capnproto_test.Capnp.Test.ITestExtends + { + } + + public class TestExtends2Proxy : Proxy, ITestExtends2 + { + public async Task Qux(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Grault(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestExtends2Skeleton : Skeleton + { + public TestExtends2Skeleton() + { + SetMethodTable(); + } + + public override ulong InterfaceId => 11013518732491786115UL; + } + + [Proxy(typeof(TestPipelineProxy)), Skeleton(typeof(TestPipelineSkeleton))] + public interface ITestPipeline : IDisposable + { + Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> GetCap(uint n, Capnproto_test.Capnp.Test.ITestInterface inCap, CancellationToken cancellationToken_ = default); + Task TestPointers(Capnproto_test.Capnp.Test.ITestInterface cap, AnyPointer obj, IReadOnlyList list, CancellationToken cancellationToken_ = default); + Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_ = default); + } + + public class TestPipelineProxy : Proxy, ITestPipeline + { + public Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> GetCap(uint n, Capnproto_test.Capnp.Test.ITestInterface inCap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_getCap() + {N = n, InCap = inCap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(11935670180855499984UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.S, r_.OutBox); + } + + ); + } + + public async Task TestPointers(Capnproto_test.Capnp.Test.ITestInterface cap, AnyPointer obj, IReadOnlyList list, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_testPointers() + {Cap = cap, Obj = obj, List = list}; + arg_.serialize(in_); + var d_ = await Call(11935670180855499984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_getAnyCap() + {N = n, InCap = inCap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(11935670180855499984UL, 2, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.S, r_.OutBox); + } + + ); + } + } + + public class TestPipelineSkeleton : Skeleton + { + public TestPipelineSkeleton() + { + SetMethodTable(GetCap, TestPointers, GetAnyCap); + } + + public override ulong InterfaceId => 11935670180855499984UL; + Task GetCap(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestPipeline.Result_getCap{S = s, OutBox = outBox}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task TestPointers(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.TestPointers(in_.Cap, in_.Obj, in_.List, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task GetAnyCap(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetAnyCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestPipeline.Result_getAnyCap{S = s, OutBox = outBox}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_getCap_OutBox_Cap = new MemberAccessPath(1U, 0U); + public static Capnproto_test.Capnp.Test.ITestInterface OutBox_Cap(this Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> task) + { + return (Capnproto_test.Capnp.Test.ITestInterface)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getCap_OutBox_Cap)); + } + + static readonly MemberAccessPath Path_getAnyCap_OutBox_Cap = new MemberAccessPath(1U, 0U); + public static BareProxy OutBox_Cap(this Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> task) + { + return (BareProxy)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getAnyCap_OutBox_Cap)); + } + } + + public static class TestPipeline + { + public class Box : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class AnyBox : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public BareProxy Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public BareProxy Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public BareProxy Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + InCap = reader.InCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + writer.InCap = InCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface InCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + public Capnproto_test.Capnp.Test.ITestInterface InCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnproto_test.Capnp.Test.ITestInterface InCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_getCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + OutBox = CapnpSerializable.Create(reader.OutBox); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + OutBox?.serialize(writer.OutBox); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestPipeline.Box OutBox + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestPipeline.Box.READER OutBox => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestPipeline.Box.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestPipeline.Box.WRITER OutBox + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Params_testPointers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + Obj = CapnpSerializable.Create(reader.Obj); + List = reader.List; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + writer.Obj.SetObject(Obj); + writer.List.Init(List); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public AnyPointer Obj + { + get; + set; + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + public DeserializerState Obj => ctx.StructReadPointer(1); + public IReadOnlyList List => ctx.ReadCapList(2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public DynamicSerializerState Obj + { + get => BuildPointer(1); + set => Link(1, value); + } + + public ListOfCapsSerializer List + { + get => BuildPointer>(2); + set => Link(2, value); + } + } + } + + public class Result_testPointers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_getAnyCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + InCap = reader.InCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + writer.InCap = InCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public BareProxy InCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + public BareProxy InCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public BareProxy InCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_getAnyCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + OutBox = CapnpSerializable.Create(reader.OutBox); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + OutBox?.serialize(writer.OutBox); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox OutBox + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox.READER OutBox => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestPipeline.AnyBox.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox.WRITER OutBox + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + [Proxy(typeof(TestCallOrderProxy)), Skeleton(typeof(TestCallOrderSkeleton))] + public interface ITestCallOrder : IDisposable + { + Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default); + } + + public class TestCallOrderProxy : Proxy, ITestCallOrder + { + public async Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence() + {Expected = expected}; + arg_.serialize(in_); + var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.N); + } + } + + public class TestCallOrderSkeleton : Skeleton + { + public TestCallOrderSkeleton() + { + SetMethodTable(GetCallSequence); + } + + public override ulong InterfaceId => 11594359141811814481UL; + Task GetCallSequence(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetCallSequence(in_.Expected, cancellationToken_), n => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestCallOrder.Result_getCallSequence{N = n}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestCallOrder + { + public class Params_getCallSequence : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Expected = reader.Expected; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Expected = Expected; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Expected + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Expected => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint Expected + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Result_getCallSequence : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + } + + [Proxy(typeof(TestTailCalleeProxy)), Skeleton(typeof(TestTailCalleeSkeleton))] + public interface ITestTailCallee : IDisposable + { + Task Foo(int i, string t, CancellationToken cancellationToken_ = default); + } + + public class TestTailCalleeProxy : Proxy, ITestTailCallee + { + public Task Foo(int i, string t, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestTailCallee.Params_foo() + {I = i, T = t}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15985132292242203195UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + ); + } + } + + public class TestTailCalleeSkeleton : Skeleton + { + public TestTailCalleeSkeleton() + { + SetMethodTable(Foo); + } + + public override ulong InterfaceId => 15985132292242203195UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.T, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_foo_C = new MemberAccessPath(1U); + public static Capnproto_test.Capnp.Test.ITestCallOrder C(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_foo_C)); + } + } + + public static class TestTailCallee + { + public class TailResult : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + T = reader.T; + C = reader.C; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.T = T; + writer.C = C; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint I + { + get; + set; + } + + public string T + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestCallOrder C + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint I => ctx.ReadDataUInt(0UL, 0U); + public string T => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestCallOrder C => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint I + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string T + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder C + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + T = reader.T; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.T = T; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int I + { + get; + set; + } + + public string T + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int I => ctx.ReadDataInt(0UL, 0); + public string T => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int I + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string T + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + + [Proxy(typeof(TestTailCallerProxy)), Skeleton(typeof(TestTailCallerSkeleton))] + public interface ITestTailCaller : IDisposable + { + Task Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default); + } + + public class TestTailCallerProxy : Proxy, ITestTailCaller + { + public Task Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestTailCaller.Params_foo() + {I = i, Callee = callee}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(9731139705278181429UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + ); + } + } + + public class TestTailCallerSkeleton : Skeleton + { + public TestTailCallerSkeleton() + { + SetMethodTable(Foo); + } + + public override ulong InterfaceId => 9731139705278181429UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.Callee, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + } + + public static class TestTailCaller + { + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + Callee = reader.Callee; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.Callee = Callee; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int I + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestTailCallee Callee + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int I => ctx.ReadDataInt(0UL, 0); + public Capnproto_test.Capnp.Test.ITestTailCallee Callee => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int I + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public Capnproto_test.Capnp.Test.ITestTailCallee Callee + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + } + + [Proxy(typeof(TestHandleProxy)), Skeleton(typeof(TestHandleSkeleton))] + public interface ITestHandle : IDisposable + { + } + + public class TestHandleProxy : Proxy, ITestHandle + { + } + + public class TestHandleSkeleton : Skeleton + { + public TestHandleSkeleton() + { + SetMethodTable(); + } + + public override ulong InterfaceId => 11785461720995412501UL; + } + + [Proxy(typeof(TestMoreStuffProxy)), Skeleton(typeof(TestMoreStuffSkeleton))] + public interface ITestMoreStuff : Capnproto_test.Capnp.Test.ITestCallOrder + { + Task CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task CallHeld(CancellationToken cancellationToken_ = default); + Task GetHeld(CancellationToken cancellationToken_ = default); + Task Echo(Capnproto_test.Capnp.Test.ITestCallOrder cap, CancellationToken cancellationToken_ = default); + Task ExpectCancel(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_ = default); + Task GetHandle(CancellationToken cancellationToken_ = default); + Task GetNull(CancellationToken cancellationToken_ = default); + Task GetEnormousString(CancellationToken cancellationToken_ = default); + Task MethodWithNullDefault(string a, Capnproto_test.Capnp.Test.ITestInterface b, CancellationToken cancellationToken_ = default); + } + + public class TestMoreStuffProxy : Proxy, ITestMoreStuff + { + public async Task CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFoo() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public async Task CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFooWhenResolved() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public Task NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_neverReturn() + {Cap = cap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 2, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.CapCopy); + } + + ); + } + + public async Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_hold() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 3, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task CallHeld(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callHeld() + {}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 4, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public Task GetHeld(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHeld() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 5, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Cap); + } + + ); + } + + public Task Echo(Capnproto_test.Capnp.Test.ITestCallOrder cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_echo() + {Cap = cap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 6, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Cap); + } + + ); + } + + public async Task ExpectCancel(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_expectCancel() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 7, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithDefaults() + {A = a, B = b, C = c}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 8, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.D, r_.E); + } + + public Task GetHandle(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHandle() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 9, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Handle); + } + + ); + } + + public Task GetNull(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getNull() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 10, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.NullCap); + } + + ); + } + + public async Task GetEnormousString(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getEnormousString() + {}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 11, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.Str); + } + + public async Task MethodWithNullDefault(string a, Capnproto_test.Capnp.Test.ITestInterface b, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithNullDefault() + {A = a, B = b}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 12, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence() + {Expected = expected}; + arg_.serialize(in_); + var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.N); + } + } + + public class TestMoreStuffSkeleton : Skeleton + { + public TestMoreStuffSkeleton() + { + SetMethodTable(CallFoo, CallFooWhenResolved, NeverReturn, Hold, CallHeld, GetHeld, Echo, ExpectCancel, MethodWithDefaults, GetHandle, GetNull, GetEnormousString, MethodWithNullDefault); + } + + public override ulong InterfaceId => 15980754968839795663UL; + Task CallFoo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallFoo(in_.Cap, cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFoo{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallFooWhenResolved(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallFooWhenResolved(in_.Cap, cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFooWhenResolved{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task NeverReturn(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.NeverReturn(in_.Cap, cancellationToken_), capCopy => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_neverReturn{CapCopy = capCopy}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task Hold(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.Hold(in_.Cap, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task CallHeld(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.CallHeld(cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callHeld{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetHeld(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetHeld(cancellationToken_), cap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHeld{Cap = cap}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task Echo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Echo(in_.Cap, cancellationToken_), cap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_echo{Cap = cap}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task ExpectCancel(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.ExpectCancel(in_.Cap, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task MethodWithDefaults(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.MethodWithDefaults(in_.A, in_.B, in_.C, cancellationToken_), (d, e) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithDefaults{D = d, E = e}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetHandle(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetHandle(cancellationToken_), handle => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHandle{Handle = handle}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetNull(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetNull(cancellationToken_), nullCap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getNull{NullCap = nullCap}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetEnormousString(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetEnormousString(cancellationToken_), str => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getEnormousString{Str = str}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task MethodWithNullDefault(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.MethodWithNullDefault(in_.A, in_.B, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_neverReturn_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestInterface Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestInterface)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_neverReturn_Eager)); + } + + static readonly MemberAccessPath Path_echo_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestCallOrder Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_echo_Eager)); + } + + static readonly MemberAccessPath Path_getHandle_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestHandle Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestHandle)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getHandle_Eager)); + } + + static readonly MemberAccessPath Path_getNull_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestMoreStuff Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestMoreStuff)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getNull_Eager)); + } + } + + public static class TestMoreStuff + { + public class Params_callFoo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_callFoo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_callFooWhenResolved : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_callFooWhenResolved : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_neverReturn : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_neverReturn : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + CapCopy = reader.CapCopy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.CapCopy = CapCopy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface CapCopy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface CapCopy => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface CapCopy + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_hold : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_hold : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_callHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_callHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_getHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_echo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestCallOrder Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_echo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestCallOrder Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_expectCancel : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_expectCancel : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_methodWithDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + A = reader.A; + B = reader.B; + C = reader.C; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.A = A; + writer.B = B; + writer.C = C; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + C = C ?? "foo"; + } + + public string A + { + get; + set; + } + + public uint B + { + get; + set; + } + + = 123U; + public string C + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string A => ctx.ReadText(0, ""); + public uint B => ctx.ReadDataUInt(0UL, 123U); + public string C => ctx.ReadText(1, "foo"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public string A + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public uint B + { + get => this.ReadDataUInt(0UL, 123U); + set => this.WriteData(0UL, value, 123U); + } + + public string C + { + get => this.ReadText(1, "foo"); + set => this.WriteText(1, value, "foo"); + } + } + } + + public class Result_methodWithDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + D = reader.D; + E = reader.E; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.D = D; + writer.E = E; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + E = E ?? "bar"; + } + + public string D + { + get; + set; + } + + public string E + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string D => ctx.ReadText(0, ""); + public string E => ctx.ReadText(1, "bar"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string D + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string E + { + get => this.ReadText(1, "bar"); + set => this.WriteText(1, value, "bar"); + } + } + } + + public class Params_getHandle : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getHandle : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Handle = reader.Handle; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Handle = Handle; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestHandle Handle + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestHandle Handle => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestHandle Handle + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getNull : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getNull : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + NullCap = reader.NullCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.NullCap = NullCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getEnormousString : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getEnormousString : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Str = reader.Str; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Str = Str; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Str + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Str => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Str + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_methodWithNullDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + A = reader.A; + B = reader.B; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.A = A; + writer.B = B; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string A + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface B + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string A => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestInterface B => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string A + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestInterface B + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + + public class Result_methodWithNullDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestMembraneProxy)), Skeleton(typeof(TestMembraneSkeleton))] + public interface ITestMembrane : IDisposable + { + Task MakeThing(CancellationToken cancellationToken_ = default); + Task CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default); + Task CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default); + Task Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default); + Task WaitForever(CancellationToken cancellationToken_ = default); + } + + public class TestMembraneProxy : Proxy, ITestMembrane + { + public Task MakeThing(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_makeThing() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(13870398341137210380UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Thing); + } + + ); + } + + public async Task CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_callPassThrough() + {Thing = thing, TailCall = tailCall}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_callIntercept() + {Thing = thing, TailCall = tailCall}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public Task Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_loopback() + {Thing = thing}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(13870398341137210380UL, 3, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Thing); + } + + ); + } + + public async Task WaitForever(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_waitForever() + {}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 4, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestMembraneSkeleton : Skeleton + { + public TestMembraneSkeleton() + { + SetMethodTable(MakeThing, CallPassThrough, CallIntercept, Loopback, WaitForever); + } + + public override ulong InterfaceId => 13870398341137210380UL; + Task MakeThing(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.MakeThing(cancellationToken_), thing => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_makeThing{Thing = thing}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallPassThrough(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallPassThrough(in_.Thing, in_.TailCall, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallIntercept(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallIntercept(in_.Thing, in_.TailCall, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task Loopback(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Loopback(in_.Thing, cancellationToken_), thing => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_loopback{Thing = thing}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task WaitForever(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.WaitForever(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_makeThing_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.TestMembrane.IThing Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.TestMembrane.IThing)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_makeThing_Eager)); + } + } + + public static class TestMembrane + { + [Proxy(typeof(ThingProxy)), Skeleton(typeof(ThingSkeleton))] + public interface IThing : IDisposable + { + Task PassThrough(CancellationToken cancellationToken_ = default); + Task Intercept(CancellationToken cancellationToken_ = default); + } + + public class ThingProxy : Proxy, IThing + { + public async Task PassThrough(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_passThrough() + {}; + arg_.serialize(in_); + var d_ = await Call(10615798940090972439UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Intercept(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_intercept() + {}; + arg_.serialize(in_); + var d_ = await Call(10615798940090972439UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + } + + public class ThingSkeleton : Skeleton + { + public ThingSkeleton() + { + SetMethodTable(PassThrough, Intercept); + } + + public override ulong InterfaceId => 10615798940090972439UL; + Task PassThrough(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.PassThrough(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task Intercept(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Intercept(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class Thing + { + public class Params_passThrough : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_intercept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + public class Result : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Text = reader.Text; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Text = Text; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Text + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Text => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Text + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_makeThing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_makeThing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_callPassThrough : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + TailCall = reader.TailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + writer.TailCall = TailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public bool TailCall + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + public bool TailCall => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public bool TailCall + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Params_callIntercept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + TailCall = reader.TailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + writer.TailCall = TailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public bool TailCall + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + public bool TailCall => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public bool TailCall + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Params_loopback : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_loopback : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_waitForever : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_waitForever : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + public class TestContainMembrane : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + List = reader.List; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + writer.List.Init(List); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap + { + get; + set; + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap => ctx.ReadCap(0); + public IReadOnlyList List => ctx.ReadCapList(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public ListOfCapsSerializer List + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public class TestTransferCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + List = reader.List.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.List.Init(List, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList List => ctx.ReadList(0).Cast(Capnproto_test.Capnp.Test.TestTransferCap.Element.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public ListOfStructsSerializer List + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + + public class Element : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Text = reader.Text; + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Text = Text; + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Text + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Text => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Text + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + } + + [Proxy(typeof(TestKeywordMethodsProxy)), Skeleton(typeof(TestKeywordMethodsSkeleton))] + public interface ITestKeywordMethods : IDisposable + { + Task Delete(CancellationToken cancellationToken_ = default); + Task Class(CancellationToken cancellationToken_ = default); + Task Void(CancellationToken cancellationToken_ = default); + Task Return(CancellationToken cancellationToken_ = default); + } + + public class TestKeywordMethodsProxy : Proxy, ITestKeywordMethods + { + public async Task Delete(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_delete() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Class(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_class() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Void(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_void() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Return(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_return() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 3, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestKeywordMethodsSkeleton : Skeleton + { + public TestKeywordMethodsSkeleton() + { + SetMethodTable(Delete, Class, Void, Return); + } + + public override ulong InterfaceId => 11160837778045172988UL; + async Task Delete(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Delete(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Class(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Class(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Void(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Void(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Return(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Return(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestKeywordMethods + { + public class Params_delete : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_delete : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_class : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_class : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_void : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_void : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_return : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_return : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestAuthenticatedBootstrapProxy<>)), Skeleton(typeof(TestAuthenticatedBootstrapSkeleton<>))] + public interface ITestAuthenticatedBootstrap : IDisposable + { + Task GetCallerId(CancellationToken cancellationToken_ = default); + } + + public class TestAuthenticatedBootstrapProxy : Proxy, ITestAuthenticatedBootstrap where TVatId : class + { + public Task GetCallerId(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Params_getCallerId.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap.Params_getCallerId() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(16893789964317726925UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create.Result_getCallerId>(d_); + return (r_.Caller); + } + + ); + } + } + + public class TestAuthenticatedBootstrapSkeleton : Skeleton> where TVatId : class + { + public TestAuthenticatedBootstrapSkeleton() + { + SetMethodTable(GetCallerId); + } + + public override ulong InterfaceId => 16893789964317726925UL; + Task GetCallerId(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetCallerId(cancellationToken_), caller => + { + var s_ = SerializerState.CreateForRpc.Result_getCallerId.WRITER>(); + var r_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap.Result_getCallerId{Caller = caller}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestAuthenticatedBootstrap + where TVatId : class + { + public class Params_getCallerId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getCallerId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Caller = CapnpSerializable.Create(reader.Caller); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Caller.SetObject(Caller); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TVatId Caller + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Caller => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public DynamicSerializerState Caller + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + } + + public class TestSturdyRef : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + HostId = CapnpSerializable.Create(reader.HostId); + ObjectId = CapnpSerializable.Create(reader.ObjectId); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + HostId?.serialize(writer.HostId); + writer.ObjectId.SetObject(ObjectId); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestSturdyRefHostId HostId + { + get; + set; + } + + public AnyPointer ObjectId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestSturdyRefHostId.READER HostId => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestSturdyRefHostId.READER.create); + public DeserializerState ObjectId => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public Capnproto_test.Capnp.Test.TestSturdyRefHostId.WRITER HostId + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState ObjectId + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class TestSturdyRefHostId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Host = reader.Host; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Host = Host; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Host + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Host => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Host + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class TestSturdyRefObjectId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheTag = reader.TheTag; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TheTag = TheTag; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag => (Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag)ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag + { + get => (Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + } + + public enum Tag : ushort + { + testInterface, + testExtends, + testPipeline, + testTailCallee, + testTailCaller, + testMoreStuff + } + } + + public class TestProvisionId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestRecipientId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestThirdPartyCapId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestJoinResult : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestNameAnnotation : ICapnpSerializable + { + public enum WHICH : ushort + { + BadFieldName = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.BadFieldName: + BadFieldName = reader.BadFieldName; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + AnotherBadFieldName = reader.AnotherBadFieldName; + BadlyNamedUnion = CapnpSerializable.Create(reader.BadlyNamedUnion); + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.BadFieldName: + _content = false; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.BadFieldName: + writer.BadFieldName = BadFieldName.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + + writer.AnotherBadFieldName = AnotherBadFieldName; + BadlyNamedUnion?.serialize(writer.BadlyNamedUnion); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? BadFieldName + { + get => _which == WHICH.BadFieldName ? (bool? )_content : null; + set + { + _which = WHICH.BadFieldName; + _content = value; + } + } + + public sbyte? Bar + { + get => _which == WHICH.Bar ? (sbyte? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion BadlyNamedUnion + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(16U, (ushort)0); + public bool BadFieldName => which == WHICH.BadFieldName ? ctx.ReadDataBool(0UL, false) : default; + public sbyte Bar => which == WHICH.Bar ? ctx.ReadDataSByte(0UL, (sbyte)0) : default; + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName => (Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum)ctx.ReadDataUShort(32UL, (ushort)0); + public @badlyNamedUnion.READER BadlyNamedUnion => new @badlyNamedUnion.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(16U, (ushort)0); + set => this.WriteData(16U, (ushort)value, (ushort)0); + } + + public bool BadFieldName + { + get => which == WHICH.BadFieldName ? this.ReadDataBool(0UL, false) : default; + set => this.WriteData(0UL, value, false); + } + + public sbyte Bar + { + get => which == WHICH.Bar ? this.ReadDataSByte(0UL, (sbyte)0) : default; + set => this.WriteData(0UL, value, (sbyte)0); + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName + { + get => (Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum)this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, (ushort)value, (ushort)0); + } + + public @badlyNamedUnion.WRITER BadlyNamedUnion + { + get => Rewrap<@badlyNamedUnion.WRITER>(); + } + } + + public class @badlyNamedUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + BadlyNamedGroup = 0, + Baz = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.BadlyNamedGroup: + BadlyNamedGroup = CapnpSerializable.Create(reader.BadlyNamedGroup); + break; + case WHICH.Baz: + Baz = CapnpSerializable.Create(reader.Baz); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.BadlyNamedGroup: + _content = null; + break; + case WHICH.Baz: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.BadlyNamedGroup: + BadlyNamedGroup?.serialize(writer.BadlyNamedGroup); + break; + case WHICH.Baz: + Baz?.serialize(writer.Baz); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion.@badlyNamedGroup BadlyNamedGroup + { + get => _which == WHICH.BadlyNamedGroup ? (Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion.@badlyNamedGroup)_content : null; + set + { + _which = WHICH.BadlyNamedGroup; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct Baz + { + get => _which == WHICH.Baz ? (Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct)_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public @badlyNamedGroup.READER BadlyNamedGroup => which == WHICH.BadlyNamedGroup ? new @badlyNamedGroup.READER(ctx) : default; + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER Baz => which == WHICH.Baz ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public @badlyNamedGroup.WRITER BadlyNamedGroup + { + get => which == WHICH.BadlyNamedGroup ? Rewrap<@badlyNamedGroup.WRITER>() : default; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER Baz + { + get => which == WHICH.Baz ? BuildPointer(0) : default; + set => Link(0, value); + } + } + + public class @badlyNamedGroup : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + } + } + } + + public enum BadlyNamedEnum : ushort + { + foo, + bar, + baz + } + + public class NestedStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BadNestedFieldName = reader.BadNestedFieldName; + AnotherBadNestedFieldName = CapnpSerializable.Create(reader.AnotherBadNestedFieldName); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BadNestedFieldName = BadNestedFieldName; + AnotherBadNestedFieldName?.serialize(writer.AnotherBadNestedFieldName); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool BadNestedFieldName + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct AnotherBadNestedFieldName + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BadNestedFieldName => ctx.ReadDataBool(0UL, false); + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER AnotherBadNestedFieldName => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public bool BadNestedFieldName + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER AnotherBadNestedFieldName + { + get => BuildPointer(0); + set => Link(0, value); + } + } + + public enum DeeplyNestedEnum : ushort + { + quux, + corge, + grault + } + } + } + + [Proxy(typeof(TestNameAnnotationInterfaceProxy)), Skeleton(typeof(TestNameAnnotationInterfaceSkeleton))] + public interface ITestNameAnnotationInterface : IDisposable + { + Task BadlyNamedMethod(byte badlyNamedParam, CancellationToken cancellationToken_ = default); + } + + public class TestNameAnnotationInterfaceProxy : Proxy, ITestNameAnnotationInterface + { + public async Task BadlyNamedMethod(byte badlyNamedParam, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Params_badlyNamedMethod() + {BadlyNamedParam = badlyNamedParam}; + arg_.serialize(in_); + var d_ = await Call(15065286897585459595UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestNameAnnotationInterfaceSkeleton : Skeleton + { + public TestNameAnnotationInterfaceSkeleton() + { + SetMethodTable(BadlyNamedMethod); + } + + public override ulong InterfaceId => 15065286897585459595UL; + async Task BadlyNamedMethod(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.BadlyNamedMethod(in_.BadlyNamedParam, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestNameAnnotationInterface + { + public class Params_badlyNamedMethod : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BadlyNamedParam = reader.BadlyNamedParam; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BadlyNamedParam = BadlyNamedParam; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte BadlyNamedParam + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte BadlyNamedParam => ctx.ReadDataByte(0UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public byte BadlyNamedParam + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + } + } + + public class Result_badlyNamedMethod : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } +} \ No newline at end of file diff --git a/Capnp.Net.Runtime/AnyPointer.cs b/Capnp.Net.Runtime/AnyPointer.cs new file mode 100644 index 0000000..02a5efc --- /dev/null +++ b/Capnp.Net.Runtime/AnyPointer.cs @@ -0,0 +1,31 @@ +namespace Capnp +{ + /// + /// Generic implementation, based on a wrapper around . + /// + public class AnyPointer : ICapnpSerializable + { + /// + /// The will be set by the Deserialize method. + /// + public DeserializerState State { get; private set; } + + /// + /// Sets the State property. + /// + /// deserializer state + public void Deserialize(DeserializerState state) + { + State = state; + } + + /// + /// Performs a deep copy from State to given state. + /// + /// serializer state + public void Serialize(SerializerState state) + { + Reserializing.DeepCopy(State, state); + } + } +} diff --git a/Capnp.Net.Runtime/Capnp.Net.Runtime.csproj b/Capnp.Net.Runtime/Capnp.Net.Runtime.csproj new file mode 100644 index 0000000..3520379 --- /dev/null +++ b/Capnp.Net.Runtime/Capnp.Net.Runtime.csproj @@ -0,0 +1,17 @@ + + + + netcoreapp2.1 + Capnp + 7.2 + + + + TRACE + + + + + + + diff --git a/Capnp.Net.Runtime/CapnpSerializable.cs b/Capnp.Net.Runtime/CapnpSerializable.cs new file mode 100644 index 0000000..054d5b5 --- /dev/null +++ b/Capnp.Net.Runtime/CapnpSerializable.cs @@ -0,0 +1,173 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Runtime.CompilerServices; + +namespace Capnp +{ + /// + /// Provides functionality to construct domain objects from . + /// + public static class CapnpSerializable + { + interface IConstructibleFromDeserializerState + { + T Create(DeserializerState state); + } + + class FromStruct: IConstructibleFromDeserializerState + where T : ICapnpSerializable, new() + { + public T Create(DeserializerState state) + { + var result = new T(); + if (state.Kind != ObjectKind.Nil) + { + result.Deserialize(state); + } + return result; + } + } + + class FromList: IConstructibleFromDeserializerState> + where T: class + { + readonly Func _elementSerializer; + + public FromList() + { + _elementSerializer = (Func)GetSerializer(typeof(T)); + + } + public IReadOnlyList Create(DeserializerState state) + { + return state.RequireList().Cast(_elementSerializer); + } + } + + class FromCapability: IConstructibleFromDeserializerState + where T: class + { + public T Create(DeserializerState state) + { + return state.RequireCap(); + } + } + + static readonly ConditionalWeakTable> _typeMap = + new ConditionalWeakTable>(); + + static CapnpSerializable() + { + _typeMap.Add(typeof(string), d => d.RequireList().CastText()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastBool()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastSByte()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastByte()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastShort()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastUShort()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastInt()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastUInt()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastLong()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastULong()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastFloat()); + _typeMap.Add(typeof(IReadOnlyList), d => d.RequireList().CastDouble()); + } + + static Func CreateSerializer(Type type) + { + if (typeof(ICapnpSerializable).IsAssignableFrom(type)) + { + try + { + return ((IConstructibleFromDeserializerState) + Activator.CreateInstance(typeof(FromStruct<>).MakeGenericType(type))).Create; + } + catch (Exception ex) + { + throw new ArgumentException( + $"Cannot create serializer, probably because serializer {type.Name} does not expose a public parameterless constructor", + ex); + } + } + else if (type.IsGenericType && typeof(IReadOnlyList<>) == type.GetGenericTypeDefinition()) + { + try + { + var elementType = type.GetGenericArguments()[0]; + return ((IConstructibleFromDeserializerState) + Activator.CreateInstance(typeof(FromList<>).MakeGenericType(elementType))).Create; + } + catch (TargetInvocationException ex) + { + throw ex.InnerException; + } + catch (Exception ex) + { + throw new ArgumentException( + $"Cannot create list serializer, probably because the element type is not a reference type", + ex); + } + } + else + { + try + { + Rpc.CapabilityReflection.ValidateCapabilityInterface(type); + } + catch (Exception ex) + { + throw new ArgumentException( + $"Don't know how to construct a serializer from {type.Name}. Tried to interpret it as capability interface, but it didn't work.", + ex); + } + + try + { + return ((IConstructibleFromDeserializerState) + Activator.CreateInstance(typeof(FromCapability<>).MakeGenericType(type))).Create; + } + catch (Exception ex) + { + throw new ArgumentException( + $"Cannot create serializer, probably because serializer {type.Name} a not a viable capability interface", + ex); + } + } + } + + static Func GetSerializer(Type type) + { + return _typeMap.GetValue(type, CreateSerializer); + } + + /// + /// Constructs a domain object from a given deserializer state. + /// + /// Type of domain object to construct. Must be one of the following: + /// + /// Type implementing . The type must must have a public parameterless constructor. + /// A capability interface ( for further explanation) + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// whereby T is one of the things listed here. + /// + /// + /// + /// + public static T Create(DeserializerState state) + where T: class + { + return (T)GetSerializer(typeof(T))(state); + } + } +} diff --git a/Capnp.Net.Runtime/DeserializationException.cs b/Capnp.Net.Runtime/DeserializationException.cs new file mode 100644 index 0000000..9db5b60 --- /dev/null +++ b/Capnp.Net.Runtime/DeserializationException.cs @@ -0,0 +1,19 @@ +using System; + +namespace Capnp +{ + /// + /// This exception gets thrown when a Cap'n Proto object could not be deserialized correctly. + /// + public class DeserializationException : Exception + { + public DeserializationException(string message) : base(message) + { + } + + public DeserializationException(string message, Exception innerException): + base(message, innerException) + { + } + } +} diff --git a/Capnp.Net.Runtime/DeserializerState.cs b/Capnp.Net.Runtime/DeserializerState.cs new file mode 100644 index 0000000..f32ab86 --- /dev/null +++ b/Capnp.Net.Runtime/DeserializerState.cs @@ -0,0 +1,686 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// Implements the heart of deserialization. This stateful helper struct exposes all functionality to traverse serialized data. + /// Although it is public, you should not use it directly. Instead, use the reader, writer, and domain class adapters which are produced + /// by the code generator. + /// + public struct DeserializerState: IStructDeserializer + { + /// + /// A wire message is essentially a collection of memory blocks. + /// + public IReadOnlyList> Segments { get; } + /// + /// Index of the segment (into the Segments property) which this state currently refers to. + /// + public uint CurrentSegmentIndex { get; private set; } + /// + /// Word offset within the current segment which this state currently refers to. + /// + public int Offset { get; set; } + /// + /// Context-dependent meaning: Usually the number of bytes traversed until this state was reached, to prevent amplification attacks. + /// However, if this state is of Kind == ObjectKind.Value (an artificial category which will never occur on the wire but is used to + /// internally represent lists of primitives as lists of structs), it contains the primitive's value. + /// + public uint BytesTraversedOrData { get; set; } + /// + /// If this state currently represents a list, the number of list elements. + /// + public int ListElementCount { get; private set; } + /// + /// If this state currently represents a struct, the struct's data section word count. + /// + public ushort StructDataCount { get; set; } + /// + /// If this state currently represents a struct, the struct's pointer section word count. + /// + public ushort StructPtrCount { get; set; } + /// + /// The kind of object this state currently represents. + /// + public ObjectKind Kind { get; set; } + /// + /// The capabilities imported from the capability table. Only valid in RPC context. + /// + public IReadOnlyList Caps { get; set; } + /// + /// Current segment (essentially Segments[CurrentSegmentIndex] + /// + public ReadOnlySpan CurrentSegment => Segments != null ? Segments[(int)CurrentSegmentIndex].Span : default; + + DeserializerState(IReadOnlyList> segments) + { + Segments = segments; + CurrentSegmentIndex = 0; + Offset = 0; + BytesTraversedOrData = 0; + ListElementCount = 0; + StructDataCount = 0; + StructPtrCount = 1; + Kind = ObjectKind.Struct; + Caps = null; + } + + /// + /// Constructs a state representing a message root object. + /// + /// the message + /// + public static DeserializerState CreateRoot(WireFrame frame) + { + var state = new DeserializerState(frame.Segments); + state.DecodePointer(0); + return state; + } + + /// + /// Implicitly converts a serializer state into a deserializer state. + /// The conversion is cheap, since it does not involve copying any payload. + /// + /// The serializer state to be converted + public static implicit operator DeserializerState(SerializerState state) + { + if (state == null) + throw new ArgumentNullException(nameof(state)); + + switch (state.Kind) + { + case ObjectKind.ListOfBits: + case ObjectKind.ListOfBytes: + case ObjectKind.ListOfEmpty: + case ObjectKind.ListOfInts: + case ObjectKind.ListOfLongs: + case ObjectKind.ListOfPointers: + case ObjectKind.ListOfShorts: + case ObjectKind.ListOfStructs: + case ObjectKind.Nil: + case ObjectKind.Struct: + return new DeserializerState(state.Allocator.Segments) + { + CurrentSegmentIndex = state.SegmentIndex, + Offset = state.Offset, + ListElementCount = state.ListElementCount, + StructDataCount = state.StructDataCount, + StructPtrCount = state.StructPtrCount, + Kind = state.Kind, + Caps = state.Caps + }; + + case ObjectKind.Capability: + return new DeserializerState(state.Allocator.Segments) + { + Kind = ObjectKind.Capability, + Caps = state.Caps, + BytesTraversedOrData = state.CapabilityIndex + }; + + default: + throw new ArgumentException("Unexpected type of object, cannot convert that into DeserializerState", nameof(state)); + } + } + + /// + /// Constructs a state representing the given value. This kind of state is artificial and beyond the Cap'n Proto specification. + /// We need it to internally represent list of primitive values as lists of structs. + /// + public static DeserializerState MakeValueState(uint value) + { + return new DeserializerState() + { + BytesTraversedOrData = value, + Kind = ObjectKind.Value + }; + } + + /// + /// Increments the number of bytes traversed and checks the results against the traversal limit. + /// + /// Amount to increase the traversed bytes + public void IncrementBytesTraversed(uint additionalBytesTraversed) + { + BytesTraversedOrData = checked(BytesTraversedOrData + additionalBytesTraversed); + + if (BytesTraversedOrData > SecurityOptions.TraversalLimit) + throw new DeserializationException("Traversal limit was reached"); + } + /// + /// Memory span which represents this struct's data section (given this state actually represents a struct) + /// + public ReadOnlySpan StructDataSection => CurrentSegment.Slice(Offset, StructDataCount); + ReadOnlySpan StructPtrSection => CurrentSegment.Slice(Offset + StructDataCount, StructPtrCount); + + ReadOnlySpan GetRawBits() => CurrentSegment.Slice(Offset, (ListElementCount + 63) / 64); + ReadOnlySpan GetRawBytes() => CurrentSegment.Slice(Offset, (ListElementCount + 7) / 8); + ReadOnlySpan GetRawShorts() => CurrentSegment.Slice(Offset, (ListElementCount + 3) / 4); + ReadOnlySpan GetRawInts() => CurrentSegment.Slice(Offset, (ListElementCount + 1) / 2); + ReadOnlySpan GetRawLongs() => CurrentSegment.Slice(Offset, ListElementCount); + /// + /// If this state represents a list of primitive values, returns the raw list data. + /// + public ReadOnlySpan RawData + { + get + { + switch (Kind) + { + case ObjectKind.ListOfBits: + return GetRawBits(); + + case ObjectKind.ListOfBytes: + return GetRawBytes(); + + case ObjectKind.ListOfShorts: + return GetRawShorts(); + + case ObjectKind.ListOfInts: + return GetRawInts(); + + case ObjectKind.ListOfLongs: + return GetRawLongs(); + + default: + return default; + } + } + } + + void Validate() + { + try + { + switch (Kind) + { + case ObjectKind.Struct: + CurrentSegment.Slice(Offset, StructDataCount + StructPtrCount); + break; + + case ObjectKind.ListOfBits: + GetRawBits(); + break; + + case ObjectKind.ListOfBytes: + GetRawBytes(); + break; + + case ObjectKind.ListOfInts: + GetRawInts(); + break; + + case ObjectKind.ListOfLongs: + case ObjectKind.ListOfPointers: + GetRawLongs(); + break; + + case ObjectKind.ListOfStructs: + CurrentSegment.Slice(Offset, checked(ListElementCount * (StructDataCount + StructPtrCount))); + break; + } + } + catch (Exception problem) + { + throw new DeserializationException("Invalid wire pointer", problem); + } + } + + /// + /// Interprets a pointer within the current segment and mutates this state to represent the pointer's target. + /// + /// word offset relative to this.Offset within current segment + /// offset negative or out of range + /// invalid pointer data or traversal limit exceeded + internal void DecodePointer(int offset) + { + if (offset < 0) + throw new IndexOutOfRangeException(nameof(offset)); + + WirePointer pointer = CurrentSegment[Offset + offset]; + + int derefCount = 0; + + do + { + if (pointer.IsNull) + { + this = default; + return; + } + + switch (pointer.Kind) + { + case PointerKind.Struct: + Offset = checked(pointer.Offset + Offset + offset + 1); + IncrementBytesTraversed(checked(8u * pointer.StructSize)); + StructDataCount = pointer.StructDataCount; + StructPtrCount = pointer.StructPtrCount; + Kind = ObjectKind.Struct; + Validate(); + return; + + case PointerKind.List: + Offset = checked(pointer.Offset + Offset + offset + 1); + ListElementCount = pointer.ListElementCount; + StructDataCount = 0; + StructPtrCount = 0; + + switch (pointer.ListKind) + { + case ListKind.ListOfEmpty: // e.g. List(void) + // the “traversal limit” should count a list of zero-sized elements as if each element were one word instead. + IncrementBytesTraversed(checked(8u * (uint)ListElementCount)); + Kind = ObjectKind.ListOfEmpty; + break; + + case ListKind.ListOfBits: + IncrementBytesTraversed(checked((uint)ListElementCount + 7) / 8); + Kind = ObjectKind.ListOfBits; + break; + + case ListKind.ListOfBytes: + IncrementBytesTraversed((uint)ListElementCount); + Kind = ObjectKind.ListOfBytes; + break; + + case ListKind.ListOfShorts: + IncrementBytesTraversed(checked(2u * (uint)ListElementCount)); + Kind = ObjectKind.ListOfShorts; + break; + + case ListKind.ListOfInts: + IncrementBytesTraversed(checked(4u * (uint)ListElementCount)); + Kind = ObjectKind.ListOfInts; + break; + + case ListKind.ListOfLongs: + IncrementBytesTraversed(checked(8u * (uint)ListElementCount)); + Kind = ObjectKind.ListOfLongs; + break; + + case ListKind.ListOfPointers: + IncrementBytesTraversed(checked(8u * (uint)ListElementCount)); + Kind = ObjectKind.ListOfPointers; + break; + + case ListKind.ListOfStructs: + { + WirePointer tag = CurrentSegment[Offset]; + if (tag.Kind != PointerKind.Struct) + throw new DeserializationException("Unexpected: List of composites with non-struct type tag"); + IncrementBytesTraversed(checked(8u * (uint)pointer.ListElementCount + 8u)); + ListElementCount = tag.ListOfStructsElementCount; + StructDataCount = tag.StructDataCount; + StructPtrCount = tag.StructPtrCount; + Kind = ObjectKind.ListOfStructs; + } + break; + + default: + throw new InvalidProgramException(); + + } + Validate(); + return; + + case PointerKind.Far: + + if (pointer.IsDoubleFar) + { + CurrentSegmentIndex = pointer.TargetSegmentIndex; + Offset = 0; + + WirePointer pointer1 = CurrentSegment[pointer.LandingPadOffset]; + if (pointer1.Kind != PointerKind.Far || pointer1.IsDoubleFar) + throw new DeserializationException("Error decoding double-far pointer: convention broken"); + + WirePointer pointer2 = CurrentSegment[pointer.LandingPadOffset + 1]; + if (pointer2.Kind == PointerKind.Far) + throw new DeserializationException("Error decoding double-far pointer: not followed by intra-segment pointer"); + + CurrentSegmentIndex = pointer1.TargetSegmentIndex; + Offset = 0; + pointer = pointer2; + offset = -1; + } + else + { + CurrentSegmentIndex = pointer.TargetSegmentIndex; + Offset = 0; + offset = pointer.LandingPadOffset; + pointer = CurrentSegment[pointer.LandingPadOffset]; + } + continue; + + case PointerKind.Other: + this = default; + Kind = ObjectKind.Capability; + BytesTraversedOrData = pointer.CapabilityIndex; + return; + + default: + throw new InvalidProgramException(); + } + + } while (++derefCount < SecurityOptions.RecursionLimit); + + throw new DeserializationException("Recursion limit reached while decoding a pointer"); + } + + /// + /// Interprets a pointer within the current segment as capability pointer and returns the according low-level capability object from + /// the capability table. Does not mutate this state. + /// + /// Offset relative to this.Offset within current segment + /// the low-level capability object + /// offset negative or out of range + /// capability table not set + /// not a capability pointer or invalid capability index + internal Rpc.ConsumedCapability DecodeCapPointer(int offset) + { + if (offset < 0) + { + throw new IndexOutOfRangeException(nameof(offset)); + } + + if (Caps == null) + { + throw new InvalidOperationException("Capbility table not set"); + } + + WirePointer pointer = CurrentSegment[Offset + offset]; + + if (pointer.IsNull) + { + // Despite this behavior is not officially specified, + // the official C++ implementation seems to send null pointers for null caps. + return null; + } + + if (pointer.Kind != PointerKind.Other) + { + throw new Rpc.RpcException("Expected a capability pointer, but got something different"); + } + + if (pointer.CapabilityIndex >= Caps.Count) + { + throw new Rpc.RpcException("Capability index out of range"); + } + + return Caps[(int)pointer.CapabilityIndex]; + } + + /// + /// Reads a slice of up to 64 bits from this struct's data section, starting from the specified bit offset. + /// The slice must be aligned within a 64 bit word boundary. + /// + /// Start bit offset relative to the data section, little endian + /// numbers of bits to read + /// the data + /// non-aligned access + /// bitOffset exceeds the data section + /// this state does not represent a struct + public ulong StructReadData(ulong bitOffset, int bitCount) + { + switch (Kind) + { + case ObjectKind.Nil: + return 0; + + case ObjectKind.Struct: + + int index = checked((int)(bitOffset / 64)); + int relBitOffset = (int)(bitOffset % 64); + + var data = StructDataSection; + + if (index >= data.Length) + return 0; // Assume backwards-compatible change + + if (relBitOffset + bitCount > 64) + throw new ArgumentOutOfRangeException(nameof(bitCount)); + + ulong word = data[index]; + + if (bitCount == 64) + { + return word; + } + else + { + ulong mask = (1ul << bitCount) - 1; + return (word >> relBitOffset) & mask; + } + + case ObjectKind.Value: + + if (bitOffset >= 32) return 0; + if (bitCount >= 32) return BytesTraversedOrData >> (int)bitOffset; + return (BytesTraversedOrData >> (int)bitOffset) & ((1u << bitCount) - 1); + + default: + throw new DeserializationException("This is not a struct"); + } + } + + /// + /// Decodes a pointer from this struct's pointer section and returns the state representing the pointer target. + /// It is valid to specify an index beyond the pointer section, in which case a default state (representing the "null object") + /// will be returned. This is to preserve upward compatibility with schema evolution. + /// + /// Index within the pointer section + /// the target state + /// this state does not represent a struct, + /// invalid pointer, or traversal limit exceeded + public DeserializerState StructReadPointer(int index) + { + if (Kind != ObjectKind.Struct && Kind != ObjectKind.Nil) + throw new DeserializationException("This is not a struct"); + + if (index >= StructPtrCount) + return default; + + DeserializerState state = this; + state.DecodePointer(index + StructDataCount); + + return state; + } + + internal Rpc.ConsumedCapability StructReadRawCap(int index) + { + if (Kind != ObjectKind.Struct && Kind != ObjectKind.Nil) + throw new InvalidOperationException("Allowed on structs only"); + + if (index >= StructPtrCount) + return null; + + return DecodeCapPointer(index + StructDataCount); + } + + /// + /// Given this state represents a list (of anything), returns a ListDeserializer to further decode the list content. + /// + /// state does not represent a list + public ListDeserializer RequireList() + { + switch (Kind) + { + case ObjectKind.ListOfBits: + return new ListOfBitsDeserializer(ref this, false); + + case ObjectKind.ListOfBytes: + return new ListOfPrimitivesDeserializer(ref this, ListKind.ListOfBytes); + + case ObjectKind.ListOfEmpty: + return new ListOfEmptyDeserializer(ref this); + + case ObjectKind.ListOfInts: + return new ListOfPrimitivesDeserializer(ref this, ListKind.ListOfInts); + + case ObjectKind.ListOfLongs: + return new ListOfPrimitivesDeserializer(ref this, ListKind.ListOfLongs); + + case ObjectKind.ListOfPointers: + return new ListOfPointersDeserializer(ref this); + + case ObjectKind.ListOfShorts: + return new ListOfPrimitivesDeserializer(ref this, ListKind.ListOfShorts); + + case ObjectKind.ListOfStructs: + return new ListOfStructsDeserializer(ref this); + + case ObjectKind.Nil: + return new EmptyListDeserializer(); + + default: + throw new DeserializationException("Cannot deserialize this object as list"); + } + } + + /// + /// Given this state represents a list of pointers, returns a ListOfCapsDeserializer for decoding it as list of capabilities. + /// + /// Capability interface + /// state does not represent a list of pointers + public ListOfCapsDeserializer RequireCapList() where T: class + { + switch (Kind) + { + case ObjectKind.ListOfPointers: + return new ListOfCapsDeserializer(ref this); + + default: + throw new DeserializationException("Cannot deserialize this object as capability list"); + } + } + + /// + /// Convenience method. Given this state represents a struct, decodes text field from its pointer table. + /// + /// index within this struct's pointer table + /// default text to return of pointer is null + /// the decoded text, or defaultText (which might be null) + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-list-of-bytes pointer, traversal limit exceeded + public string ReadText(int index, string defaultText = null) + { + return StructReadPointer(index).RequireList().CastText() ?? defaultText; + } + + /// + /// Convenience method. Given this state represents a struct, decodes a list deserializer field from its pointer table. + /// + /// index within this struct's pointer table + /// the list deserializer instance + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-list pointer, traversal limit exceeded + public ListDeserializer ReadList(int index) + { + return StructReadPointer(index).RequireList(); + } + + /// + /// Convenience method. Given this state represents a struct, decodes a capability list field from its pointer table. + /// + /// Capability interface + /// index within this struct's pointer table + /// the capability list deserializer instance + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-list-of-pointers pointer, traversal limit exceeded + public ListOfCapsDeserializer ReadCapList(int index) where T : class + { + return StructReadPointer(index).RequireCapList(); + } + + /// + /// Convenience method. Given this state represents a struct, decodes a list of structs field from its pointer table. + /// + /// Struct target representation type + /// index within this struct's pointer table + /// constructs a target representation type instance from the underlying deserializer state + /// the decoded list of structs + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-list-of-{structs,pointers} pointer, traversal limit exceeded + public IReadOnlyList ReadListOfStructs(int index, Func cons) + { + return ReadList(index).Cast(cons); + } + + /// + /// Convenience method. Given this state represents a struct, decodes a struct field from its pointer table. + /// + /// Struct target representation type + /// index within this struct's pointer table + /// constructs a target representation type instance from the underlying deserializer state + /// the decoded struct + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-struct pointer, traversal limit exceeded + public T ReadStruct(int index, Func cons) + { + return cons(StructReadPointer(index)); + } + + /// + /// Given this state represents a capability, returns its index into the capability table. + /// + public uint CapabilityIndex => Kind == ObjectKind.Capability ? BytesTraversedOrData : ~0u; + + /// + /// Given this state represents a struct, decodes a capability field from its pointer table. + /// + /// Capability interface + /// index within this struct's pointer table + /// capability instance or null if pointer was null + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-capability pointer, traversal limit exceeded + public T ReadCap(int index, + [System.Runtime.CompilerServices.CallerMemberName] string memberName = "", + [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "", + [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0) where T: class + { + var cap = StructReadRawCap(index); + return Rpc.CapabilityReflection.CreateProxy(cap, memberName, sourceFilePath, sourceLineNumber) as T; + } + + /// + /// Given this state represents a struct, decodes a capability field from its pointer table and + /// returns it as bare (generic) proxy. + /// + /// index within this struct's pointer table + /// capability instance or null if pointer was null + /// negative index + /// state does not represent a struct, invalid pointer, + /// non-capability pointer, traversal limit exceeded + public Rpc.BareProxy ReadCap(int index) + { + var cap = StructReadRawCap(index); + return new Rpc.BareProxy(cap); + } + + /// + /// Given this state represents a capability, wraps it into a proxy instance for the desired interface. + /// + /// Capability interface + /// capability instance or null if pointer was null + /// negative index + /// state does not represent a capability + public T RequireCap() where T: class + { + if (Kind == ObjectKind.Nil) + return null; + + if (Kind != ObjectKind.Capability) + throw new DeserializationException("Expected a capability"); + + return Rpc.CapabilityReflection.CreateProxy(Caps[(int)CapabilityIndex]) as T; + } + } +} diff --git a/Capnp.Net.Runtime/DynamicSerializerState.cs b/Capnp.Net.Runtime/DynamicSerializerState.cs new file mode 100644 index 0000000..2ac3bc8 --- /dev/null +++ b/Capnp.Net.Runtime/DynamicSerializerState.cs @@ -0,0 +1,227 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// This SerializerState specialization provides functionality to build arbitrary Cap'n Proto objects without requiring the schema code generator. + /// + public class DynamicSerializerState : SerializerState + { + /// + /// Constructs an unbound instance. + /// + public DynamicSerializerState() + { + } + + /// + /// Constructs an instance and binds it to the given . + /// + /// message builder + public DynamicSerializerState(MessageBuilder messageBuilder): + base(messageBuilder) + { + } + + /// + /// Constructs an instance, binds it to a dedicated message builder, and initializes the capability table for usage in RPC context. + /// + public static DynamicSerializerState CreateForRpc() + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + return new DynamicSerializerState(mb); + } + + /// + /// Converts any to a DynamicSerializerState instance, which involves deep copying the object graph. + /// + /// The deserializer state to convert + public static explicit operator DynamicSerializerState(DeserializerState state) + { + var mb = MessageBuilder.Create(); + if (state.Caps != null) + mb.InitCapTable(); + var sstate = mb.CreateObject(); + Reserializing.DeepCopy(state, sstate); + + return sstate; + } + + /// + /// Links a sub-item (struct field or list element) of this state to another state. Usually, this operation is not necessary, since objects are constructed top-down. + /// However, there might be some advanced scenarios where you want to reference the same object twice (also interesting for designing amplification attacks). + /// The Cap'n Proto serialization intrinsically supports this, since messages are object graphs, not trees. + /// + /// If this state describes a struct: Index into this struct's pointer table. + /// If this state describes a list of pointers: List element index. + /// state to be linked + /// Whether to deep copy the target state if it belongs to a different message builder than this state. + /// is null + /// out of range + /// + /// This state does neither describe a struct, nor a list of pointers + /// Another state is already linked to the specified position (sorry, no overwrite allowed) + /// This state and belong to different message builder, and is false + /// + public new void Link(int slot, SerializerState target, bool allowCopy = true) => base.Link(slot, target, allowCopy); + + /// + /// Links a sub-item (struct field or list element) of this state to a capability. + /// + /// If this state describes a struct: Index into this struct's pointer table. + /// If this state describes a list of pointers: List element index. + /// capability index inside the capability table + /// + /// This state does neither describe a struct, nor a list of pointers + /// Another state is already linked to the specified position (sorry, no overwrite allowed) + /// + public new void LinkToCapability(int slot, uint capabilityIndex) => base.LinkToCapability(slot, capabilityIndex); + + /// + /// Determines the underlying object to be a struct. + /// + /// Desired size of the struct's data section, in words + /// Desired size of the struct's pointer section, in words + /// The object type was already set to something different + public new void SetStruct(ushort dataCount, ushort ptrCount) => base.SetStruct(dataCount, ptrCount); + + /// + /// Determines the underlying object to be a list of (primitive) values. + /// + /// Element size in bits, must be 0 (void), 1 (bool), 8, 16, 32, or 64 + /// Desired element count + /// The object type was already set to something different + /// outside allowed range, + /// negative or exceeding 2^29-1 + public new void SetListOfValues(byte bitsPerElement, int totalCount) => base.SetListOfValues(bitsPerElement, totalCount); + + /// + /// Determines the underlying object to be a list of pointers. + /// + /// Desired element count + /// The object type was already set to something different + /// negative or exceeding 2^29-1 + public new void SetListOfPointers(int totalCount) => base.SetListOfPointers(totalCount); + + /// + /// Determines the underlying object to be a list of structs (fixed-width compound list). + /// + /// Desired element count + /// Desired size of each struct's data section, in words + /// Desired size of each struct's pointer section, in words + /// The object type was already set to something different + /// negative, or total word count would exceed 2^29-1 + public new void SetListOfStructs(int totalCount, ushort dataCount, ushort ptrCount) => base.SetListOfStructs(totalCount, dataCount, ptrCount); + + /// + /// Constructs the underlying object from the given representation. + /// + /// Object representation. Must be one of the following: + /// + /// An instance implementing + /// null + /// A + /// A + /// A + /// A + /// A + /// A + /// A + /// A + /// A + /// A + /// A + /// Another + /// Another + /// Low-level capability object () + /// Proxy object () + /// Skeleton object () + /// Capability interface implementation + /// A whereby each list item is one of the things listed here. + /// + /// + public void SetObject(object obj) + { + switch (obj) + { + case ICapnpSerializable serializable: + serializable.Serialize(this); + break; + + case string s: + WriteText(s); + break; + + case IReadOnlyList bytes: + Rewrap>().Init(bytes); + break; + + case IReadOnlyList sbytes: + Rewrap>().Init(sbytes); + break; + + case IReadOnlyList ushorts: + Rewrap>().Init(ushorts); + break; + + case IReadOnlyList shorts: + Rewrap>().Init(shorts); + break; + + case IReadOnlyList uints: + Rewrap>().Init(uints); + break; + + case IReadOnlyList ints: + Rewrap>().Init(ints); + break; + + case IReadOnlyList ulongs: + Rewrap>().Init(ulongs); + break; + + case IReadOnlyList longs: + Rewrap>().Init(longs); + break; + + case IReadOnlyList floats: + Rewrap>().Init(floats); + break; + + case IReadOnlyList doubles: + Rewrap>().Init(doubles); + break; + + case IReadOnlyList bools: + Rewrap().Init(bools); + break; + + case IReadOnlyList strings: + Rewrap().Init(strings); + break; + + case IReadOnlyList objects: + Rewrap>().Init(objects, (s, o) => s.SetObject(o)); + break; + + case DeserializerState ds: + Reserializing.DeepCopy(ds, this); + break; + + case SerializerState s: + Reserializing.DeepCopy(s, this); + break; + + case null: + break; + + default: + SetCapability(ProvideCapability(obj)); + break; + } + } + } +} diff --git a/Capnp.Net.Runtime/EmptyList.cs b/Capnp.Net.Runtime/EmptyList.cs new file mode 100644 index 0000000..8db5d94 --- /dev/null +++ b/Capnp.Net.Runtime/EmptyList.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp +{ + /// + /// Implements an empty . + /// + /// + public class EmptyList : IReadOnlyList + { + /// + /// Always throws an . + /// + /// Ignored + public T this[int index] => throw new ArgumentOutOfRangeException(nameof(index)); + + /// + /// Always 0. + /// + public int Count => 0; + + /// + /// Returns an empty enumerator. + /// + public IEnumerator GetEnumerator() + { + return Enumerable.Empty().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/EmptyListDeserializer.cs b/Capnp.Net.Runtime/EmptyListDeserializer.cs new file mode 100644 index 0000000..e843204 --- /dev/null +++ b/Capnp.Net.Runtime/EmptyListDeserializer.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for empty lists. + /// + public class EmptyListDeserializer : ListDeserializer + { + /// + /// Always ListKind.ListOfEmpty (despite the fact the empty list != List(Void) + /// + public override ListKind Kind => ListKind.ListOfEmpty; + + /// + /// Returns am empty . + /// + /// Element ype + /// Ignored + public override IReadOnlyList Cast(Func cons) => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastBool() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastByte() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastDouble() => new EmptyList(); + + /// + /// Returns an empty + /// + public override IReadOnlyList CastFloat() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastInt() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastList() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastLong() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastSByte() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastShort() => new EmptyList(); + + /// + /// Returns an empty string. + /// + public override string CastText() => string.Empty; + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastUInt() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastULong() => new EmptyList(); + + /// + /// Returns an empty . + /// + public override IReadOnlyList CastUShort() => new EmptyList(); + } +} diff --git a/Capnp.Net.Runtime/FramePump.cs b/Capnp.Net.Runtime/FramePump.cs new file mode 100644 index 0000000..837648c --- /dev/null +++ b/Capnp.Net.Runtime/FramePump.cs @@ -0,0 +1,206 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Diagnostics; +using System.IO; +using System.Net.Sockets; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp +{ + /// + /// The FramePump handles sending and receiving Cap'n Proto messages over a stream. It exposes a Send method for writing frames to the stream, and an + /// event handler for processing received frames. It does not fork any new thread by itself, but instead exposes a synchronous blocking Run method that + /// implements the receive loop. Invoke this method in the thread context of your choice. + /// + public class FramePump: IDisposable + { + ILogger Logger { get; } = Logging.CreateLogger(); + + int _disposing; + readonly Stream _stream; + readonly BinaryWriter _writer; + readonly object _writeLock = new object(); + + /// + /// Constructs a new instance for given stream. + /// + /// The stream for message I/O. + /// If you intend to receive messages, the stream must support reading (CanRead). + /// If you intend to send messages, the stream must support writing (CanWrite). + /// + /// is null. + public FramePump(Stream stream) + { + _stream = stream ?? throw new ArgumentNullException(nameof(stream)); + + if (stream.CanWrite) + _writer = new BinaryWriter(_stream); + } + + /// + /// Disposes this instance and the underlying stream. This will also cause the Run method to return. + /// + public void Dispose() + { + if (0 == Interlocked.Exchange(ref _disposing, 1)) + { + _writer?.Dispose(); + _stream.Dispose(); + } + } + + /// + /// Event handler for frame reception. + /// + public event Action FrameReceived; + + /// + /// Sends a message over the stream. + /// + /// Message to be sent + /// The underlying stream does not support writing. + /// The message does not provide at least one segment, or one of its segments is empty. + /// An I/O error occurs. + /// This instance or stream is diposed. + public void Send(WireFrame frame) + { + if (_writer == null) + throw new InvalidOperationException("Stream is not writable"); + + if (frame.Segments == null) + throw new ArgumentException("Do not pass default(WireFrame)"); + + if (frame.Segments.Count == 0) + throw new ArgumentException("Expected at least one segment"); + + foreach (var segment in frame.Segments) + { + if (segment.Length == 0) + throw new ArgumentException("Segment must not have zero length"); + } + + lock (_writeLock) + { + _writer.Write(frame.Segments.Count - 1); + + foreach (var segment in frame.Segments) + { + _writer.Write(segment.Length); + } + + if ((frame.Segments.Count & 1) == 0) + { + // Padding + _writer.Write(0); + } + + foreach (var segment in frame.Segments) + { + var bytes = MemoryMarshal.Cast(segment.Span); + + _writer.Write(bytes); + } + } + } + + long _waitingForData; + + /// + /// Whether the pump is currently waiting for data to receive. + /// + public bool IsWaitingForData + { + get => Interlocked.Read(ref _waitingForData) != 0; + private set => Interlocked.Exchange(ref _waitingForData, value ? 1 : 0); + } + + /// + /// Synchronously runs the frame reception loop. Will only return after calling Dispose() or upon error condition. + /// The method does not propagate EndOfStreamException or ObjectDisposedException to the caller, since these conditions are considered + /// to be part of normal operation. It does pass exceptions which arise due to I/O errors or invalid data. + /// + /// The underlying stream does not support reading or is already closed. + /// Received invalid data. + /// Received a message with too many or too big segments, probably dues to invalid data. + /// An I/O error occurs. + public void Run() + { + try + { + using (var reader = new BinaryReader(_stream, Encoding.Default)) + { + while (true) + { + IsWaitingForData = true; + + uint scountm = reader.ReadUInt32(); + int scount = checked((int)(scountm + 1)); + var buffers = new Memory[scount]; + + for (uint i = 0; i < scount; i++) + { + int size = checked((int)reader.ReadUInt32()); + + // This implementation will never send empty segments. + // Other implementations should not. An empty segment may also + // indicate and end-of-stream (stream closed) condition. + if (size == 0) + { + Logger.LogInformation("Received zero-sized segment, stopping interaction"); + return; + } + + buffers[i] = new Memory(new ulong[size]); + } + + if ((scount & 1) == 0) + { + // Padding + reader.ReadUInt32(); + } + + for (uint i = 0; i < scount; i++) + { + var buffer = MemoryMarshal.Cast(buffers[i].Span); + + int got = reader.Read(buffer); + + if (got != buffer.Length) + { + Logger.LogWarning("Received incomplete frame"); + + throw new EndOfStreamException("Expected more bytes according to framing header"); + } + } + + IsWaitingForData = false; + + FrameReceived?.Invoke(new WireFrame(new ArraySegment>(buffers, 0, scount))); + } + } + } + catch (EndOfStreamException) + { + } + catch (ObjectDisposedException) + { + } + catch (Exception exception) + { + // When disposing, all kinds of errors might happen here, + // not worth logging. + if (_disposing == 0) + { + Logger.LogWarning(exception.Message); + } + } + finally + { + IsWaitingForData = false; + } + } + } +} diff --git a/Capnp.Net.Runtime/Framing.cs b/Capnp.Net.Runtime/Framing.cs new file mode 100644 index 0000000..657ffc1 --- /dev/null +++ b/Capnp.Net.Runtime/Framing.cs @@ -0,0 +1,60 @@ +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; + +namespace Capnp +{ + /// + /// Supports the deserialization of Cap'n Proto messages from a stream (see https://capnproto.org/encoding.html#serialization-over-a-stream). + /// Packing and compression cannot be handled yet. + /// + public static class Framing + { + /// + /// Deserializes a message from given stream. + /// + /// The stream to read from + /// The deserialized message + /// is null. + /// The stream does not support reading, is null, or is already closed. + /// The end of the stream is reached. + /// The stream is closed. + /// An I/O error occurs. + /// Encountered invalid framing data. + /// Too many or too large segments, probably due to invalid framing data. + public static WireFrame ReadSegments(Stream stream) + { + using (var reader = new BinaryReader(stream, Encoding.Default, true)) + { + uint scountm = reader.ReadUInt32(); + uint scount = checked(scountm + 1); + var buffers = new Memory[scount]; + + for (uint i = 0; i < scount; i++) + { + uint size = reader.ReadUInt32(); + buffers[i] = new Memory(new ulong[size]); + } + + if ((scount & 1) == 0) + { + // Padding + reader.ReadUInt32(); + } + + for (uint i = 0; i < scount; i++) + { + var buffer = MemoryMarshal.Cast(buffers[i].Span); + + if (reader.Read(buffer) != buffer.Length) + { + throw new EndOfStreamException("Expected more bytes according to framing header"); + } + } + + return new WireFrame(buffers); + } + } + } +} diff --git a/Capnp.Net.Runtime/ICapnpSerializable.cs b/Capnp.Net.Runtime/ICapnpSerializable.cs new file mode 100644 index 0000000..36eaeea --- /dev/null +++ b/Capnp.Net.Runtime/ICapnpSerializable.cs @@ -0,0 +1,21 @@ +namespace Capnp +{ + /// + /// This interface is intended to be implemented by schema-generated domain classes which support deserialization from + /// a and serialization to a . + /// + public interface ICapnpSerializable + { + /// + /// Serializes the implementation's current state to a serializer state. + /// + /// Target serializer state + void Serialize(SerializerState state); + + /// + /// Deserializes the implementation's state from a deserializer state. + /// + /// Source deserializer state + void Deserialize(DeserializerState state); + } +} diff --git a/Capnp.Net.Runtime/ISegmentAllocator.cs b/Capnp.Net.Runtime/ISegmentAllocator.cs new file mode 100644 index 0000000..abcfb8d --- /dev/null +++ b/Capnp.Net.Runtime/ISegmentAllocator.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// Implements a segment allocation policy for Cap'n Proto building messages. + /// + public interface ISegmentAllocator + { + /// + /// Currently allocated segments. + /// + IReadOnlyList> Segments { get; } + + /// + /// Attempts to allocate a memory block. The first allocation attempt is made inside the segment specified by . + /// If that segment does not provide enough space or does not exist, further actions depend on the flag. + /// If that flag is true, allocation will fail (return false). Otherwise, the allocation shall scan existing segments for the requested amount of space, + /// and create a new segment if none provides enough space. + /// + /// Number of words to allocate + /// Index of preferred segment wherein the block should be allocated + /// Position of allocated memory block (undefined in case of failure) + /// Whether the segment specified by is mandatory + /// Whether allocation was successful + bool Allocate(uint nwords, uint preferredSegment, out SegmentSlice slice, bool forcePreferredSegment); + } +} diff --git a/Capnp.Net.Runtime/IStructDeserializer.cs b/Capnp.Net.Runtime/IStructDeserializer.cs new file mode 100644 index 0000000..24cd8d3 --- /dev/null +++ b/Capnp.Net.Runtime/IStructDeserializer.cs @@ -0,0 +1,22 @@ +using System; + +namespace Capnp +{ + /// + /// An implementations of this interface represents a struct which is being deserialized from a Cap'n Proto object. + /// + public interface IStructDeserializer + { + /// + /// Reads a slice of up to 64 bits from this struct's data section, starting from the specified bit offset. + /// The slice must be aligned within a 64 bit word boundary. + /// + /// Start bit offset relative to the data section, little endian + /// numbers of bits to read + /// the data + /// non-aligned access + /// bitOffset exceeds the data section + /// this state does not represent a struct + ulong StructReadData(ulong bitOffset, int bitCount); + } +} diff --git a/Capnp.Net.Runtime/IStructSerializer.cs b/Capnp.Net.Runtime/IStructSerializer.cs new file mode 100644 index 0000000..8678c33 --- /dev/null +++ b/Capnp.Net.Runtime/IStructSerializer.cs @@ -0,0 +1,27 @@ +using System; + +namespace Capnp +{ + /// + /// An implementations of this interface represents a struct which is being serialized as Cap'n Proto object. + /// + public interface IStructSerializer: IStructDeserializer + { + /// + /// Writes data (up to 64 bits) into the underlying struct's data section. + /// The write operation must be aligned to fit within a single word. + /// + /// Start bit relative to the struct's data section, little endian + /// Number of bits to write + /// Data bits to write + /// The object was not determined to be a struct + /// The data slice specified by and + /// is not completely within the struct's data section, misaligned, exceeds one word, or is negative + void StructWriteData(ulong bitOffset, int bitCount, ulong data); + + /// + /// The struct's data section as memory span. + /// + Span StructDataSection { get; } + } +} diff --git a/Capnp.Net.Runtime/ListDeserializer.cs b/Capnp.Net.Runtime/ListDeserializer.cs new file mode 100644 index 0000000..78f4105 --- /dev/null +++ b/Capnp.Net.Runtime/ListDeserializer.cs @@ -0,0 +1,403 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// Base class for interpreting a as List(T). + /// + public abstract class ListDeserializer + { + static class GenericCasts + { + public static Func CastFunc; + } + + static ListDeserializer() + { + GenericCasts>.CastFunc = _ => _.CastBool(); + GenericCasts>.CastFunc = _ => _.CastSByte(); + GenericCasts>.CastFunc = _ => _.CastByte(); + GenericCasts>.CastFunc = _ => _.CastShort(); + GenericCasts>.CastFunc = _ => _.CastUShort(); + GenericCasts>.CastFunc = _ => _.CastInt(); + GenericCasts>.CastFunc = _ => _.CastUInt(); + GenericCasts>.CastFunc = _ => _.CastLong(); + GenericCasts>.CastFunc = _ => _.CastULong(); + GenericCasts>.CastFunc = _ => _.CastFloat(); + GenericCasts>.CastFunc = _ => _.CastDouble(); + GenericCasts.CastFunc = _ => _.CastText(); + } + + /// + /// Underlying deserializer state + /// + protected readonly DeserializerState State; + + internal ListDeserializer(ref DeserializerState state) + { + State = state; + } + + internal ListDeserializer() + { + } + + T Cast() + { + var func = GenericCasts.CastFunc; + + if (func == null) + throw new NotSupportedException("Requested cast is not supported"); + + return func(this); + } + + /// + /// This list's element count + /// + public int Count => State.ListElementCount; + + /// + /// The list's element category + /// + public abstract ListKind Kind { get; } + + /// + /// Represents this list by applying a selector function to each element's deserializer state. + /// This operator is only supported by certain specializations. + /// + /// Target element type + /// Selector function + /// The desired representation + public abstract IReadOnlyList Cast(Func cons); + + /// + /// Represents this list as a list of lists. + /// + /// The list of lists representation, each element being a on its own. + /// If this kind of list cannot be represented as list of lists (because it is a list of non-pointers) + public virtual IReadOnlyList CastList() + { + throw new NotSupportedException("This kind of list does not contain nested lists"); + } + + /// + /// Represents this list as a list of capabilities. + /// + /// Capability interface + /// Capability list representation + /// If this kind of list cannot be represented as list of capabilities (because it is a list of non-pointers) + /// If does not qualify as capability interface. + public virtual IReadOnlyList> CastCapList() where T: class + { + throw new NotSupportedException("This kind of list does not contain nested lists"); + } + + object CastND(int n, Func func) + { + if (n <= 0) throw new ArgumentOutOfRangeException(nameof(n)); + + for (int i = 1; i < n; i++) + { + var copy = func; // This copy assignment is intentional. Try to optimize it away and be amazed! + func = ld => ld.CastList().LazyListSelect(copy); + } + + return func(this); + } + + /// + /// Represents this list as n-dimensional list of T, with T being a primitive type. + /// + /// Element type, must be primitive + /// Number of dimensions + /// The desired representation as >]]> + /// is less than or equal to 0 + /// If this list cannot be represented in the desired manner. + public object CastND(int n) => CastND(n, ld => ld.Cast>()); + + /// + /// Represents this list as n-dimensional list of T, with T being any type. + /// + /// Element type + /// Number of dimensions + /// Selector function which constructs an instance of from a + /// The desired representation as >]]> + /// is null. + /// is less than or equals 0. + /// If this list cannot be represented in the desired manner. + public object CastND(int n, Func cons) => CastND(n, ld => ld.Cast(cons)); + + /// + /// Represents this list as n-dimensional list of enums. + /// + /// Enum type + /// Number of dimensions + /// Cast function which converts ushort value to enum value + /// The desired representation as >]]> + /// is null. + /// is less than or equals 0. + /// If this list cannot be represented in the desired manner. + public object CastEnumsND(int n, Func cons) => CastND(n, ld => ld.CastEnums(cons)); + + /// + /// Represents this list as n-dimensional List(...List(Void)) + /// + /// Number of dimensions + /// The desired representation as >]]> + /// is less than or equals 0 + /// If this list cannot be represented in the desired manner. + public object CastVoidND(int n) => CastND(n, (ListDeserializer ld) => ld.Count); + + /// + /// Represents this list as "matrix" (jagged array) with primitive element type. + /// + /// Element type, must be primitive + /// The desired representation + /// If this list cannot be represented in the desired manner. + public IReadOnlyList> Cast2D() + { + return CastList().LazyListSelect(ld => ld.Cast>()); + } + + /// + /// Represents this list as List(Data). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public IReadOnlyList> CastData() => Cast2D(); + + /// + /// Represents this list as "matrix" (jagged array) with complex element type. + /// + /// Element type + /// Selector function which constructs an instance of from a + /// The desired representation + /// is null. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList> Cast2D(Func cons) + { + return CastList().LazyListSelect(ld => ld.Cast(cons)); + } + + /// + /// Represents this list as "matrix" (jagged array) of enum-typed elements. + /// + /// Enum type + /// Cast function which converts ushort value to enum value + /// The desired representation + /// is null. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList> CastEnums2D(Func cons) + { + return CastList().LazyListSelect(ld => ld.CastEnums(cons)); + } + + /// + /// Represents this list as 3-dimensional jagged array with primitive element type. + /// + /// Element type, must be primitive + /// The desired representation + /// If this list cannot be represented in the desired manner. + public IReadOnlyList>> Cast3D() + { + return CastList().LazyListSelect(ld => ld.Cast2D()); + } + + /// + /// Represents this list as 3-dimensional jagged array with complex element type. + /// + /// Element type + /// Selector function which constructs an instance of from a + /// The desired representation + /// is null. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList>> Cast3D(Func cons) + { + return CastList().LazyListSelect(ld => ld.Cast2D(cons)); + } + + /// + /// Represents this list as 3-dimensional jagged array of enum-typed elements. + /// + /// Enum type + /// Cast function which converts ushort value to enum value + /// The desired representation + /// is null. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList>> CastEnums3D(Func cons) + { + return CastList().LazyListSelect(ld => ld.CastEnums2D(cons)); + } + + /// + /// Represents this list as list of enum-typed elements. + /// + /// Enum type + /// Cast function which converts ushort value to enum value + /// The desired representation + /// is null. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList CastEnums(Func cons) + { + return CastUShort().LazyListSelect(cons); + } + + /// + /// Represents this list as List(Void), which boils down to returning the number of elements. + /// + /// The List(Void) representation which is nothing but the list's element count. + public int CastVoid() => Count; + + /// + /// Represents this list as List(List(Void)), which boils down to returning a list of element counts. + /// + /// A list of integers whereby each number equals the sublist's element count. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList CastVoid2D() => CastList().LazyListSelect(ld => ld.Count); + + /// + /// Represents this list as List(List(List(Void))). + /// + /// The List(List(List(Void))) representation which is in turn a 2-dimensional jagged array of element counts. + /// If this list cannot be represented in the desired manner. + public IReadOnlyList> CastVoid3D() => CastList().LazyListSelect(ld => ld.CastVoid2D()); + + /// + /// Represents this list as List(Text). For representing it as Text, use . + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public IReadOnlyList CastText2() => CastList().LazyListSelect(ld => ld.CastText()); + + /// + /// Represents this list as Text. For representing it as List(Text), use . + /// + /// + /// Did you notice that the naming pattern is broken here? For every other CastX method, X depicts the element type. + /// CastX actually means "represent this list as list of X". Logically, the semantics of CastText should be the semantics + /// implemented by CastText2. And this method's name should be "CastChar". This wouldn't be accurate either, since a string + /// is semantically more than the list of its characters. Trying to figure out a consistent naming pattern, we'd probably + /// end up in less concise method names (do you have a good suggestion?). Considering this and the fact that you probably + /// won't use these methods directly (because the code generator will produce nice wrappers for you) it seems acceptable to + /// live with the asymmetric and somewhat ugly naming. + /// + /// The decoded text + /// If this list cannot be represented in the desired manner. + public virtual string CastText() + { + throw new NotSupportedException("This kind of list does not represent text"); + } + + /// + /// Represents this list as List(Bool). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastBool() + { + return Cast(sd => sd.ReadDataBool(0)); + } + + /// + /// Represents this list as List(Int8). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastSByte() + { + return Cast(sd => sd.ReadDataSByte(0)); + } + + /// + /// Represents this list as List(UInt8). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastByte() + { + return Cast(sd => sd.ReadDataByte(0)); + } + + /// + /// Represents this list as List(Int16). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastShort() + { + return Cast(sd => sd.ReadDataShort(0)); + } + + /// + /// Represents this list as List(UInt16). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastUShort() + { + return Cast(sd => sd.ReadDataUShort(0)); + } + + /// + /// Represents this list as List(Int32). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastInt() + { + return Cast(sd => sd.ReadDataInt(0)); + } + + /// + /// Represents this list as List(UInt32). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastUInt() + { + return Cast(sd => sd.ReadDataUInt(0)); + } + + public virtual IReadOnlyList CastLong() + /// + /// Represents this list as List(Int64). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + { + return Cast(sd => sd.ReadDataLong(0)); + } + + /// + /// Represents this list as List(UInt64). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastULong() + { + return Cast(sd => sd.ReadDataULong(0)); + } + + /// + /// Represents this list as List(Float32). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastFloat() + { + return Cast(sd => sd.ReadDataFloat(0)); + } + + /// + /// Represents this list as List(Float64). + /// + /// The desired representation + /// If this list cannot be represented in the desired manner. + public virtual IReadOnlyList CastDouble() + { + return Cast(sd => sd.ReadDataDouble(0)); + } + } +} diff --git a/Capnp.Net.Runtime/ListKind.cs b/Capnp.Net.Runtime/ListKind.cs new file mode 100644 index 0000000..66d5492 --- /dev/null +++ b/Capnp.Net.Runtime/ListKind.cs @@ -0,0 +1,48 @@ +namespace Capnp +{ + /// + /// Enumerates the list element categories which are defined by Cap'n Proto. + /// + public enum ListKind: byte + { + /// + /// List(Void) + /// + ListOfEmpty = 0, + + /// + /// List(Bool) + /// + ListOfBits = 1, + + /// + /// List(Int8) or List(UInt8) + /// + ListOfBytes = 2, + + /// + /// List(Int16), List(UInt16), or List(Enum) + /// + ListOfShorts = 3, + + /// + /// List(Int32), List(UInt32), or List(Float32) + /// + ListOfInts = 4, + + /// + /// List(Int64), List(UInt64), or List(Float64) + /// + ListOfLongs = 5, + + /// + /// A list of pointers + /// + ListOfPointers = 6, + + /// + /// A list of fixed-size composites (i.e. structs) + /// + ListOfStructs = 7 + } +} diff --git a/Capnp.Net.Runtime/ListOfBitsDeserializer.cs b/Capnp.Net.Runtime/ListOfBitsDeserializer.cs new file mode 100644 index 0000000..1cc4061 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfBitsDeserializer.cs @@ -0,0 +1,79 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for a List(Bool). + /// + public class ListOfBitsDeserializer: ListDeserializer, IReadOnlyList + { + readonly bool _defaultValue; + + internal ListOfBitsDeserializer(ref DeserializerState context, bool defaultValue) : + base(ref context) + { + _defaultValue = defaultValue; + } + + /// + /// Always ListKind.ListOfBits + /// + public override ListKind Kind => ListKind.ListOfBits; + + /// + /// Gets the element at given index. + /// + /// Element index + /// Element value + /// is out of range. + public bool this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + int wi = index / 64; + int bi = index % 64; + + return ((State.CurrentSegment[State.Offset + wi] >> bi) & 1) != + (_defaultValue ? 1u : 0); + } + } + + IEnumerable Enumerate() + { + for (int i = 0; i < Count; i++) + yield return this[i]; + } + + /// + /// Implements + /// + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + /// + /// Return this + /// + public override IReadOnlyList CastBool() => this; + + /// + /// Always throws since it is not intended to represent a list of bits differently. + /// + public override IReadOnlyList Cast(Func cons) + { + throw new NotSupportedException("Cannot cast a list of bits to anything else"); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfBitsSerializer.cs b/Capnp.Net.Runtime/ListOfBitsSerializer.cs new file mode 100644 index 0000000..cbbfe3d --- /dev/null +++ b/Capnp.Net.Runtime/ListOfBitsSerializer.cs @@ -0,0 +1,98 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp +{ + /// + /// SerializerState specialization for a List(Bool). + /// + public class ListOfBitsSerializer: SerializerState, IReadOnlyList + { + + /// + /// Gets or sets the element at given index. + /// + /// Element index + /// Element value + /// List was not initialized, or attempting to overwrite a non-null element. + /// is out of range. + public bool this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + int wi = index / 64; + int bi = index % 64; + + return ((RawData[wi] >> bi) & 1) != 0; + } + set + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + int wi = index / 64; + int bi = index % 64; + + if (value) + RawData[wi] |= (1ul << bi); + else + RawData[wi] &= ~(1ul << bi); + } + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + SetListOfValues(1, count); + } + + /// + /// Initializes the list with given content. + /// + /// List content. Can be null in which case the list is simply not initialized. + /// The list was already initialized + /// More than 2^29-1 items. + public void Init(IReadOnlyList items) + { + if (items == null) + { + return; + } + + Init(items.Count); + + for (int i = 0; i < items.Count; i++) + { + this[i] = items[i]; + } + } + + /// + /// Implements + /// + public IEnumerator GetEnumerator() => (IEnumerator)this.ToArray().GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => this.ToArray().GetEnumerator(); + } +} diff --git a/Capnp.Net.Runtime/ListOfCapsDeserializer.cs b/Capnp.Net.Runtime/ListOfCapsDeserializer.cs new file mode 100644 index 0000000..a1668c6 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfCapsDeserializer.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for a list of capabilities. + /// + /// Capability interface + public class ListOfCapsDeserializer : ListDeserializer, IReadOnlyList + where T: class + { + internal ListOfCapsDeserializer(ref DeserializerState state) : base(ref state) + { + Rpc.CapabilityReflection.ValidateCapabilityInterface(typeof(T)); + } + + /// + /// Returns the capability at given index. + /// + /// Element index + /// The capability at given index (in terms of its proxy instance) + public T this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + return Rpc.CapabilityReflection.CreateProxy(State.DecodeCapPointer(index)) as T; + } + } + + /// + /// Always ListKind.ListOfPointers + /// + public override ListKind Kind => ListKind.ListOfPointers; + + /// + /// Always throws , since it is not intended to convert a capability list to anything else. + /// + public override IReadOnlyList Cast(Func cons) + { + throw new NotSupportedException("Cannot cast a list of capabilities to anything else"); + } + + IEnumerable Enumerate() + { + int count = Count; + for (int i = 0; i < count; i++) + { + yield return this[i]; + } + } + + /// + /// Implements + /// + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfCapsSerializer.cs b/Capnp.Net.Runtime/ListOfCapsSerializer.cs new file mode 100644 index 0000000..b7207e9 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfCapsSerializer.cs @@ -0,0 +1,111 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + /// + /// SerializerState specialization for a list of capabilities. + /// + /// Capability interface + public class ListOfCapsSerializer : + SerializerState, + IReadOnlyList + where T : class + { + /// + /// Constructs an instance. + /// + /// does not quality as capability interface. + /// The implementation might attempt to throw this exception earlier in the static constructor (during type load). Currently it doesn't + /// because there is a significant risk of messing something up and ending with a hard-to-debug . + public ListOfCapsSerializer() + { + Rpc.CapabilityReflection.ValidateCapabilityInterface(typeof(T)); + } + + /// + /// Gets or sets the capability at given element index. + /// + /// Element index + /// Proxy object of capability at given element index + /// List was not initialized, or attempting to overwrite an already set element. + /// is out of range. + public T this[int index] + { + get => Rpc.CapabilityReflection.CreateProxy(DecodeCapPointer(index)) as T; + set + { + if (!IsAllocated) + throw new InvalidOperationException("Call Init() first"); + + if (index < 0 || index >= RawData.Length) + throw new IndexOutOfRangeException("index out of range"); + + uint id = ProvideCapability(value); + WirePointer ptr = default; + ptr.SetCapability(id); + RawData[index] = id; + } + } + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + SetListOfPointers(count); + } + + /// + /// Initializes the list with given content. + /// + /// List content. Can be null in which case the list is simply not initialized. + /// The list was already initialized + /// More than 2^29-1 items. + public void Init(IReadOnlyList caps) + { + if (caps == null) + { + return; + } + + Init(caps.Count); + + for (int i = 0; i < caps.Count; i++) + { + this[i] = caps[i]; + } + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + IEnumerable Enumerate() + { + int count = Count; + for (int i = 0; i < count; i++) + yield return this[i]; + } + + /// + /// Implements + /// + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfEmptyDeserializer.cs b/Capnp.Net.Runtime/ListOfEmptyDeserializer.cs new file mode 100644 index 0000000..e8d1d2f --- /dev/null +++ b/Capnp.Net.Runtime/ListOfEmptyDeserializer.cs @@ -0,0 +1,66 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for List(Void). + /// + public class ListOfEmptyDeserializer : ListDeserializer, IReadOnlyList + { + internal ListOfEmptyDeserializer(ref DeserializerState state) : + base(ref state) + { + } + + /// + /// Returns a DeserializerState representing an element at given index. + /// This is always the null object, since Void cannot carry any data. + /// + /// Element index + /// default(DeserializerState) + /// is out of range. + public DeserializerState this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + return default; + } + } + + /// + /// Always ListKind.ListOfEmpty + /// + public override ListKind Kind => ListKind.ListOfEmpty; + + /// + /// Applies a selector function to each element. + /// Trivia: Since each element is the null object, the selector function always gets fed with a null object. + /// + /// Element target type + /// Selector function + /// The desired representation + public override IReadOnlyList Cast(Func cons) + { + return this.LazyListSelect(cons); + } + + /// + /// Implements . + /// + public IEnumerator GetEnumerator() + { + return Enumerable.Repeat(default(DeserializerState), Count).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfEmptySerializer.cs b/Capnp.Net.Runtime/ListOfEmptySerializer.cs new file mode 100644 index 0000000..7638b61 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfEmptySerializer.cs @@ -0,0 +1,33 @@ +using System; + +namespace Capnp +{ + /// + /// SerializerState specialization for List(Void). + /// + public class ListOfEmptySerializer: + SerializerState + { + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + SetListOfValues(0, count); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfPointersDeserializer.cs b/Capnp.Net.Runtime/ListOfPointersDeserializer.cs new file mode 100644 index 0000000..a3e679e --- /dev/null +++ b/Capnp.Net.Runtime/ListOfPointersDeserializer.cs @@ -0,0 +1,91 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for List(T) when T is unknown (generic), List(Data), List(Text), and List(List(...)). + /// + public class ListOfPointersDeserializer: ListDeserializer, IReadOnlyList + { + internal ListOfPointersDeserializer(ref DeserializerState state) : + base(ref state) + { + } + + /// + /// Always ListKind.ListOfPointers + /// + public override ListKind Kind => ListKind.ListOfPointers; + + /// + /// Gets the DeserializerState representing the element at given index. + /// + /// Element index + /// DeserializerState representing the element at given index + public DeserializerState this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + var state = State; + + state.DecodePointer(index); + + return state; + } + } + + IEnumerable Enumerate() + { + for (int i = 0; i < Count; i++) + yield return this[i]; + } + + /// + /// Implements . + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + /// + /// Applies a selector function to each element. + /// + /// Element target type + /// Selector function + /// The desired representation + public override IReadOnlyList Cast(Func cons) + { + return this.LazyListSelect(cons); + } + + /// + /// Interprets this instance as List(List(...)). + /// + /// The desired representation. Since it is evaluated lazily, type conflicts will not happen before accessing the resulting list's elements. + public override IReadOnlyList CastList() + { + return this.LazyListSelect(d => d.RequireList()); + } + + /// + /// Interprets this instance as a list of capabilities. + /// + /// Capability interface + /// The desired representation. Since it is evaluated lazily, type conflicts will not happen before accessing the resulting list's elements. + public override IReadOnlyList> CastCapList() + { + return this.LazyListSelect(d => d.RequireCapList()); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfPointersSerializer.cs b/Capnp.Net.Runtime/ListOfPointersSerializer.cs new file mode 100644 index 0000000..15d9cdd --- /dev/null +++ b/Capnp.Net.Runtime/ListOfPointersSerializer.cs @@ -0,0 +1,118 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Capnp +{ + /// + /// SerializerState specialization for List(T) when T is unknown (generic), List(Data), List(Text), and List(List(...)). + /// + /// SerializerState which represents the element type + public class ListOfPointersSerializer: + SerializerState, + IReadOnlyList + where TS: SerializerState, new() + { + /// + /// Gets or sets the element at given index. + /// + /// Element index + /// Serializer state representing the desired element + /// List was not initialized, or attempting to overwrite a non-null element. + /// is out of range. + public TS this[int index] + { + get + { + if (!IsAllocated) + throw new InvalidOperationException("Not initialized"); + + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + return BuildPointer(index); + } + set + { + if (!IsAllocated) + throw new InvalidOperationException("Not initialized"); + + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + Link(index, value, true); + } + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + IEnumerable Enumerate() + { + int count = Count; + + for (int i = 0; i < count; i++) + { + yield return TryGetPointer(i); + } + } + + /// + /// Implements . + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + SetListOfPointers(count); + } + + /// + /// Initializes the list with given content. + /// + /// Item type + /// List content. Can be null in which case the list is simply not initialized. + /// Serialization action to transfer a particular item into the serializer state. + /// The list was already initialized + /// More than 2^29-1 items. + public void Init(IReadOnlyList items, Action init) + { + if (items == null) + { + return; + } + + Init(items.Count); + + for (int i = 0; i < items.Count; i++) + { + init(this[i], items[i]); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} + diff --git a/Capnp.Net.Runtime/ListOfPrimitivesDeserializer.cs b/Capnp.Net.Runtime/ListOfPrimitivesDeserializer.cs new file mode 100644 index 0000000..fc10145 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfPrimitivesDeserializer.cs @@ -0,0 +1,234 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for List(Int*), List(UInt*), List(Float*), and List(Enum). + /// + /// List element type + public class ListOfPrimitivesDeserializer: ListDeserializer, IReadOnlyList + where T: struct + { + class ListOfULongAsStructView : IReadOnlyList + { + readonly ListOfPrimitivesDeserializer _lpd; + readonly Func _sel; + + public ListOfULongAsStructView(ListOfPrimitivesDeserializer lpd, Func sel) + { + _lpd = lpd; + _sel = sel; + } + + public U this[int index] + { + get + { + var state = _lpd.State; + + if (index < 0 || index >= _lpd.Count) + throw new ArgumentOutOfRangeException(nameof(index)); + + state.Offset += index; + state.Kind = ObjectKind.Struct; + state.StructDataCount = 1; + state.StructPtrCount = 0; + + return _sel(state); + } + } + + public int Count => _lpd.Count; + + IEnumerable Enumerate() + { + var state = _lpd.State; + + state.Kind = ObjectKind.Struct; + state.StructDataCount = 1; + state.StructPtrCount = 0; + + for (int i = 0; i < Count; i++) + { + yield return _sel(state); + ++state.Offset; + } + + } + + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + readonly ListKind _kind; + + internal ListOfPrimitivesDeserializer(ref DeserializerState state, ListKind kind) : + base(ref state) + { + _kind = kind; + + var binCoder = PrimitiveCoder.Get(); + } + + /// + /// One of ListOfBytes, ListOfShorts, ListOfInts, ListOfLongs. + /// + public override ListKind Kind => _kind; + + ReadOnlySpan Data => MemoryMarshal.Cast(State.CurrentSegment.Slice(State.Offset)).Slice(0, Count); + + /// + /// Returns the element at given index. + /// + /// Element index + /// Element value + /// is out of range. + public T this[int index] => Data[index]; + + ListOfPrimitivesDeserializer PrimitiveCast() where U: struct + { + if (Marshal.SizeOf() != Marshal.SizeOf()) + throw new NotSupportedException("Source and target types have different sizes, cannot cast"); + + var stateCopy = State; + return new ListOfPrimitivesDeserializer(ref stateCopy, Kind); + } + + /// + /// Always throws because this specialization can never represent a List(bool). + /// + public override IReadOnlyList CastBool() => throw new NotSupportedException("Cannot cast to list of bits"); + + /// + /// Attempts to interpret this instance as List(UInt8). + /// + /// The desired representation + /// Element size is different from 1 byte. + public override IReadOnlyList CastByte() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Int8). + /// + /// The desired representation + /// Element size is different from 1 byte. + public override IReadOnlyList CastSByte() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(UInt16). + /// + /// The desired representation + /// Element size is different from 2 bytes. + public override IReadOnlyList CastUShort() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Int16). + /// + /// The desired representation + /// Element size is different from 2 bytes. + public override IReadOnlyList CastShort() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(UInt32). + /// + /// The desired representation + /// Element size is different from 4 bytes. + public override IReadOnlyList CastUInt() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Int32). + /// + /// The desired representation + /// Element size is different from 4 bytes. + public override IReadOnlyList CastInt() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(UInt64). + /// + /// The desired representation + /// Element size is different from 8 bytes. + public override IReadOnlyList CastULong() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Int64). + /// + /// The desired representation + /// Element size is different from 8 bytes. + public override IReadOnlyList CastLong() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Float32). + /// + /// The desired representation + /// Element size is different from 4 bytes. + public override IReadOnlyList CastFloat() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(Float64). + /// + /// The desired representation + /// Element size is different from 8 bytes. + public override IReadOnlyList CastDouble() => PrimitiveCast(); + + /// + /// Attempts to interpret this instance as List(U) whereby U is a struct, applying a selector function to each element. + /// + /// Selector function + /// The desired representation + public override IReadOnlyList Cast(Func cons) + { + switch (Marshal.SizeOf()) + { + case 1: return PrimitiveCast().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))); + case 2: return PrimitiveCast().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))); + case 4: return PrimitiveCast().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))); + case 8: return new ListOfULongAsStructView(PrimitiveCast(), cons); + default: + throw new InvalidProgramException("This program path should not be reachable"); + } + } + + /// + /// Attempts to interpret this instance as Text and returns the string representation. + /// + /// The decoded string + /// Element size is different from 1 byte. + public override string CastText() + { + var utf8Bytes = PrimitiveCast().Data; + if (utf8Bytes.Length == 0) return string.Empty; + var utf8GytesNoZterm = utf8Bytes.Slice(0, utf8Bytes.Length - 1); + return Encoding.UTF8.GetString(utf8GytesNoZterm); + } + + IEnumerable Enumerate() + { + for (int i = 0; i < Count; i++) + yield return this[i]; + } + + /// + /// Implements . + /// + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfPrimitivesSerializer.cs b/Capnp.Net.Runtime/ListOfPrimitivesSerializer.cs new file mode 100644 index 0000000..a558475 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfPrimitivesSerializer.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace Capnp +{ + /// + /// SerializerState specialization for List(Int*), List(UInt*), List(Float*), and List(Enum). + /// + /// List element type, must be primitive. Static constructor will throw if the type does not work. + public class ListOfPrimitivesSerializer : + SerializerState, + IReadOnlyList + where T : struct + { + static readonly int ElementSize; + + static ListOfPrimitivesSerializer() + { + if (typeof(T).IsEnum) + { + ElementSize = Marshal.SizeOf(Enum.GetUnderlyingType(typeof(T))); + } + else + { + ElementSize = Marshal.SizeOf(); + } + } + + Span Data => MemoryMarshal.Cast(RawData); + + /// + /// Gets or sets the value at given index. + /// + /// Element index + /// Element value + public T this[int index] + { + get => Data[index]; + set => Data[index] = value; + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + SetListOfValues((byte)(8 * ElementSize), count); + } + + /// + /// Initializes the list with given content. + /// + /// List content. Can be null in which case the list is simply not initialized. + /// The list was already initialized + /// More than 2^29-1 items. + public void Init(IReadOnlyList items) + { + if (items == null) + { + return; + } + + Init(items.Count); + + for (int i = 0; i < items.Count; i++) + { + this[i] = items[i]; + } + } + + /// + /// Implements . + /// + /// + public IEnumerator GetEnumerator() => (IEnumerator)Data.ToArray().GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => Data.ToArray().GetEnumerator(); + } +} diff --git a/Capnp.Net.Runtime/ListOfStructsDeserializer.cs b/Capnp.Net.Runtime/ListOfStructsDeserializer.cs new file mode 100644 index 0000000..04f0bdd --- /dev/null +++ b/Capnp.Net.Runtime/ListOfStructsDeserializer.cs @@ -0,0 +1,81 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp +{ + /// + /// ListDeserializer specialization for List(T) when T is a known struct (i.e. a list of fixed-width composites). + /// + public class ListOfStructsDeserializer: ListDeserializer, IReadOnlyList + { + internal ListOfStructsDeserializer(ref DeserializerState context): + base(ref context) + { + } + + /// + /// Always returns ListKind.ListOfStructs. + /// + public override ListKind Kind => ListKind.ListOfStructs; + + /// + /// Returns the deserializer state at given index. + /// + /// Element index + /// Element deserializer state + /// is out of range. + /// Traversal limit reached + public DeserializerState this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + int stride = State.StructDataCount + State.StructPtrCount; + + var state = State; + // the “traversal limit” should count a list of zero-sized elements as if each element were one word instead. + state.IncrementBytesTraversed(checked(8u * (uint)(stride == 0 ? 1 : stride))); + state.Offset = checked(state.Offset + 1 + index * stride); + state.Kind = ObjectKind.Struct; + + return state; + } + } + + /// + /// Converts this list to a different representation by applying an element selector function. + /// + /// Target type after applying the selector function + /// The selector function + /// The new list representation + public override IReadOnlyList Cast(Func cons) + { + return this.LazyListSelect(cons); + } + + IEnumerable Enumerate() + { + for (int i = 0; i < Count; i++) + { + yield return this[i]; + } + } + + /// + /// Implements + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfStructsSerializer.cs b/Capnp.Net.Runtime/ListOfStructsSerializer.cs new file mode 100644 index 0000000..6f25afb --- /dev/null +++ b/Capnp.Net.Runtime/ListOfStructsSerializer.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp +{ + /// + /// SerializerState specialization for List(T) when T is a known struct (i.e. a list of fixed-width composites). + /// + /// SerializerState which represents the struct type + public class ListOfStructsSerializer : + SerializerState, + IReadOnlyList + where TS : SerializerState, new() + { + /// + /// Returns the struct serializer a given index. + /// + /// Element index + /// The struct serializer + public TS this[int index] + { + get + { + if (!IsAllocated) + throw new InvalidOperationException("Not initialized"); + + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + return ListBuildStruct(index); + } + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + /// + /// Implementation of /> + /// + /// + public IEnumerator GetEnumerator() + { + if (Count == 0) return Enumerable.Empty().GetEnumerator(); + return ListEnumerateStructs().GetEnumerator(); + } + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + var sample = new TS(); + SetListOfStructs(count, sample.StructDataCount, sample.StructPtrCount); + } + + /// + /// Initializes the list with given content. + /// + /// Item type + /// List content. Can be null in which case the list is simply not initialized. + /// Serialization action to transfer a particular item into the serializer state. + /// The list was already initialized + /// More than 2^29-1 items. + public void Init(IReadOnlyList items, Action init) + { + if (items == null) + { + return; + } + + Init(items.Count); + + for (int i = 0; i < items.Count; i++) + { + init(this[i], items[i]); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/Capnp.Net.Runtime/ListOfTextSerializer.cs b/Capnp.Net.Runtime/ListOfTextSerializer.cs new file mode 100644 index 0000000..b8e4da1 --- /dev/null +++ b/Capnp.Net.Runtime/ListOfTextSerializer.cs @@ -0,0 +1,112 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// SerializerState specialization for List(Text) + /// + public class ListOfTextSerializer : + SerializerState, + IReadOnlyList + { + /// + /// Gets or sets the text at given index. Once an element is set, it cannot be overwritten. + /// + /// Element index + /// List is not initialized + /// is out of range. + /// UTF-8 encoding exceeds 2^29-2 bytes + public string this[int index] + { + get + { + if (!IsAllocated) + throw new InvalidOperationException("Not initialized"); + + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + return ReadText(index); + } + set + { + if (!IsAllocated) + throw new InvalidOperationException("Not initialized"); + + if (index < 0 || index >= Count) + throw new IndexOutOfRangeException(); + + WriteText(index, value); + } + } + + /// + /// This list's element count. + /// + public int Count => ListElementCount; + + IEnumerable Enumerate() + { + int count = Count; + + for (int i = 0; i < count; i++) + { + yield return TryGetPointer(i)?.ListReadAsText(); + } + } + + /// + /// Implementation of /> + /// + public IEnumerator GetEnumerator() + { + return Enumerate().GetEnumerator(); + } + + /// + /// Initializes this list with a specific size. The list can be initialized only once. + /// + /// List element count + /// The list was already initialized + /// is negative or greater than 2^29-1 + public void Init(int count) + { + if (IsAllocated) + throw new InvalidOperationException("Already initialized"); + + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + SetListOfPointers(count); + } + + /// + /// Initializes the list with given content. + /// + /// List content. Can be null in which case the list is simply not initialized. + /// The list was already initialized + /// More than 2^29-1 items, or the UTF-8 encoding of an individual string requires more than 2^29-2 bytes. + public void Init(IReadOnlyList items) + { + if (items == null) + { + return; + } + + Init(items.Count); + + for (int i = 0; i < items.Count; i++) + { + this[i] = items[i]; + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} + diff --git a/Capnp.Net.Runtime/Logging.cs b/Capnp.Net.Runtime/Logging.cs new file mode 100644 index 0000000..53e2e42 --- /dev/null +++ b/Capnp.Net.Runtime/Logging.cs @@ -0,0 +1,23 @@ +using System; +using Microsoft.Extensions.Logging; + +namespace Capnp +{ + /// + /// Runtime logging features rely on + /// + public static class Logging + { + /// + /// Gets or sets the logger factory which will be used by this assembly. + /// + public static ILoggerFactory LoggerFactory { get; set; } = new LoggerFactory(); + + /// + /// Creates a new ILogger instance, using the LoggerFactory of this class. + /// + /// The type using the logger + /// The logger instance + public static ILogger CreateLogger() => LoggerFactory.CreateLogger(); + } +} diff --git a/Capnp.Net.Runtime/MessageBuilder.cs b/Capnp.Net.Runtime/MessageBuilder.cs new file mode 100644 index 0000000..d0fe6a0 --- /dev/null +++ b/Capnp.Net.Runtime/MessageBuilder.cs @@ -0,0 +1,102 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Text; + +namespace Capnp +{ + /// + /// Entry point for building Cap'n Proto messages. + /// + public class MessageBuilder + { + readonly ISegmentAllocator _allocator; + readonly DynamicSerializerState _rootPtrBuilder; + List _capTable; + + MessageBuilder(ISegmentAllocator allocator) + { + _allocator = allocator; + _rootPtrBuilder = new DynamicSerializerState(this); + _rootPtrBuilder.SetStruct(0, 1); + _rootPtrBuilder.Allocate(); + } + + /// + /// Constructs an instance using a custom segment allocator and reserves space for the root pointer. + /// + /// Segment allocator implementation type + public static MessageBuilder Create() where T: ISegmentAllocator, new() + { + return new MessageBuilder(new T()); + } + + /// + /// Constructs an instance using the default segment allocator and reserves space for the root pointer. + /// + /// Default segment size, + public static MessageBuilder Create(int defaultSegmentSize = 128) + { + return new MessageBuilder(new SegmentAllocator(defaultSegmentSize)); + } + + /// + /// Creates a new object inside the message. + /// + /// Serializer state specialization + /// Serializer state instance representing the new object + public TS CreateObject() where TS: SerializerState, new() + { + var ts = new TS(); + ts.Bind(this); + return ts; + } + + /// + /// Gets or sets the root object. The root object must be set exactly once per message. + /// Setting it manually is only required (and allowed) when it was created with . + /// + public SerializerState Root + { + get => _rootPtrBuilder.TryGetPointer(0); + set => _rootPtrBuilder.Link(0, value); + } + + /// + /// Creates an object and sets it as root object. + /// + /// Serializer state specialization + /// Serializer state instance representing the new object + public TS BuildRoot() where TS: SerializerState, new() + { + if (Root != null) + throw new InvalidOperationException("Root already set"); + + var root = CreateObject(); + Root = root; + return root; + } + + /// + /// Returns the wire representation of the built message. + /// + public WireFrame Frame => new WireFrame(_allocator.Segments); + + /// + /// Initializes the capability table for using the message builder in RPC context. + /// + public void InitCapTable() + { + if (_capTable != null) + throw new InvalidOperationException("Capability table was already initialized"); + + _capTable = new List(); + } + + /// + /// Returns this message builder's segment allocator. + /// + public ISegmentAllocator Allocator => _allocator; + internal List Caps => _capTable; + } +} diff --git a/Capnp.Net.Runtime/ObjectKind.cs b/Capnp.Net.Runtime/ObjectKind.cs new file mode 100644 index 0000000..c3b83f8 --- /dev/null +++ b/Capnp.Net.Runtime/ObjectKind.cs @@ -0,0 +1,73 @@ +using System; + +namespace Capnp +{ + /// + /// The different kinds of Cap'n Proto objects. + /// Despite this is a [Flags] enum, it does not make sense to mutually combine literals. + /// + [Flags] + public enum ObjectKind: byte + { + /// + /// The null object, obtained by decoding a null pointer. + /// + Nil = 0, + + /// + /// A struct + /// + Struct = 1, + + /// + /// A capability + /// + Capability = 2, + + /// + /// A List(void) + /// + ListOfEmpty = 8, + + /// + /// A list of bits + /// + ListOfBits = 9, + + /// + /// A list of octets + /// + ListOfBytes = 10, + + /// + /// A list of 16 bit words + /// + ListOfShorts = 11, + + /// + /// A list of 32 bit words + /// + ListOfInts = 12, + + /// + /// A list of 64 bits words + /// + ListOfLongs = 13, + + /// + /// A list of pointers + /// + ListOfPointers = 14, + + /// + /// A list of fixed-width composites + /// + ListOfStructs = 15, + + /// + /// A value. This kind of object does not exist on the wire and is not specified by Capnp. + /// It is an internal helper to represent lists of primitive values as lists of structs. + /// + Value = 16 + } +} diff --git a/Capnp.Net.Runtime/PrimitiveCoder.cs b/Capnp.Net.Runtime/PrimitiveCoder.cs new file mode 100644 index 0000000..ba03f80 --- /dev/null +++ b/Capnp.Net.Runtime/PrimitiveCoder.cs @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + class PrimitiveCoder + { + class Coder + { + public static Func Fn { get; set; } + } + + static PrimitiveCoder() + { + Coder.Fn = (x, y) => x != y; + Coder.Fn = (x, y) => (sbyte)(x ^ y); + Coder.Fn = (x, y) => (byte)(x ^ y); + Coder.Fn = (x, y) => (short)(x ^ y); + Coder.Fn = (x, y) => (ushort)(x ^ y); + Coder.Fn = (x, y) => x ^ y; + Coder.Fn = (x, y) => x ^ y; + Coder.Fn = (x, y) => x ^ y; + Coder.Fn = (x, y) => x ^ y; + Coder.Fn = (x, y) => + { + int xi = BitConverter.SingleToInt32Bits(x); + int yi = BitConverter.SingleToInt32Bits(y); + int zi = xi ^ yi; + return BitConverter.Int32BitsToSingle(zi); + }; + Coder.Fn = (x, y) => + { + long xi = BitConverter.DoubleToInt64Bits(x); + long yi = BitConverter.DoubleToInt64Bits(y); + long zi = xi ^ yi; + return BitConverter.Int64BitsToDouble(zi); + }; + } + + public static Func Get() + { + return Coder.Fn ?? + throw new NotSupportedException("Generic type argument is not a supported primitive type, no coder defined"); + } + } +} diff --git a/Capnp.Net.Runtime/ReadOnlyListExtensions.cs b/Capnp.Net.Runtime/ReadOnlyListExtensions.cs new file mode 100644 index 0000000..9ff9097 --- /dev/null +++ b/Capnp.Net.Runtime/ReadOnlyListExtensions.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Capnp +{ + /// + /// Provides extension methods for + /// + public static class ReadOnlyListExtensions + { + class ReadOnlyListSelectOperator : IReadOnlyList + { + readonly IReadOnlyList _source; + readonly Func _selector; + + public ReadOnlyListSelectOperator(IReadOnlyList source, Func selector) + { + _source = source ?? throw new ArgumentNullException(nameof(source)); + _selector = selector ?? throw new ArgumentNullException(nameof(selector)); + } + + public To this[int index] => _selector(_source[index]); + + public int Count => _source.Count; + + public IEnumerator GetEnumerator() + { + return _source.Select(_selector).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + /// + /// LINQ-like "Select" operator for + /// + /// Source element type + /// Target element type + /// Source list + /// Selector function + /// A read-only list in which each element corresponds to the source element after applying the selector function + /// or is null. + public static IReadOnlyList LazyListSelect( + this IReadOnlyList source, Func selector) + { + return new ReadOnlyListSelectOperator(source, selector); + } + + /// + /// Applies a selector function to each list element and stores the result in a new list. + /// As opposed to the source is evaluated immediately + /// and the result is cached. + /// + /// Source element type + /// Target element type + /// Source list + /// Selector function + /// A read-only list in which each element corresponds to the source element after applying the selector function + /// or is null. + public static IReadOnlyList ToReadOnlyList( + this IReadOnlyList source, Func selector) + { + return source.Select(selector).ToList().AsReadOnly(); + } + } +} diff --git a/Capnp.Net.Runtime/Reserializing.cs b/Capnp.Net.Runtime/Reserializing.cs new file mode 100644 index 0000000..8f0c964 --- /dev/null +++ b/Capnp.Net.Runtime/Reserializing.cs @@ -0,0 +1,99 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + /// + /// Provides deep-copy functionality to re-serialize an existing deserializer state into another serializer state. + /// + public static class Reserializing + { + /// + /// Performs a deep copy of an existing deserializer state into another serializer state. + /// This implementation does not analyze the source object graph and therefore cannot detect multiple references to the same object. + /// Such cases will result in object duplication. + /// + /// source state + /// target state + /// is null. + /// Target state was already set to a different object type than the source state. + /// Security violation due to amplification attack or stack overflow DoS attack, + /// or illegal pointer detected during deserialization. + public static void DeepCopy(DeserializerState from, SerializerState to) + { + if (to == null) + throw new ArgumentNullException(nameof(to)); + + var ds = to.Rewrap(); + + IReadOnlyList items; + + switch (from.Kind) + { + case ObjectKind.Struct: + ds.SetStruct(from.StructDataCount, from.StructPtrCount); + ds.Allocate(); + from.StructDataSection.CopyTo(ds.StructDataSection); + for (int i = 0; i < from.StructPtrCount; i++) + { + DeepCopy(from.StructReadPointer(i), ds.BuildPointer(i)); + } + break; + + case ObjectKind.ListOfBits: + ds.SetListOfValues(1, from.ListElementCount); + from.RawData.CopyTo(ds.RawData); + break; + + case ObjectKind.ListOfBytes: + ds.SetListOfValues(8, from.ListElementCount); + from.RawData.CopyTo(ds.RawData); + break; + + case ObjectKind.ListOfEmpty: + ds.SetListOfValues(0, from.ListElementCount); + break; + + case ObjectKind.ListOfInts: + ds.SetListOfValues(32, from.ListElementCount); + from.RawData.CopyTo(ds.RawData); + break; + + case ObjectKind.ListOfLongs: + ds.SetListOfValues(64, from.ListElementCount); + from.RawData.CopyTo(ds.RawData); + break; + + case ObjectKind.ListOfShorts: + ds.SetListOfValues(16, from.ListElementCount); + from.RawData.CopyTo(ds.RawData); + break; + + case ObjectKind.ListOfPointers: + ds.SetListOfPointers(from.ListElementCount); + items = (IReadOnlyList)from.RequireList(); + for (int i = 0; i < from.ListElementCount; i++) + { + DeepCopy(items[i], ds.BuildPointer(i)); + } + break; + + case ObjectKind.ListOfStructs: + ds.SetListOfStructs(from.ListElementCount, from.StructDataCount, from.StructPtrCount); + items = (IReadOnlyList)from.RequireList(); + for (int i = 0; i < from.ListElementCount; i++) + { + DeepCopy(items[i], ds.ListBuildStruct(i)); + } + break; + + case ObjectKind.Capability: + ds.SetCapability(from.CapabilityIndex); + break; + } + + to.InheritFrom(ds); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/AnswerOrCounterquestion.cs b/Capnp.Net.Runtime/Rpc/AnswerOrCounterquestion.cs new file mode 100644 index 0000000..0755b53 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/AnswerOrCounterquestion.cs @@ -0,0 +1,28 @@ +namespace Capnp.Rpc +{ + /// + /// Helper struct to support tail calls + /// + public struct AnswerOrCounterquestion + { + readonly object _obj; + + AnswerOrCounterquestion(object obj) + { + _obj = obj; + } + + public static implicit operator AnswerOrCounterquestion (SerializerState answer) + { + return new AnswerOrCounterquestion(answer); + } + + public static implicit operator AnswerOrCounterquestion (PendingQuestion counterquestion) + { + return new AnswerOrCounterquestion(counterquestion); + } + + public SerializerState Answer => _obj as SerializerState; + public PendingQuestion Counterquestion => _obj as PendingQuestion; + } +} diff --git a/Capnp.Net.Runtime/Rpc/BareProxy.cs b/Capnp.Net.Runtime/Rpc/BareProxy.cs new file mode 100644 index 0000000..9739e5a --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/BareProxy.cs @@ -0,0 +1,53 @@ +namespace Capnp.Rpc +{ + /// + /// Generic Proxy implementation which exposes the (usually protected) Call method. + /// + public class BareProxy: Proxy + { + /// + /// Wraps a capability implementation in a Proxy. + /// + /// Capability implementation + /// Proxy + /// is null. + /// No found on implemented interface(s). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Problem with instatiating the Skeleton (constructor threw exception). + /// Caller does not have permission to invoke the Skeleton constructor. + /// Problem with building the Skeleton type, or problem with loading some dependent class. + public static BareProxy FromImpl(object impl) + { + return new BareProxy(LocalCapability.Create(CapabilityReflection.CreateSkeleton(impl))); + } + + /// + /// Constructs an unbound instance. + /// + public BareProxy() + { + } + + /// + /// Constructs an instance and binds it to the given low-level capability. + /// + /// low-level capability + public BareProxy(ConsumedCapability cap): base(cap) + { + } + + /// + /// Requests a method call. + /// + /// Target interface ID + /// Target method ID + /// Method arguments + /// Whether it is a tail call + /// Answer promise + public IPromisedAnswer Call(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool tailCall) + { + return base.Call(interfaceId, methodId, args, tailCall); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/CapabilityReflection.cs b/Capnp.Net.Runtime/Rpc/CapabilityReflection.cs new file mode 100644 index 0000000..87f4441 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/CapabilityReflection.cs @@ -0,0 +1,285 @@ +using System; +using System.Diagnostics; +using System.Linq; +using System.Runtime.CompilerServices; + +namespace Capnp.Rpc +{ + /// + /// Provides functionality to construct Proxy and Skeleton instances from capability interfaces and objects implementing capability interfaces. + /// A capability interface is any .NET interface which is annotated with and . + /// There are some intricacies to consider that you usually don't need to care about, since all that stuff will be generated. + /// + public static class CapabilityReflection + { + interface IBrokenFactory + { + System.Exception Exception { get; } + } + + abstract class ProxyFactory + { + public abstract Proxy NewProxy(); + } + + class ProxyFactory: ProxyFactory where T: Proxy, new() + { + public override Proxy NewProxy() => new T(); + } + + class BrokenProxyFactory: ProxyFactory, IBrokenFactory + { + readonly System.Exception _exception; + + public BrokenProxyFactory(System.Exception exception) + { + _exception = exception; + } + + public System.Exception Exception => _exception; + + public override Proxy NewProxy() + { + throw _exception; + } + } + + abstract class SkeletonFactory + { + public abstract Skeleton NewSkeleton(); + } + + class SkeletonFactory: SkeletonFactory where T: Skeleton, new() + { + public override Skeleton NewSkeleton() => new T(); + } + + class BrokenSkeletonFactory: SkeletonFactory, IBrokenFactory + { + System.Exception _exception; + + public BrokenSkeletonFactory(System.Exception exception) + { + _exception = exception; + } + + public System.Exception Exception => _exception; + + public override Skeleton NewSkeleton() + { + throw _exception; + } + } + + class PolySkeletonFactory: SkeletonFactory + { + readonly SkeletonFactory[] _monoFactories; + + public PolySkeletonFactory(SkeletonFactory[] monoFactories) + { + _monoFactories = monoFactories; + } + + public override Skeleton NewSkeleton() + { + var poly = new PolySkeleton(); + foreach (var fac in _monoFactories) + { + poly.AddInterface(fac.NewSkeleton()); + } + return poly; + } + } + + static ConditionalWeakTable _proxyMap = + new ConditionalWeakTable(); + static ConditionalWeakTable _skeletonMap = + new ConditionalWeakTable(); + + static CapabilityReflection() + { + _proxyMap.Add(typeof(BareProxy), new ProxyFactory()); + } + + static SkeletonFactory CreateMonoSkeletonFactory(SkeletonAttribute attr, Type[] genericArguments) + { + var skeletonClass = attr.SkeletonClass; + if (genericArguments.Length > 0) + skeletonClass = skeletonClass.MakeGenericType(genericArguments); + + return (SkeletonFactory)Activator.CreateInstance( + typeof(SkeletonFactory<>) + .MakeGenericType(skeletonClass)); + } + + static SkeletonFactory GetSkeletonFactory(Type type) + { + return _skeletonMap.GetValue(type, _ => + { + try + { + var attrs = (from iface in _.GetInterfaces() + from attr in iface.GetCustomAttributes(typeof(SkeletonAttribute), true) + select (SkeletonAttribute)attr).ToArray(); + + if (attrs.Length == 0) + throw new InvalidCapabilityInterfaceException("No 'Skeleton' attribute defined, don't know how to create the skeleton"); + + Type[] genericArguments = type.GetGenericArguments(); + + if (attrs.Length == 1) + { + return CreateMonoSkeletonFactory(attrs[0], genericArguments); + } + else + { + var monoFactories = attrs.Select(a => CreateMonoSkeletonFactory(a, genericArguments)).ToArray(); + return new PolySkeletonFactory(monoFactories); + } + } + catch (System.Exception exception) + { + return new BrokenSkeletonFactory(exception); + } + }); + } + + /// + /// Creates a Skeleton for a given interface implementation. + /// + /// Interface implementation. Must implement at least one interface which is annotated with a . + /// The Skeleton + /// is null. + /// No found on implemented interface(s). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Problem with instatiating the Skeleton (constructor threw exception). + /// Caller does not have permission to invoke the Skeleton constructor. + /// Problem with building the Skeleton type, or problem with loading some dependent class. + public static Skeleton CreateSkeleton(object obj) + { + if (obj == null) + throw new ArgumentNullException(nameof(obj)); + + var factory = GetSkeletonFactory(obj.GetType()); + var skeleton = factory.NewSkeleton(); + skeleton.Bind(obj); + return skeleton; + } + + static ProxyFactory GetProxyFactory(Type type) + { + return _proxyMap.GetValue(type, _ => + { + try + { + var attrs = type + .GetCustomAttributes(typeof(ProxyAttribute), true) + .Cast() + .ToArray(); + + if (attrs.Length == 0) + throw new InvalidCapabilityInterfaceException("No 'Proxy' attribute defined, don't know how to create the proxy"); + + if (attrs.Length == 1) + { + Type proxyClass = attrs[0].ProxyClass; + Type[] genericArguments = type.GetGenericArguments(); + if (genericArguments.Length > 0) + proxyClass = proxyClass.MakeGenericType(proxyClass); + + return (ProxyFactory)Activator.CreateInstance( + typeof(ProxyFactory<>) + .MakeGenericType(proxyClass)); + } + else + { + throw new InvalidCapabilityInterfaceException("Multiple 'Proxy' attributes defined, don't know which one to take"); + } + } + catch (System.Exception exception) + { + return new BrokenProxyFactory(exception); + } + }); + } + + + /// + /// Validates that a given type qualifies as cpapbility interface, throws on failure. + /// + /// type to check + /// is null. + /// Given typ did not qualify as capability interface. + /// Message and probably InnterException give more details. + public static void ValidateCapabilityInterface(Type interfaceType) + { + if (interfaceType == null) + { + throw new ArgumentNullException(nameof(interfaceType)); + } + + var proxyFactory = GetProxyFactory(interfaceType); + + if (proxyFactory is IBrokenFactory brokenFactory) + { + throw new InvalidCapabilityInterfaceException( + "Given type did not qualify as capability interface, see inner exception.", + brokenFactory.Exception); + } + } + + /// + /// Checkes whether a given type qualifies as cpapbility interface./> on failure. + /// + /// type to check + /// true when is a capability interface + /// is null. + public static bool IsValidCapabilityInterface(Type interfaceType) + { + if (interfaceType == null) + { + throw new ArgumentNullException(nameof(interfaceType)); + } + + var proxyFactory = GetProxyFactory(interfaceType); + + return !(proxyFactory is IBrokenFactory); + } + + /// + /// Constructs a Proxy for given capability interface and wraps it around given low-level capability. + /// + /// Capability interface. Must be annotated with . + /// low-level capability + /// The Proxy instance which implements . + /// is null. + /// did not qualify as capability interface. + /// Mismatch between generic type arguments (if capability interface is generic). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Problem with instatiating the Proxy (constructor threw exception). + /// Caller does not have permission to invoke the Proxy constructor. + /// Problem with building the Proxy type, or problem with loading some dependent class. + public static Proxy CreateProxy(ConsumedCapability cap, + [System.Runtime.CompilerServices.CallerMemberName] string memberName = "", + [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "", + [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0) + { + var factory = GetProxyFactory(typeof(TInterface)); + var proxy = factory.NewProxy(); + proxy.Bind(cap); +#if DebugFinalizers + proxy.CreatorMemberName = memberName; + proxy.CreatorFilePath = sourceFilePath; + proxy.CreatorLineNumber = sourceLineNumber; + if (cap != null) + { + cap.CreatorFilePath = proxy.CreatorFilePath; + cap.CreatorLineNumber = proxy.CreatorLineNumber; + cap.CreatorMemberName = proxy.CreatorMemberName; + } +#endif + return proxy; + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/ConsumedCapability.cs b/Capnp.Net.Runtime/Rpc/ConsumedCapability.cs new file mode 100644 index 0000000..91863f0 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/ConsumedCapability.cs @@ -0,0 +1,33 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Base class for a low-level capability at consumer side. It is created by the . An application does not directly interact with it + /// (which is intentionally impossible, since the invocation method is internal), but instead uses a -derived wrapper. + /// + public abstract class ConsumedCapability + { + internal abstract IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool tailCall); + + /// + /// Request the RPC engine to release this capability from its import table, + /// which usually also means to remove it from the remote peer's export table. + /// + protected abstract void ReleaseRemotely(); + internal abstract void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer); + internal abstract void Freeze(out IRpcEndpoint boundEndpoint); + internal abstract void Unfreeze(); + + internal abstract void AddRef(); + internal abstract void Release(); + +#if DebugFinalizers + public string CreatorMemberName { get; set; } + public string CreatorFilePath { get; set; } + public int CreatorLineNumber { get; set; } +#endif + } +} diff --git a/Capnp.Net.Runtime/Rpc/IEndpoint.cs b/Capnp.Net.Runtime/Rpc/IEndpoint.cs new file mode 100644 index 0000000..5c695f2 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IEndpoint.cs @@ -0,0 +1,18 @@ +namespace Capnp.Rpc +{ + /// + /// A uni-directional endpoint, used in conjunction with the . + /// + public interface IEndpoint + { + /// + /// Transmit the given Cap'n Proto message over this endpoint. + /// + void Forward(WireFrame frame); + + /// + /// Close this endpoint. + /// + void Dismiss(); + } +} diff --git a/Capnp.Net.Runtime/Rpc/IMonoSkeleton.cs b/Capnp.Net.Runtime/Rpc/IMonoSkeleton.cs new file mode 100644 index 0000000..4c41061 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IMonoSkeleton.cs @@ -0,0 +1,13 @@ +namespace Capnp.Rpc +{ + /// + /// A mono skeleton (as opposed to ) is a skeleton which implements one particular RPC interface. + /// + public interface IMonoSkeleton: IProvidedCapability + { + /// + /// Interface ID of this skeleton. + /// + ulong InterfaceId { get; } + } +} diff --git a/Capnp.Net.Runtime/Rpc/IPromisedAnswer.cs b/Capnp.Net.Runtime/Rpc/IPromisedAnswer.cs new file mode 100644 index 0000000..aedcbe4 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IPromisedAnswer.cs @@ -0,0 +1,27 @@ +using System; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// A promised answer due to RPC. + /// + /// + /// Disposing the instance before the answer is available results in a best effort attempt to cancel + /// the ongoing call. + /// + public interface IPromisedAnswer: IDisposable + { + /// + /// Task which will complete when the RPC returns, delivering its result struct. + /// + Task WhenReturned { get; } + + /// + /// Creates a low-level capability for promise pipelining. + /// + /// Path to the desired capability inside the result struct. + /// Pipelined low-level capability + ConsumedCapability Access(MemberAccessPath access); + } +} diff --git a/Capnp.Net.Runtime/Rpc/IProvidedCapability.cs b/Capnp.Net.Runtime/Rpc/IProvidedCapability.cs new file mode 100644 index 0000000..3cbc384 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IProvidedCapability.cs @@ -0,0 +1,24 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + + /// + /// Low-level interface of a capability at provider side. + /// + public interface IProvidedCapability + { + /// + /// Calls an interface method of this capability. + /// + /// ID of interface to call + /// ID of method to call + /// Method arguments ("params struct") + /// Cancellation token, indicating when the call should cancelled. + /// A Task which will resolve to the call result ("result struct") + Task Invoke(ulong interfaceId, ushort methodId, + DeserializerState args, CancellationToken cancellationToken = default); + } +} diff --git a/Capnp.Net.Runtime/Rpc/IResolvingCapability.cs b/Capnp.Net.Runtime/Rpc/IResolvingCapability.cs new file mode 100644 index 0000000..e8b29da --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IResolvingCapability.cs @@ -0,0 +1,15 @@ +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// A promised capability. + /// + public interface IResolvingCapability + { + /// + /// Will eventually give the resolved capability. + /// + Task WhenResolved { get; } + } +} diff --git a/Capnp.Net.Runtime/Rpc/IRpcEndpoint.cs b/Capnp.Net.Runtime/Rpc/IRpcEndpoint.cs new file mode 100644 index 0000000..12a4aca --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/IRpcEndpoint.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + internal interface IRpcEndpoint + { + PendingQuestion BeginQuestion(ConsumedCapability target, SerializerState inParams); + void SendQuestion(SerializerState inParams, Payload.WRITER payload); + uint AllocateExport(Skeleton providedCapability, out bool first); + void RequestPostAction(Action postAction); + void Finish(uint questionId); + void ReleaseImport(uint importId); + void RemoveImport(uint importId); + void Resolve(uint preliminaryId, Skeleton preliminaryCap, Func resolvedCapGetter); + + Task RequestSenderLoopback(Action writer); + void DeleteQuestion(PendingQuestion question); + } +} diff --git a/Capnp.Net.Runtime/Rpc/Impatient.cs b/Capnp.Net.Runtime/Rpc/Impatient.cs new file mode 100644 index 0000000..c5b9e27 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/Impatient.cs @@ -0,0 +1,148 @@ +using System; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Provides support for promise pipelining. + /// + public static class Impatient + { + static readonly ConditionalWeakTable _taskTable = new ConditionalWeakTable(); + static readonly ThreadLocal _askingEndpoint = new ThreadLocal(); + + /// + /// Attaches a continuation to the given promise and registers the resulting task for pipelining. + /// + /// Task result type + /// The promise + /// The continuation + /// Task representing the future answer + /// or is null. + /// The pomise was already registered. + public static Task MakePipelineAware(IPromisedAnswer promise, Func then) + { + async Task AwaitAnswer() + { + return then(await promise.WhenReturned); + } + + var rtask = AwaitAnswer(); + _taskTable.Add(rtask, promise); + return rtask; + } + + /// + /// Looks up the underlying promise which was previously registered for the given Task using MakePipelineAware. + /// + /// + /// The underlying promise + /// is null. + /// The task was not registered using MakePipelineAware. + public static IPromisedAnswer GetAnswer(Task task) + { + if (!_taskTable.TryGetValue(task, out var answer)) + { + throw new ArgumentException("Unknown task"); + } + + return answer; + } + + internal static IPromisedAnswer TryGetAnswer(Task task) + { + _taskTable.TryGetValue(task, out var answer); + return answer; + } + + static async Task AwaitProxy(Task task) where T: class + { + var item = await task; + + switch (item) + { + case Proxy proxy: + return proxy; + + case null: + return null; + } + + var skel = Skeleton.GetOrCreateSkeleton(item, false); + var localCap = LocalCapability.Create(skel); + return CapabilityReflection.CreateProxy(localCap); + } + + /// + /// Returns a local "lazy" proxy for a given Task. + /// This is not real promise pipelining and will probably be removed. + /// + /// Capability interface type + /// The task + /// A proxy for the given task. + /// is null. + /// did not + /// quality as capability interface. + public static TInterface PseudoEager(this Task task, + [System.Runtime.CompilerServices.CallerMemberName] string memberName = "", + [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "", + [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0) + where TInterface : class + { + var lazyCap = new LazyCapability(AwaitProxy(task)); + return CapabilityReflection.CreateProxy(lazyCap, memberName, sourceFilePath, sourceLineNumber) as TInterface; + } + + internal static IRpcEndpoint AskingEndpoint + { + get => _askingEndpoint.Value; + set { _askingEndpoint.Value = value; } + } + + public static async Task MaybeTailCall(Task task, Func func) + { + if (TryGetAnswer(task) is PendingQuestion pendingQuestion && + pendingQuestion.RpcEndpoint == AskingEndpoint) + { + pendingQuestion.IsTailCall = true; + return pendingQuestion; + } + else + { + return func(await task); + } + } + + public static Task MaybeTailCall(Task<(T1, T2)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2)); + } + + public static Task MaybeTailCall(Task<(T1, T2, T3)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2, t.Item3)); + } + + public static Task MaybeTailCall(Task<(T1, T2, T3, T4)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2, t.Item3, t.Item4)); + } + + public static Task MaybeTailCall(Task<(T1, T2, T3, T4, T5)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5)); + } + + public static Task MaybeTailCall(Task<(T1, T2, T3, T4, T5, T6)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6)); + } + + public static Task MaybeTailCall(Task<(T1, T2, T3, T4, T5, T6, T7)> task, Func func) + { + return MaybeTailCall(task, (ValueTuple t) => func(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7)); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/ImportedCapability.cs b/Capnp.Net.Runtime/Rpc/ImportedCapability.cs new file mode 100644 index 0000000..9773e34 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/ImportedCapability.cs @@ -0,0 +1,55 @@ +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Low-level capability which as imported from a remote peer. + /// + class ImportedCapability : RemoteCapability + { + readonly uint _remoteId; + + public ImportedCapability(IRpcEndpoint ep, uint remoteId): base(ep) + { + _remoteId = remoteId; + } + + protected override void ReleaseRemotely() + { + _ep.ReleaseImport(_remoteId); + _ep.RemoveImport(_remoteId); + } + + protected override Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId) + { + var call = base.SetupMessage(args, interfaceId, methodId); + call.Target.which = MessageTarget.WHICH.ImportedCap; + call.Target.ImportedCap = _remoteId; + + return call; + } + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + boundEndpoint = _ep; + } + + internal override void Unfreeze() + { + } + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER capDesc) + { + if (endpoint == _ep) + { + capDesc.which = CapDescriptor.WHICH.ReceiverHosted; + capDesc.ReceiverHosted = _remoteId; + } + else + { + capDesc.which = CapDescriptor.WHICH.SenderHosted; + capDesc.SenderHosted = endpoint.AllocateExport(Vine.Create(this), out var _); + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/InvalidCapabilityInterfaceException.cs b/Capnp.Net.Runtime/Rpc/InvalidCapabilityInterfaceException.cs new file mode 100644 index 0000000..7df17ca --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/InvalidCapabilityInterfaceException.cs @@ -0,0 +1,18 @@ +namespace Capnp.Rpc +{ + /// + /// Will be thrown if a type did not qualify as capability interface. + /// In order to qualify the type must be properly annotated with a and . + /// See descriptions of these attributes for further details. + /// + public class InvalidCapabilityInterfaceException : System.Exception + { + public InvalidCapabilityInterfaceException(string message) : base(message) + { + } + + public InvalidCapabilityInterfaceException(string message, System.Exception innerException) : base(message, innerException) + { + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/LazyCapability.cs b/Capnp.Net.Runtime/Rpc/LazyCapability.cs new file mode 100644 index 0000000..b90c60a --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/LazyCapability.cs @@ -0,0 +1,110 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class LazyCapability : RefCountingCapability, IResolvingCapability + { + public static LazyCapability CreateBrokenCap(string message) + { + var cap = new LazyCapability(Task.FromException(new RpcException(message))); + cap.AddRef(); // Instance shall be persistent + return cap; + } + + public static LazyCapability CreateCanceledCap(CancellationToken token) + { + var cap = new LazyCapability(Task.FromCanceled(token)); + cap.AddRef(); // Instance shall be persistent + return cap; + } + + public static LazyCapability Null { get; } = CreateBrokenCap("Null capability"); + + public LazyCapability(Task capabilityTask) + { + WhenResolved = capabilityTask; + } + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + if (WhenResolved.IsCompleted) + { + try + { + WhenResolved.Result.Freeze(out boundEndpoint); + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + } + else + { + boundEndpoint = null; + } + } + + internal override void Unfreeze() + { + } + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + { + if (WhenResolved.IsCompletedSuccessfully) + { + WhenResolved.Result.Export(endpoint, writer); + } + else + { + this.ExportAsSenderPromise(endpoint, writer); + } + } + + async void DisposeProxyWhenResolved() + { + try + { + var cap = await WhenResolved; + if (cap != null) cap.Dispose(); + } + catch + { + } + } + + protected override void ReleaseRemotely() + { + DisposeProxyWhenResolved(); + } + + public Task WhenResolved { get; } + + async Task CallImpl(ulong interfaceId, ushort methodId, + DynamicSerializerState args, bool pipeline, + CancellationToken cancellationToken) + { + var cap = await WhenResolved; + + cancellationToken.ThrowIfCancellationRequested(); + + if (cap == null) + throw new RpcException("Broken capability"); + + var call = cap.Call(interfaceId, methodId, args, pipeline); + var whenReturned = call.WhenReturned; + + using (var registration = cancellationToken.Register(call.Dispose)) + { + return await whenReturned; + } + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + var cts = new CancellationTokenSource(); + return new LocalAnswer(cts, CallImpl(interfaceId, methodId, args, pipeline, cts.Token)); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/LocalAnswer.cs b/Capnp.Net.Runtime/Rpc/LocalAnswer.cs new file mode 100644 index 0000000..80b5ac0 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/LocalAnswer.cs @@ -0,0 +1,52 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class LocalAnswer : IPromisedAnswer + { + readonly CancellationTokenSource _cts; + + public LocalAnswer(CancellationTokenSource cts, Task call) + { + _cts = cts ?? throw new ArgumentNullException(nameof(cts)); + WhenReturned = call ?? throw new ArgumentNullException(nameof(call)); + + CleanupAfterReturn(); + } + + async void CleanupAfterReturn() + { + try + { + await WhenReturned; + } + catch + { + } + finally + { + _cts.Dispose(); + } + } + + public Task WhenReturned { get; } + + public ConsumedCapability Access(MemberAccessPath access) + { + return new LocalAnswerCapability(WhenReturned, access); + } + + public void Dispose() + { + try + { + _cts.Cancel(); + } + catch (ObjectDisposedException) + { + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/LocalAnswerCapability.cs b/Capnp.Net.Runtime/Rpc/LocalAnswerCapability.cs new file mode 100644 index 0000000..b4b5e2b --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/LocalAnswerCapability.cs @@ -0,0 +1,91 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class LocalAnswerCapability : RefCountingCapability, IResolvingCapability + { + readonly Task _answer; + readonly MemberAccessPath _access; + + public LocalAnswerCapability(Task answer, MemberAccessPath access) + { + _answer = answer; + _access = access; + } + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + boundEndpoint = null; + } + + internal override void Unfreeze() + { + } + + async Task AwaitResolved() + { + var state = await _answer; + return new Proxy(_access.Eval(state)); + } + + public Task WhenResolved => AwaitResolved(); + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + { + if (_answer.IsCompleted) + { + DeserializerState result; + try + { + result = _answer.Result; + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + + using (var proxy = new Proxy(_access.Eval(result))) + { + proxy.Export(endpoint, writer); + } + } + else + { + this.ExportAsSenderPromise(endpoint, writer); + } + } + + async Task CallImpl(ulong interfaceId, ushort methodId, + DynamicSerializerState args, bool pipeline, + CancellationToken cancellationToken) + { + var cap = await AwaitResolved(); + + cancellationToken.ThrowIfCancellationRequested(); + + if (cap == null) + throw new RpcException("Broken capability"); + + var call = cap.Call(interfaceId, methodId, args, pipeline); + var whenReturned = call.WhenReturned; + + using (var registration = cancellationToken.Register(() => call.Dispose())) + { + return await whenReturned; + } + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + var cts = new CancellationTokenSource(); + return new LocalAnswer(cts, CallImpl(interfaceId, methodId, args, pipeline, cts.Token)); + } + + protected override void ReleaseRemotely() + { + this.DisposeWhenResolved(); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/LocalCapability.cs b/Capnp.Net.Runtime/Rpc/LocalCapability.cs new file mode 100644 index 0000000..60782fc --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/LocalCapability.cs @@ -0,0 +1,71 @@ +using System; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class LocalCapability : ConsumedCapability + { + static readonly ConditionalWeakTable _localCaps = + new ConditionalWeakTable(); + + public static ConsumedCapability Create(Skeleton skeleton) + { + if (skeleton is Vine vine) + return vine.Proxy.ConsumedCap; + else + return _localCaps.GetValue(skeleton, _ => new LocalCapability(_)); + } + + static async Task AwaitAnswer(Task call) + { + var aorcq = await call; + return aorcq.Answer ?? await aorcq.Counterquestion.WhenReturned; + } + + public Skeleton ProvidedCap { get; } + + LocalCapability(Skeleton providedCap) + { + ProvidedCap = providedCap ?? throw new ArgumentNullException(nameof(providedCap)); + } + + internal override void AddRef() + { + ProvidedCap.Claim(); + } + + internal override void Release() + { + ProvidedCap.Relinquish(); + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + var cts = new CancellationTokenSource(); + var call = ProvidedCap.Invoke(interfaceId, methodId, args, cts.Token); + return new LocalAnswer(cts, AwaitAnswer(call)); + } + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER capDesc) + { + capDesc.which = CapDescriptor.WHICH.SenderHosted; + capDesc.SenderHosted = endpoint.AllocateExport(ProvidedCap, out bool _); + } + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + boundEndpoint = null; + } + + internal override void Unfreeze() + { + } + + protected override void ReleaseRemotely() + { + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/MemberAccessPath.cs b/Capnp.Net.Runtime/Rpc/MemberAccessPath.cs new file mode 100644 index 0000000..00ca7b5 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/MemberAccessPath.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Capnp.Rpc +{ + /// + /// A path from an outer Cap'n Proto struct to an inner (probably deeply nested) struct member. + /// + public class MemberAccessPath + { + public static readonly MemberAccessPath BootstrapAccess = new MemberAccessPath(new List()); + + public static MemberAccessPath Deserialize(PromisedAnswer.READER promisedAnswer) + { + var ops = new MemberAccess[promisedAnswer.Transform.Count]; + + int i = 0; + foreach (var op in promisedAnswer.Transform) + { + ops[i++] = MemberAccess.Deserialize(op); + } + + return new MemberAccessPath(ops); + } + + /// + /// Constructs a path from qualifiers. + /// + /// List of member access elements + public MemberAccessPath(IReadOnlyList path) + { + Path = path ?? throw new ArgumentNullException(nameof(path)); + } + + /// + /// Constructs a path from Cap'n Proto struct member offsets. + /// + /// Member offsets + public MemberAccessPath(params uint[] offsets) + { + if (offsets == null) + throw new ArgumentNullException(nameof(offsets)); + + Path = offsets.Select(i => new StructMemberAccess(checked((ushort)i))).ToArray(); + } + + /// + /// Base class of an individual member access. + /// + /// + /// This might appear a bit of overengineering, since the only specialization is the . + /// But there might be further specializations in the future, the most obvious one being an "ArrayElementAccess". + /// Now we already have a suitable design pattern, mainly to show the abstract concept behind a member access path. + /// + public abstract class MemberAccess + { + public static MemberAccess Deserialize(PromisedAnswer.Op.READER op) + { + switch (op.which) + { + case PromisedAnswer.Op.WHICH.GetPointerField: + return new StructMemberAccess(op.GetPointerField); + + default: + throw new NotSupportedException(); + } + } + + /// + /// Serializes this instance to a . + /// + /// Serialization target + public abstract void Serialize(PromisedAnswer.Op.WRITER op); + + /// + /// Evaluates the member access on a given struct instance. + /// + /// Input struct instance + /// Member value or object + public abstract DeserializerState Eval(DeserializerState state); + } + + /// + /// The one and only member access which is currently supported: Member of a struct. + /// + public class StructMemberAccess: MemberAccess + { + /// + /// Constructs an instance for given struct member offset. + /// + /// The Cap'n Proto struct member offset + public StructMemberAccess(ushort offset) + { + Offset = offset; + } + + /// + /// The Cap'n Proto struct member offset + /// + public ushort Offset { get; } + + /// + /// Serializes this instance to a . + /// + /// Serialization target + public override void Serialize(PromisedAnswer.Op.WRITER op) + { + op.which = PromisedAnswer.Op.WHICH.GetPointerField; + op.GetPointerField = Offset; + } + + /// + /// Evaluates the member access on a given struct instance. + /// + /// Input struct instance + /// Member value or object + public override DeserializerState Eval(DeserializerState state) + { + if (state.Kind == ObjectKind.Nil) + { + return default(DeserializerState); + } + + if (state.Kind != ObjectKind.Struct) + { + throw new ArgumentException("Expected a struct"); + } + + return state.StructReadPointer(Offset); + } + } + + /// + /// The access path is a composition of individual member accesses. + /// + public IReadOnlyList Path { get; } + + /// + /// Serializes this path th a . + /// + /// The serialization target + public void Serialize(PromisedAnswer.WRITER promisedAnswer) + { + promisedAnswer.Transform.Init(Path.Count); + + for (int i = 0; i < Path.Count; i++) + { + Path[i].Serialize(promisedAnswer.Transform[i]); + } + } + + /// + /// Evaluates the path on a given object. + /// + /// The object (usually "params struct") on which to evaluate this path. + /// Resulting low-level capability + /// Evaluation of this path did not give a capability + public ConsumedCapability Eval(DeserializerState rpcState) + { + var cur = rpcState; + + foreach (var op in Path) + { + cur = op.Eval(cur); + } + + switch (cur.Kind) + { + case ObjectKind.Nil: + return null; + + case ObjectKind.Capability: + return rpcState.Caps[(int)cur.CapabilityIndex]; + + default: + throw new DeserializationException("Access path did not result in a capability"); + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/PendingAnswer.cs b/Capnp.Net.Runtime/Rpc/PendingAnswer.cs new file mode 100644 index 0000000..2ef55af --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/PendingAnswer.cs @@ -0,0 +1,310 @@ +using System; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class PendingAnswer: IDisposable + { + readonly object _reentrancyBlocker = new object(); + readonly CancellationTokenSource _cts; + readonly TaskCompletionSource _whenCanceled; + Task _callTask; + Task _initialTask; + Task _chainedTask; + bool _disposed; + + public PendingAnswer(Task callTask, CancellationTokenSource cts) + { + _cts = cts; + _callTask = callTask ?? throw new ArgumentNullException(nameof(callTask)); + _whenCanceled = new TaskCompletionSource(); + } + + public void Cancel() + { + _cts?.Cancel(); + _whenCanceled.SetResult(0); + } + + async Task InitialAwaitWhenReady() + { + var which = await Task.WhenAny(_callTask, _whenCanceled.Task); + + if (which != _callTask) + { + throw new TaskCanceledException(); + } + } + + //public Task WhenReady => ChainedAwaitWhenReady(); + + //public void Pipeline(PromisedAnswer.READER rd, Action action, Action error) + //{ + // lock (_reentrancyBlocker) + // { + // if (_chainedTask == null) + // { + // _chainedTask = InitialAwaitWhenReady(); + // } + + // _chainedTask = _chainedTask.ContinueWith(t => + // { + // bool rethrow = true; + + // try + // { + // t.Wait(); + // rethrow = false; + // EvaluateProxyAndCallContinuation(rd, action); + // } + // catch (AggregateException aggregateException) + // { + // var innerException = aggregateException.InnerException; + + // error(innerException); + + // if (rethrow) throw innerException; + // } + // }, + // TaskContinuationOptions.ExecuteSynchronously); + // } + //} + + async Task AwaitChainedTask(Task chainedTask, Func, Task> func) + { + try + { + await chainedTask; + } + catch (System.Exception exception) + { + await func(Task.FromException(exception)); + throw; + } + + await func(_callTask); + } + + static async Task AwaitSeq(Task task1, Task task2) + { + await task1; + await task2; + } + + public void Chain(bool strictSync, Func, Task> func) + { + + lock (_reentrancyBlocker) + { + if (_disposed) + { + throw new ObjectDisposedException(nameof(PendingAnswer)); + } + + if (_initialTask == null) + { + _initialTask = InitialAwaitWhenReady(); + } + + Task followUpTask; + + if (strictSync) + { + followUpTask = AwaitChainedTask(_chainedTask ?? _initialTask, func); + } + else + { + followUpTask = AwaitChainedTask(_initialTask, func); + } + + if (_chainedTask != null) + { + _chainedTask = AwaitSeq(_chainedTask, followUpTask); + } + else + { + _chainedTask = followUpTask; + } + } + } + + public void Chain(bool strictSync, PromisedAnswer.READER rd, Func, Task> func) + { + Chain(strictSync, async t => + { + async Task EvaluateProxy() + { + var aorcq = await t; + + if (aorcq.Answer != null) + { + DeserializerState cur = aorcq.Answer; + + foreach (var op in rd.Transform) + { + switch (op.which) + { + case PromisedAnswer.Op.WHICH.GetPointerField: + try + { + cur = cur.StructReadPointer(op.GetPointerField); + } + catch (System.Exception) + { + throw new ArgumentOutOfRangeException("Illegal pointer field in transformation operation"); + } + break; + + case PromisedAnswer.Op.WHICH.Noop: + break; + + default: + throw new ArgumentOutOfRangeException("Unknown transformation operation"); + } + } + + Proxy proxy; + + switch (cur.Kind) + { + case ObjectKind.Capability: + try + { + var cap = aorcq.Answer.Caps[(int)cur.CapabilityIndex]; + proxy = new Proxy(cap ?? LazyCapability.Null); + } + catch (ArgumentOutOfRangeException) + { + throw new ArgumentOutOfRangeException("Bad capability table in internal answer - internal error?"); + } + return proxy; + + default: + throw new ArgumentOutOfRangeException("Transformation did not result in a capability"); + } + } + else + { + var path = MemberAccessPath.Deserialize(rd); + var cap = new RemoteAnswerCapability(aorcq.Counterquestion, path); + return new Proxy(cap); + } + } + + await func(EvaluateProxy()); + }); + } + + //Task ChainedAwaitWhenReady() + //{ + // async Task AwaitChainedTask(Task chainedTask) + // { + // await chainedTask; + // return _callTask.Result; + // } + + // Task resultTask; + + // lock (_reentrancyBlocker) + // { + // if (_chainedTask == null) + // { + // _chainedTask = InitialAwaitWhenReady(); + // } + + // resultTask = AwaitChainedTask(_chainedTask); + // _chainedTask = resultTask; + // } + + // return resultTask; + //} + + public CancellationToken CancellationToken => _cts?.Token ?? CancellationToken.None; + + //void EvaluateProxyAndCallContinuation(PromisedAnswer.READER rd, Action action) + //{ + // var result = _callTask.Result; + + // DeserializerState cur = result; + + // foreach (var op in rd.Transform) + // { + // switch (op.which) + // { + // case PromisedAnswer.Op.WHICH.GetPointerField: + // try + // { + // cur = cur.StructReadPointer(op.GetPointerField); + // } + // catch (System.Exception) + // { + // throw new ArgumentOutOfRangeException("Illegal pointer field in transformation operation"); + // } + // break; + + // case PromisedAnswer.Op.WHICH.Noop: + // break; + + // default: + // throw new ArgumentOutOfRangeException("Unknown transformation operation"); + // } + // } + + // Proxy proxy; + + // switch (cur.Kind) + // { + // case ObjectKind.Capability: + // try + // { + // var cap = result.MsgBuilder.Caps[(int)cur.CapabilityIndex]; + // proxy = new Proxy(cap ?? LazyCapability.Null); + // } + // catch (ArgumentOutOfRangeException) + // { + // throw new ArgumentOutOfRangeException("Bad capability table in internal answer - internal error?"); + // } + // action(proxy); + // break; + + // default: + // throw new ArgumentOutOfRangeException("Transformation did not result in a capability"); + // } + //} + + public async void Dispose() + { + if (_cts != null) + { + Task chainedTask; + + lock (_reentrancyBlocker) + { + if (_disposed) + { + return; + } + chainedTask = _chainedTask; + _disposed = true; + } + + if (chainedTask != null) + { + try + { + await chainedTask; + } + catch + { + } + finally + { + _cts.Dispose(); + } + } + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/PendingQuestion.cs b/Capnp.Net.Runtime/Rpc/PendingQuestion.cs new file mode 100644 index 0000000..68623e8 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/PendingQuestion.cs @@ -0,0 +1,311 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// A promised answer due to RPC. + /// + /// + /// Disposing the instance before the answer is available results in a best effort attempt to cancel + /// the ongoing call. + /// + public sealed class PendingQuestion: IPromisedAnswer + { + [Flags] + public enum State + { + None = 0, + TailCall = 1, + Sent = 2, + Returned = 4, + FinishRequested = 8, + Disposed = 16, + Finalized = 32 + } + + readonly TaskCompletionSource _tcs = new TaskCompletionSource(); + readonly uint _questionId; + ConsumedCapability _target; + SerializerState _inParams; + int _inhibitFinishCounter; + + internal PendingQuestion(IRpcEndpoint ep, uint id, ConsumedCapability target, SerializerState inParams) + { + RpcEndpoint = ep ?? throw new ArgumentNullException(nameof(ep)); + _questionId = id; + _target = target; + _inParams = inParams; + StateFlags = inParams == null ? State.Sent : State.None; + + if (inParams != null) + { + foreach (var cap in inParams.Caps) + { + cap?.AddRef(); + } + } + + if (target != null) + { + target.AddRef(); + } + } + + internal IRpcEndpoint RpcEndpoint { get; } + internal object ReentrancyBlocker { get; } = new object(); + internal uint QuestionId => _questionId; + internal State StateFlags { get; private set; } + public Task WhenReturned => _tcs.Task; + internal bool IsTailCall + { + get => StateFlags.HasFlag(State.TailCall); + set + { + if (value) + StateFlags |= State.TailCall; + else + StateFlags &= ~State.TailCall; + } + } + internal bool IsReturned => StateFlags.HasFlag(State.Returned); + + internal void DisallowFinish() + { + ++_inhibitFinishCounter; + } + + internal void AllowFinish() + { + --_inhibitFinishCounter; + AutoFinish(); + } + + const string ReturnDespiteTailCallMessage = "Peer sent actual results despite the question was sent as tail call. This was not expected and is a protocol error."; + + internal void OnReturn(DeserializerState results) + { + lock (ReentrancyBlocker) + { + SetReturned(); + } + + if (StateFlags.HasFlag(State.TailCall)) + { + _tcs.TrySetException(new RpcException(ReturnDespiteTailCallMessage)); + } + else + { + _tcs.TrySetResult(results); + } + } + + internal void OnTailCallReturn() + { + lock (ReentrancyBlocker) + { + SetReturned(); + } + + if (!StateFlags.HasFlag(State.TailCall)) + { + _tcs.TrySetException(new RpcException("Peer sent the results of this questions somewhere else. This was not expected and is a protocol error.")); + } + else + { + _tcs.TrySetResult(default); + } + } + + internal void OnException(Exception.READER exception) + { + lock (ReentrancyBlocker) + { + SetReturned(); + } + + _tcs.TrySetException(new RpcException(exception.Reason)); + } + + internal void OnException(System.Exception exception) + { + lock (ReentrancyBlocker) + { + SetReturned(); + } + + _tcs.TrySetException(exception); + } + + internal void OnCanceled() + { + lock (ReentrancyBlocker) + { + SetReturned(); + } + + _tcs.TrySetCanceled(); + } + + void DeleteMyQuestion() + { + RpcEndpoint.DeleteQuestion(this); + } + + internal void RequestFinish() + { + RpcEndpoint.Finish(_questionId); + } + + void AutoFinish() + { + if (StateFlags.HasFlag(State.FinishRequested)) + { + return; + } + + if ((_inhibitFinishCounter == 0 && StateFlags.HasFlag(State.Returned) && !StateFlags.HasFlag(State.TailCall)) + || StateFlags.HasFlag(State.Disposed)) + { + StateFlags |= State.FinishRequested; + + RequestFinish(); + } + } + + void SetReturned() + { + if (StateFlags.HasFlag(State.Returned)) + { + throw new InvalidOperationException("Return state already set"); + } + + StateFlags |= State.Returned; + + AutoFinish(); + DeleteMyQuestion(); + } + + public ConsumedCapability Access(MemberAccessPath access) + { + lock (ReentrancyBlocker) + { + if ( StateFlags.HasFlag(State.Returned) && + !StateFlags.HasFlag(State.TailCall)) + { + try + { + return access.Eval(WhenReturned.Result); + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + } + else + { + return new RemoteAnswerCapability(this, access); + } + } + } + + static void ReleaseCaps(ConsumedCapability target, SerializerState inParams) + { + if (inParams != null) + { + foreach (var cap in inParams.Caps) + { + cap?.Release(); + } + } + + if (target != null) + { + target.Release(); + } + } + + internal void Send() + { + SerializerState inParams; + ConsumedCapability target; + + lock (ReentrancyBlocker) + { + Debug.Assert(!StateFlags.HasFlag(State.Sent)); + + inParams = _inParams; + _inParams = null; + target = _target; + _target = null; + StateFlags |= State.Sent; + } + + var msg = (Message.WRITER)inParams.MsgBuilder.Root; + Debug.Assert(msg.Call.Target.which != MessageTarget.WHICH.undefined); + var call = msg.Call; + call.QuestionId = QuestionId; + call.SendResultsTo.which = IsTailCall ? + Call.sendResultsTo.WHICH.Yourself : + Call.sendResultsTo.WHICH.Caller; + + try + { + RpcEndpoint.SendQuestion(inParams, call.Params); + } + catch (System.Exception exception) + { + OnException(exception); + } + + ReleaseCaps(target, inParams); + } + + #region IDisposable Support + + void Dispose(bool disposing) + { + SerializerState inParams; + ConsumedCapability target; + + lock (ReentrancyBlocker) + { + inParams = _inParams; + _inParams = null; + target = _target; + _target = null; + + if (disposing) + { + if (!StateFlags.HasFlag(State.Disposed)) + { + StateFlags |= State.Disposed; + + AutoFinish(); + } + } + else + { + StateFlags |= State.Finalized; + } + } + + ReleaseCaps(target, inParams); + } + + ~PendingQuestion() + { + Dispose(false); + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + #endregion + } +} diff --git a/Capnp.Net.Runtime/Rpc/PolySkeleton.cs b/Capnp.Net.Runtime/Rpc/PolySkeleton.cs new file mode 100644 index 0000000..a159f8e --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/PolySkeleton.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Combines multiple skeletons to represent objects which implement multiple interfaces. + /// + public class PolySkeleton: Skeleton + { + readonly Dictionary _ifmap = new Dictionary(); + + /// + /// Adds a skeleton to this instance. + /// + /// Interface ID + /// Skeleton to add + /// is null. + /// A skeleton with was already added. + public void AddInterface(ulong interfaceId, Skeleton skeleton) + { + if (skeleton == null) + throw new ArgumentNullException(nameof(skeleton)); + + skeleton.Claim(); + _ifmap.Add(interfaceId, skeleton); + } + + internal void AddInterface(Skeleton skeleton) + { + AddInterface(((IMonoSkeleton)skeleton).InterfaceId, skeleton); + } + + /// + /// Calls an interface method of this capability. + /// + /// ID of interface to call + /// ID of method to call + /// Method arguments ("params struct") + /// Cancellation token, indicating when the call should cancelled. + /// A Task which will resolve to the call result + public override Task Invoke(ulong interfaceId, ushort methodId, DeserializerState args, CancellationToken cancellationToken = default) + { + if (_ifmap.TryGetValue(interfaceId, out var skel)) + return skel.Invoke(interfaceId, methodId, args, cancellationToken); + + throw new NotImplementedException("Unknown interface id"); + } + + /// + /// Dispose pattern implementation + /// + protected override void Dispose(bool disposing) + { + foreach (var cap in _ifmap.Values) + { + cap.Relinquish(); + } + + base.Dispose(disposing); + } + + internal override void Bind(object impl) + { + foreach (Skeleton skel in _ifmap.Values) + { + skel.Bind(impl); + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/PromisedCapability.cs b/Capnp.Net.Runtime/Rpc/PromisedCapability.cs new file mode 100644 index 0000000..6a7ad73 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/PromisedCapability.cs @@ -0,0 +1,259 @@ +using System; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class PromisedCapability : RemoteResolvingCapability + { + readonly uint _remoteId; + readonly object _reentrancyBlocker = new object(); + readonly TaskCompletionSource _resolvedCap = new TaskCompletionSource(); + bool _released; + + public PromisedCapability(IRpcEndpoint ep, uint remoteId): base(ep) + { + _remoteId = remoteId; + } + + public override Task WhenResolved => _resolvedCap.Task; + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + lock (_reentrancyBlocker) + { + if (_resolvedCap.Task.IsCompleted && _pendingCallsOnPromise == 0) + { + try + { + _resolvedCap.Task.Result.Freeze(out boundEndpoint); + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + } + else + { + Debug.Assert(!_released); + ++_pendingCallsOnPromise; + + boundEndpoint = _ep; + } + } + } + + internal override void Unfreeze() + { + bool release = false; + + lock (_reentrancyBlocker) + { + if (_pendingCallsOnPromise == 0) + { + _resolvedCap.Task.Result.Unfreeze(); + } + else + { + Debug.Assert(_pendingCallsOnPromise > 0); + Debug.Assert(!_released); + + if (--_pendingCallsOnPromise == 0 && _resolvedCap.Task.IsCompleted) + { + release = true; + _released = true; + } + } + } + + if (release) + { + _ep.ReleaseImport(_remoteId); + } + } + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + { + lock (_reentrancyBlocker) + { + if (_resolvedCap.Task.IsCompletedSuccessfully) + { + _resolvedCap.Task.Result.Export(endpoint, writer); + } + else + { + if (_ep == endpoint) + { + writer.which = CapDescriptor.WHICH.ReceiverHosted; + writer.ReceiverHosted = _remoteId; + + Debug.Assert(!_released); + ++_pendingCallsOnPromise; + + _ep.RequestPostAction(() => + { + bool release = false; + + lock (_reentrancyBlocker) + { + if (--_pendingCallsOnPromise == 0 && _resolvedCap.Task.IsCompleted) + { + _released = true; + release = true; + } + } + + if (release) + { + _ep.ReleaseImport(_remoteId); + } + }); + } + else + { + this.ExportAsSenderPromise(endpoint, writer); + } + } + } + } + + async void TrackCall(Task call) + { + try + { + await call; + } + catch + { + } + finally + { + bool release = false; + + lock (_reentrancyBlocker) + { + if (--_pendingCallsOnPromise == 0 && _resolvedCap.Task.IsCompleted) + { + release = true; + _released = true; + } + } + + if (release) + { + _ep.ReleaseImport(_remoteId); + } + } + } + + protected override Proxy ResolvedCap + { + get + { + try + { + return _resolvedCap.Task.IsCompleted ? _resolvedCap.Task.Result : null; + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + } + } + + protected override void GetMessageTarget(MessageTarget.WRITER wr) + { + wr.which = MessageTarget.WHICH.ImportedCap; + wr.ImportedCap = _remoteId; + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + lock (_reentrancyBlocker) + { + if (_resolvedCap.Task.IsCompleted) + { + return CallOnResolution(interfaceId, methodId, args, pipeline); + } + else + { + Debug.Assert(!_released); + ++_pendingCallsOnPromise; + } + } + + var promisedAnswer = base.DoCall(interfaceId, methodId, args, pipeline); + TrackCall(promisedAnswer.WhenReturned); + return promisedAnswer; + } + + public void ResolveTo(ConsumedCapability resolvedCap) + { + bool release = false; + + lock (_reentrancyBlocker) + { + _resolvedCap.SetResult(new Proxy(resolvedCap)); + + if (_pendingCallsOnPromise == 0) + { + release = true; + _released = true; + } + } + + if (release) + { + _ep.ReleaseImport(_remoteId); + } + } + + public void Break(string message) + { + bool release = false; + + lock (_reentrancyBlocker) + { +#if false + _resolvedCap.SetException(new RpcException(message)); +#else + _resolvedCap.SetResult(new Proxy(LazyCapability.CreateBrokenCap(message))); +#endif + + if (_pendingCallsOnPromise == 0) + { + release = true; + _released = true; + } + } + + if (release) + { + _ep.ReleaseImport(_remoteId); + } + } + + protected override void ReleaseRemotely() + { + if (!_released) + { + _ep.ReleaseImport(_remoteId); + } + + _ep.RemoveImport(_remoteId); + + this.DisposeWhenResolved(); + } + + protected override Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId) + { + var call = base.SetupMessage(args, interfaceId, methodId); + + call.Target.which = MessageTarget.WHICH.ImportedCap; + call.Target.ImportedCap = _remoteId; + + return call; + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/Proxy.cs b/Capnp.Net.Runtime/Rpc/Proxy.cs new file mode 100644 index 0000000..9e4380c --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/Proxy.cs @@ -0,0 +1,213 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Application-level wrapper for consumer-side capabilities. + /// The code generator will produce a Proxy specialization for each capability interface. + /// + public class Proxy : IDisposable, IResolvingCapability + { +#if DebugFinalizers + ILogger Logger { get; } = Logging.CreateLogger(); +#endif + + bool _disposedValue = false; + + /// + /// Will eventually give the resolved capability, if this is a promised capability. + /// + public Task WhenResolved + { + get + { + if (ConsumedCap is IResolvingCapability resolving) + { + return resolving.WhenResolved; + } + else + { + return Task.FromResult(this); + } + } + } + + protected internal ConsumedCapability ConsumedCap { get; private set; } + + /// + /// Whether is this a broken capability. + /// + public bool IsNull => ConsumedCap == null; + + static async void DisposeCtrWhenReturned(CancellationTokenRegistration ctr, IPromisedAnswer answer) + { + try + { + await answer.WhenReturned; + } + catch + { + } + finally + { + ctr.Dispose(); + } + } + + /// + /// Calls a method of this capability. + /// + /// Interface ID to call + /// Method ID to call + /// Method arguments ("param struct") + /// Whether it is a tail call + /// For cancelling an ongoing method call + /// An answer promise + /// This instance was disposed, or transport-layer stream was disposed. + /// Capability is broken. + /// An I/O error occurs. + protected internal IPromisedAnswer Call(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool tailCall, CancellationToken cancellationToken = default) + { + if (_disposedValue) + throw new ObjectDisposedException(nameof(Proxy)); + + if (ConsumedCap == null) + throw new InvalidOperationException("Cannot call null capability"); + + var answer = ConsumedCap.DoCall(interfaceId, methodId, args, tailCall); + + if (cancellationToken.CanBeCanceled) + { + DisposeCtrWhenReturned(cancellationToken.Register(answer.Dispose), answer); + } + + return answer; + } + + public Proxy() + { + } + + internal Proxy(ConsumedCapability cap) + { + Bind(cap); + } + + internal void Bind(ConsumedCapability cap) + { + if (ConsumedCap != null) + throw new InvalidOperationException("Proxy was already bound"); + + if (cap == null) + return; + + ConsumedCap = cap; + cap.AddRef(); + } + + internal IProvidedCapability GetProvider() + { + switch (ConsumedCap) + { + case LocalCapability lcap: + return lcap.ProvidedCap; + + case null: + return null; + + default: + return Vine.Create(ConsumedCap); + } + } + + /// + /// Dispose pattern implementation + /// + protected virtual void Dispose(bool disposing) + { + if (!_disposedValue) + { + ConsumedCap?.Release(); + _disposedValue = true; + } + } + + ~Proxy() + { +#if DebugFinalizers + Logger.LogWarning($"Caught orphaned Proxy, created from {CreatorMemberName} in {CreatorFilePath}, line {CreatorLineNumber}."); +#endif + + Dispose(false); + } + + /// + /// Dispose pattern implementation + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Casts this Proxy to a different capability interface. + /// + /// Desired capability interface + /// Whether to Dispose() this Proxy instance + /// Proxy for desired capability interface + /// did not qualify as capability interface. + /// This capability is broken, or mismatch between generic type arguments (if capability interface is generic). + /// Mismatch between generic type arguments (if capability interface is generic). + /// Problem with instatiating the Proxy (constructor threw exception). + /// Caller does not have permission to invoke the Proxy constructor. + /// Problem with building the Proxy type, or problem with loading some dependent class. + public T Cast(bool disposeThis) where T: class + { + if (IsNull) + throw new InvalidOperationException("Capability is broken"); + + using (disposeThis ? this : null) + { + return CapabilityReflection.CreateProxy(ConsumedCap) as T; + } + } + + internal void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + { + if (_disposedValue) + throw new ObjectDisposedException(nameof(Proxy)); + + if (ConsumedCap == null) + writer.which = CapDescriptor.WHICH.None; + else + ConsumedCap.Export(endpoint, writer); + } + + internal void Freeze(out IRpcEndpoint boundEndpoint) + { + if (_disposedValue) + throw new ObjectDisposedException(nameof(Proxy)); + + boundEndpoint = null; + ConsumedCap?.Freeze(out boundEndpoint); + } + + internal void Unfreeze() + { + if (_disposedValue) + throw new ObjectDisposedException(nameof(Proxy)); + + ConsumedCap?.Unfreeze(); + } + +#if DebugFinalizers + public string CreatorMemberName { get; set; } + public string CreatorFilePath { get; set; } + public int CreatorLineNumber { get; set; } +#endif + } +} diff --git a/Capnp.Net.Runtime/Rpc/ProxyAttribute.cs b/Capnp.Net.Runtime/Rpc/ProxyAttribute.cs new file mode 100644 index 0000000..ccf38c5 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/ProxyAttribute.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Capnp.Rpc +{ + /// + /// Annotates a capability interface with its Proxy implementation. + /// + [AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = false)] + public class ProxyAttribute : Attribute + { + /// + /// Constructs this attribute. + /// + /// Proxy type. This must be a class which inherits from and + /// exposes a public parameterless constructor. Moreover, it must have same amount of generic type + /// parameters like the annotated interface, with identical generic constraints. + /// is null. + public ProxyAttribute(Type proxyClass) + { + ProxyClass = proxyClass ?? throw new ArgumentNullException(nameof(proxyClass)); + } + + /// + /// The Proxy type. + /// + public Type ProxyClass { get; } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RefCountingCapability.cs b/Capnp.Net.Runtime/Rpc/RefCountingCapability.cs new file mode 100644 index 0000000..7d61089 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RefCountingCapability.cs @@ -0,0 +1,84 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + abstract class RefCountingCapability: ConsumedCapability + { + // Note on reference counting: Works in analogy to COM. AddRef() adds a reference, + // Release() removes it. When the reference count reaches zero, the capability must be + // released remotely, i.e. we need to tell the remote peer that it can remove this + // capability from its export table. To be on the safe side, + // this class also implements a finalizer which will auto-release this capability + // remotely. This might happen if one forgets to Dispose() a Proxy. It might also happen + // if no Proxy is ever created. The latter situation occurs if the using client never + // deserializes the capability Proxy from its RPC state. This situation is nearly + // impossible to handle without relying on GC, since we never know when deserialization + // happens, and there is no RAII like in C++. Since this situation is expected to happen rarely, + // it seems acceptable to rely on the finalizer. There are three possible states. + // A: Initial state after construction: No reference, capability is *not* released. + // B: Some positive reference count. + // C: Released state: No reference anymore, capability *is* released. + // In order to distinguish state A from C, the member _refCount stores the reference count *plus one*. + // Value 0 has the special meaning of being in state C. + int _refCount = 1; + + ~RefCountingCapability() + { + Dispose(false); + } + + /// + /// Part of the Dispose pattern implementation. + /// + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + try + { + ReleaseRemotely(); + } + catch + { + } + + _refCount = 0; + } + else + { + if (_refCount > 0) + { + Task.Run(() => + { + try + { + ReleaseRemotely(); + } + catch + { + } + }); + } + } + } + + internal sealed override void AddRef() + { + if (Interlocked.Increment(ref _refCount) <= 1) + { + throw new ObjectDisposedException(nameof(ConsumedCapability)); + } + } + + internal sealed override void Release() + { + if (1 == Interlocked.Decrement(ref _refCount)) + { + Dispose(true); + GC.SuppressFinalize(this); + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RemoteAnswerCapability.cs b/Capnp.Net.Runtime/Rpc/RemoteAnswerCapability.cs new file mode 100644 index 0000000..61af0e6 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RemoteAnswerCapability.cs @@ -0,0 +1,248 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class RemoteAnswerCapability : RemoteResolvingCapability + { + // Set DebugEmbargos to true to get logging output for calls. RPC calls are expected to + // be on the critical path, hence very relevant for performance. We just can't afford + // additional stuff on this path. Even if the logger filters the outputs away, there is + // overhead for creating the Logger object, calling the Logger methods and deciding to + // filter the output. This justifies the precompiler switch. +#if DebugEmbargos + ILogger Logger { get; } = Logging.CreateLogger(); +#endif + + readonly PendingQuestion _question; + readonly MemberAccessPath _access; + Proxy _resolvedCap; + + public RemoteAnswerCapability(PendingQuestion question, MemberAccessPath access): base(question.RpcEndpoint) + { + _question = question ?? throw new ArgumentNullException(nameof(question)); + _access = access ?? throw new ArgumentNullException(nameof(access)); + } + + async void ReAllowFinishWhenDone(Task task) + { + try + { + ++_pendingCallsOnPromise; + + await task; + } + catch + { + } + finally + { + lock (_question.ReentrancyBlocker) + { + --_pendingCallsOnPromise; + _question.AllowFinish(); + } + } + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + _resolvedCap?.Dispose(); + } + + protected override Proxy ResolvedCap + { + get + { + if (_resolvedCap == null && !_question.IsTailCall && _question.IsReturned) + { + DeserializerState result; + try + { + result = _question.WhenReturned.Result; + } + catch (AggregateException exception) + { + throw exception.InnerException; + } + + _resolvedCap = new Proxy(_access.Eval(result)); + } + return _resolvedCap; + } + } + + async Task AwaitWhenResolved() + { + await _question.WhenReturned; + return ResolvedCap; + } + + public override Task WhenResolved => AwaitWhenResolved(); + + protected override void GetMessageTarget(MessageTarget.WRITER wr) + { + wr.which = MessageTarget.WHICH.PromisedAnswer; + wr.PromisedAnswer.QuestionId = _question.QuestionId; + _access.Serialize(wr.PromisedAnswer); + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + lock (_question.ReentrancyBlocker) + { + if (_question.StateFlags.HasFlag(PendingQuestion.State.Returned) && + !_question.StateFlags.HasFlag(PendingQuestion.State.TailCall)) + { + if (ResolvedCap == null) + { + throw new RpcException("Answer did not resolve to expected capability"); + } + + return CallOnResolution(interfaceId, methodId, args, pipeline); + } + else + { +#if DebugEmbargos + Logger.LogDebug("Call by proxy"); +#endif + if (_question.StateFlags.HasFlag(PendingQuestion.State.Disposed)) + { + throw new ObjectDisposedException(nameof(PendingQuestion)); + } + + if (_question.StateFlags.HasFlag(PendingQuestion.State.FinishRequested)) + { + throw new InvalidOperationException("Finish request was already sent"); + } + + _question.DisallowFinish(); + ++_pendingCallsOnPromise; + var promisedAnswer = base.DoCall(interfaceId, methodId, args, pipeline); + ReAllowFinishWhenDone(promisedAnswer.WhenReturned); + + async void DecrementPendingCallsOnPromiseWhenReturned() + { + try + { + await promisedAnswer.WhenReturned; + } + catch + { + } + finally + { + lock (_question.ReentrancyBlocker) + { + --_pendingCallsOnPromise; + } + } + } + + DecrementPendingCallsOnPromiseWhenReturned(); + return promisedAnswer; + } + } + } + + protected override Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId) + { + var call = base.SetupMessage(args, interfaceId, methodId); + + call.Target.which = MessageTarget.WHICH.PromisedAnswer; + call.Target.PromisedAnswer.QuestionId = _question.QuestionId; + _access.Serialize(call.Target.PromisedAnswer); + + return call; + } + + internal override void Freeze(out IRpcEndpoint boundEndpoint) + { + lock (_question.ReentrancyBlocker) + { + if (_question.StateFlags.HasFlag(PendingQuestion.State.Returned) && + _pendingCallsOnPromise == 0) + { + if (ResolvedCap == null) + { + throw new RpcException("Answer did not resolve to expected capability"); + } + + ResolvedCap.Freeze(out boundEndpoint); + } + else + { + ++_pendingCallsOnPromise; + _question.DisallowFinish(); + boundEndpoint = _ep; + } + } + } + + internal override void Unfreeze() + { + lock (_question.ReentrancyBlocker) + { + if (_pendingCallsOnPromise > 0) + { + --_pendingCallsOnPromise; + _question.AllowFinish(); + } + else + { + ResolvedCap?.Unfreeze(); + } + } + } + + internal override void Export(IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + { + lock (_question.ReentrancyBlocker) + { + if (_question.StateFlags.HasFlag(PendingQuestion.State.Disposed)) + throw new ObjectDisposedException(nameof(PendingQuestion)); + + if (_question.StateFlags.HasFlag(PendingQuestion.State.Returned)) + { + ResolvedCap.Export(endpoint, writer); + } + else + { + if (_question.StateFlags.HasFlag(PendingQuestion.State.FinishRequested)) + throw new InvalidOperationException("Finish request was already sent"); + + if (endpoint == _ep) + { + writer.which = CapDescriptor.WHICH.ReceiverAnswer; + _access.Serialize(writer.ReceiverAnswer); + writer.ReceiverAnswer.QuestionId = _question.QuestionId; + } + else if (_question.IsTailCall) + { + // FIXME: Resource management! We should prevent finishing this + // cap as long as it is exported. Unfortunately, we cannot determine + // when it gets removed from the export table. + + var vine = Vine.Create(this); + uint id = endpoint.AllocateExport(vine, out bool first); + + writer.which = CapDescriptor.WHICH.SenderHosted; + writer.SenderHosted = id; + } + else + { + this.ExportAsSenderPromise(endpoint, writer); + } + } + } + } + + protected override void ReleaseRemotely() + { + this.DisposeWhenResolved(); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RemoteCapability.cs b/Capnp.Net.Runtime/Rpc/RemoteCapability.cs new file mode 100644 index 0000000..e78d7c5 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RemoteCapability.cs @@ -0,0 +1,40 @@ +using System; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + + abstract class RemoteCapability : RefCountingCapability + { + protected readonly IRpcEndpoint _ep; + + protected RemoteCapability(IRpcEndpoint ep) + { + _ep = ep; + } + + internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool tailCall) + { + var call = SetupMessage(args, interfaceId, methodId); + Debug.Assert(call.Target.which != MessageTarget.WHICH.undefined); + return _ep.BeginQuestion(this, args); + } + + protected virtual Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId) + { + var callMsg = args.MsgBuilder.BuildRoot(); + + callMsg.which = Message.WHICH.Call; + + var call = callMsg.Call; + call.AllowThirdPartyTailCall = false; + call.InterfaceId = interfaceId; + call.MethodId = methodId; + call.Params.Content = args; + + return call; + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RemoteResolvingCapability.cs b/Capnp.Net.Runtime/Rpc/RemoteResolvingCapability.cs new file mode 100644 index 0000000..65550f0 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RemoteResolvingCapability.cs @@ -0,0 +1,126 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + abstract class RemoteResolvingCapability : RemoteCapability, IResolvingCapability + { + // Set DebugEmbargos to true to get logging output for calls. RPC calls are expected to + // be on the critical path, hence very relevant for performance. We just can't afford + // additional stuff on this path. Even if the logger filters the outputs away, there is + // overhead for creating the Logger object, calling the Logger methods and deciding to + // filter the output. This justifies the precompiler switch. +#if DebugEmbargos + ILogger Logger { get; } = Logging.CreateLogger(); +#endif + + public abstract Task WhenResolved { get; } + + protected RemoteResolvingCapability(IRpcEndpoint ep) : base(ep) + { + } + + protected int _pendingCallsOnPromise; + Task _disembargo; + + protected abstract Proxy ResolvedCap { get; } + + protected abstract void GetMessageTarget(MessageTarget.WRITER wr); + + protected IPromisedAnswer CallOnResolution(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline) + { + try + { + ResolvedCap.Freeze(out var resolvedCapEndpoint); + + try + { + if (resolvedCapEndpoint != null && resolvedCapEndpoint != _ep) + { + // Carol lives in a different Vat C. + throw new NotImplementedException("Sorry, level 3 RPC is not yet supported."); + } + + if (ResolvedCap.IsNull || + // If the capability resolves to null, disembargo must not be requested. + // Take the direct path, well-knowing that the call will result in an exception. + + resolvedCapEndpoint != null || + //# Note that in the case where Carol actually lives in Vat B (i.e., the same vat that the promise + //# already pointed at), no embargo is needed, because the pipelined calls are delivered over the + //# same path as the later direct calls. + + (_disembargo == null && _pendingCallsOnPromise == 0) || + // No embargo is needed since all outstanding replies have returned + + _disembargo?.IsCompleted == true + // Disembargo has returned + ) + { +#if DebugEmbargos + Logger.LogDebug("Direct call"); +#endif + return ResolvedCap.Call(interfaceId, methodId, args, pipeline); + } + else + { + if (_disembargo == null) + { +#if DebugEmbargos + Logger.LogDebug("Requesting disembargo"); +#endif + _disembargo = _ep.RequestSenderLoopback(GetMessageTarget); + } + else + { +#if DebugEmbargos + Logger.LogDebug("Waiting for requested disembargo"); +#endif + } + + var cancellationTokenSource = new CancellationTokenSource(); + + var callAfterDisembargo = _disembargo.ContinueWith(_ => + { + // Two reasons for ignoring exceptions on the previous task (i.e. not _.Wait()ing): + // 1. A faulting predecessor, especially due to cancellation, must not have any impact on this one. + // 2. A faulting disembargo request would be a fatal protocol error, resulting in Abort() - we're dead anyway. + + cancellationTokenSource.Token.ThrowIfCancellationRequested(); + + return ResolvedCap.Call(interfaceId, methodId, args, pipeline); + + }, TaskContinuationOptions.ExecuteSynchronously); + + _disembargo = callAfterDisembargo; + + async Task AwaitAnswer() + { + var promisedAnswer = await callAfterDisembargo; + + using (cancellationTokenSource.Token.Register(promisedAnswer.Dispose)) + { + return await promisedAnswer.WhenReturned; + } + } + + return new LocalAnswer(cancellationTokenSource, AwaitAnswer()); + } + } + finally + { + ResolvedCap.Unfreeze(); + } + } + catch (System.Exception exception) + { + // Wrap exception into local answer, since otherwise we'd get an AggregateException (which we don't want). + return new LocalAnswer( + new CancellationTokenSource(), + Task.FromException(exception)); + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/ResolvingCapabilityExtensions.cs b/Capnp.Net.Runtime/Rpc/ResolvingCapabilityExtensions.cs new file mode 100644 index 0000000..d59173b --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/ResolvingCapabilityExtensions.cs @@ -0,0 +1,44 @@ +namespace Capnp.Rpc +{ + static class ResolvingCapabilityExtensions + { + public static void ExportAsSenderPromise(this T cap, IRpcEndpoint endpoint, CapDescriptor.WRITER writer) + where T: ConsumedCapability, IResolvingCapability + { + var vine = Vine.Create(cap); + uint preliminaryId = endpoint.AllocateExport(vine, out bool first); + + writer.which = CapDescriptor.WHICH.SenderPromise; + writer.SenderPromise = preliminaryId; + + if (first) + { + endpoint.RequestPostAction(async () => { + + try + { + var resolvedCap = await cap.WhenResolved; + + endpoint.Resolve(preliminaryId, vine, () => resolvedCap.ConsumedCap); + } + catch (System.Exception exception) + { + endpoint.Resolve(preliminaryId, vine, () => throw exception); + } + + }); + } + } + + public static async void DisposeWhenResolved(this IResolvingCapability cap) + { + try + { + (await cap.WhenResolved)?.Dispose(); + } + catch + { + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RpcEngine.cs b/Capnp.Net.Runtime/Rpc/RpcEngine.cs new file mode 100644 index 0000000..0cb05bc --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RpcEngine.cs @@ -0,0 +1,1520 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Implements the Cap'n Proto RPC protocol. + /// + public class RpcEngine + { + class RefCounted + { + public T Cap { get; } + public int RefCount { get; private set; } + + public RefCounted(T cap) + { + Cap = cap; + RefCount = 1; + } + + public void AddRef() + { + ++RefCount; + } + + public void Release() + { + --RefCount; + CheckDispose(); + } + + public void ReleaseAll() + { + RefCount = 0; + CheckDispose(); + } + + public void Release(int count) + { + if (count > RefCount) + throw new ArgumentOutOfRangeException(nameof(count)); + + RefCount -= count; + CheckDispose(); + } + + void CheckDispose() + { + if (RefCount == 0 && Cap is IDisposable disposable) + { + disposable.Dispose(); + } + } + } + + internal class RpcEndpoint : IEndpoint, IRpcEndpoint + { + static readonly ThreadLocal _exportCapTablePostActions = new ThreadLocal(); + static readonly ThreadLocal _tailCall = new ThreadLocal(); + static readonly ThreadLocal _canDeferCalls = new ThreadLocal(); + + ILogger Logger { get; } = Logging.CreateLogger(); + + readonly RpcEngine _host; + readonly IEndpoint _tx; + + readonly Random _random = new Random(); + readonly Dictionary>> _importTable = new Dictionary>>(); + readonly Dictionary> _exportTable = new Dictionary>(); + readonly Dictionary _revExportTable = new Dictionary(); + readonly Dictionary _questionTable = new Dictionary(); + readonly Dictionary _answerTable = new Dictionary(); + readonly Dictionary> _pendingDisembargos = new Dictionary>(); + readonly object _reentrancyBlocker = new object(); + + long _recvCount; + long _sendCount; + + internal RpcEndpoint(RpcEngine host, IEndpoint tx) + { + _host = host; + _tx = tx; + } + + public void Dismiss() + { + lock (_reentrancyBlocker) + { + _exportTable.Clear(); + _revExportTable.Clear(); + _questionTable.Clear(); + _answerTable.Clear(); + _pendingDisembargos.Clear(); + } + + _tx.Dismiss(); + } + + public void Forward(WireFrame frame) + { + Interlocked.Increment(ref _recvCount); + ProcessFrame(frame); + } + + public long SendCount => Interlocked.Read(ref _sendCount); + public long RecvCount => Interlocked.Read(ref _recvCount); + + void Tx(WireFrame frame) + { + try + { + _tx.Forward(frame); + Interlocked.Increment(ref _sendCount); + } + catch (System.Exception exception) + { + Logger.LogWarning(exception, "Unable to send frame"); + throw new RpcException("Unable to send frame", exception); + } + } + + void SendAbort(string reason) + { + var mb = MessageBuilder.Create(); + var msg = mb.BuildRoot(); + msg.which = Message.WHICH.Abort; + msg.Abort.Reason = reason; + Tx(mb.Frame); + } + + void IRpcEndpoint.Resolve(uint preliminaryId, Skeleton preliminaryCap, + Func resolvedCapGetter) + { + lock (_reentrancyBlocker) + { + if (!_exportTable.TryGetValue(preliminaryId, out var existing) || + existing.Cap != preliminaryCap || + existing.RefCount == 0) + { + // Resolved too late. Capability was already released. + return; + } + + existing.AddRef(); + existing.Cap.Claim(); + } + + var mb = MessageBuilder.Create(); + var msg = mb.BuildRoot(); + msg.which = Message.WHICH.Resolve; + var resolve = msg.Resolve; + + try + { + var resolvedCap = resolvedCapGetter(); + resolve.which = Resolve.WHICH.Cap; + resolvedCap.Export(this, resolve.Cap); + } + catch (System.Exception ex) + { + resolve.which = Resolve.WHICH.Exception; + resolve.Exception.Reason = ex.Message; + } + resolve.PromiseId = preliminaryId; + + Tx(mb.Frame); + + ReleaseExport(preliminaryId, 1); + } + + uint RandId() + { + uint id = 0; + var idSpan = MemoryMarshal.CreateSpan(ref id, 1); + var idBytes = MemoryMarshal.Cast(idSpan); + + _random.NextBytes(idBytes); + + return id; + } + + uint AllocateExport(Skeleton providedCapability, out bool first) + { + lock (_reentrancyBlocker) + { + providedCapability.Claim(); + + if (_revExportTable.TryGetValue(providedCapability, out uint id)) + { + first = false; + + if (_exportTable.TryGetValue(id, out var rc)) + { + rc.AddRef(); + } + else + { + Logger.LogError("Inconsistent export table: Capability with id {0} exists in reverse table only", id); + } + } + else + { + do + { + id = RandId(); + + } while (_exportTable.ContainsKey(id)); + + _revExportTable.Add(providedCapability, id); + _exportTable.Add(id, new RefCounted(providedCapability)); + + first = true; + } + + return id; + } + } + + uint IRpcEndpoint.AllocateExport(Skeleton providedCapability, out bool first) + { + return AllocateExport(providedCapability, out first); + } + + PendingQuestion AllocateQuestion(ConsumedCapability target, SerializerState inParams) + { + uint questionId = RandId(); + var question = new PendingQuestion(this, questionId, target, inParams); + + lock (_reentrancyBlocker) + { + while (!_questionTable.TryAdd(questionId, question)) + { + questionId = RandId(); + var oldQuestion = question; + question = new PendingQuestion(this, questionId, target, inParams); + oldQuestion.Dispose(); + } + } + + return question; + } + + void DeleteQuestion(uint id, PendingQuestion question) + { + lock (_reentrancyBlocker) + { + if (!_questionTable.TryGetValue(id, out var existingQuestion)) + { + Logger.LogError("Attempting to delete unknown question ID. Race condition?"); + return; + } + + if (question != existingQuestion) + { + Logger.LogError("Found different question under given ID. WTF???"); + return; + } + + _questionTable.Remove(id); + } + } + + (TaskCompletionSource, uint) AllocateDisembargo() + { + var tcs = new TaskCompletionSource(); + + lock (_reentrancyBlocker) + { + uint id = RandId(); + + while (!_pendingDisembargos.TryAdd(id, tcs)) + { + id = RandId(); + } + + return (tcs, id); + } + } + + void ProcessBootstrap(Bootstrap.READER req) + { + uint q = req.QuestionId; + + var bootstrap = DynamicSerializerState.CreateForRpc(); + var ans = bootstrap.MsgBuilder.BuildRoot(); + + ans.which = Message.WHICH.Return; + var ret = ans.Return; + ret.AnswerId = q; + + Task bootstrapTask; + var bootstrapCap = _host.BootstrapCap; + + if (bootstrapCap != null) + { + ret.which = Return.WHICH.Results; + bootstrap.SetCapability(bootstrap.ProvideCapability(LocalCapability.Create(_host.BootstrapCap))); + ret.Results.Content = bootstrap; + + bootstrapTask = Task.FromResult(bootstrap); + } + else + { + Logger.LogWarning("Peer asked for bootstrap capability, but no bootstrap capability was set."); + + ret.which = Return.WHICH.Exception; + ret.Exception.Reason = "No bootstrap capability present"; + + bootstrapTask = Task.FromException(new RpcException(ret.Exception.Reason)); + } + + var pendingAnswer = new PendingAnswer(bootstrapTask, null); + + bool added; + lock (_reentrancyBlocker) + { + added = _answerTable.TryAdd(req.QuestionId, pendingAnswer); + } + + if (!added) + { + Logger.LogWarning("Incoming bootstrap request: Peer specified duplicate (not yet released?) answer ID."); + } + + + if (bootstrapCap != null) + { + ExportCapTableAndSend(bootstrap, ret.Results); + } + else + { + Tx(bootstrap.MsgBuilder.Frame); + } + } + + + void ProcessCall(Call.READER req) + { + Return.WRITER SetupReturn(MessageBuilder mb) + { + var rmsg = mb.BuildRoot(); + rmsg.which = Message.WHICH.Return; + var ret = rmsg.Return; + ret.AnswerId = req.QuestionId; + + return ret; + } + + void ReturnCall(Action why) + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var ret = SetupReturn(mb); + + why(ret); + + try + { + Tx(mb.Frame); + } + catch (RpcException exception) + { + Logger.LogWarning($"Unable to return call: {exception.InnerException.Message}"); + } + } + + IProvidedCapability cap; + PendingAnswer pendingAnswer = null; + bool releaseParamCaps = false; + + void AwaitAnswerAndReply() + { + bool added; + lock (_reentrancyBlocker) + { + added = _answerTable.TryAdd(req.QuestionId, pendingAnswer); + } + + if (!added) + { + Logger.LogWarning("Incoming RPC call: Peer specified duplicate (not yet released?) answer ID."); + + pendingAnswer.Cancel(); + pendingAnswer.Dispose(); + + SendAbort($"There is another pending answer for the same question ID {req.QuestionId}."); + + return; + } + + switch (req.SendResultsTo.which) + { + case Call.sendResultsTo.WHICH.Caller: + pendingAnswer.Chain(false, async t => + { + try + { + var aorcq = await t; + + if (aorcq.Answer == null && aorcq.Counterquestion == null) + { + Debug.Fail("Either answer or counter question must be present"); + } + else if (aorcq.Answer != null || aorcq.Counterquestion != _tailCall.Value) + { + var results = aorcq.Answer ?? (DynamicSerializerState)(await aorcq.Counterquestion.WhenReturned); + var ret = SetupReturn(results.MsgBuilder); + + switch (req.SendResultsTo.which) + { + case Call.sendResultsTo.WHICH.Caller: + ret.which = Return.WHICH.Results; + ret.Results.Content = results.Rewrap(); + ret.ReleaseParamCaps = releaseParamCaps; + ExportCapTableAndSend(results, ret.Results); + break; + + case Call.sendResultsTo.WHICH.Yourself: + ReturnCall(ret2 => + { + ret2.which = Return.WHICH.ResultsSentElsewhere; + ret2.ReleaseParamCaps = releaseParamCaps; + }); + break; + } + } + else if (aorcq.Counterquestion != null) + { + _tailCall.Value = null; + aorcq.Counterquestion.IsTailCall = true; + aorcq.Counterquestion.Send(); + + ReturnCall(ret2 => + { + ret2.which = Return.WHICH.TakeFromOtherQuestion; + ret2.TakeFromOtherQuestion = aorcq.Counterquestion.QuestionId; + ret2.ReleaseParamCaps = releaseParamCaps; + }); + } + } + catch (TaskCanceledException) + { + ReturnCall(ret => + { + ret.which = Return.WHICH.Canceled; + ret.ReleaseParamCaps = releaseParamCaps; + }); + } + catch (System.Exception exception) + { + ReturnCall(ret => + { + ret.which = Return.WHICH.Exception; + ret.Exception.Reason = exception.Message; + ret.ReleaseParamCaps = releaseParamCaps; + }); + } + }); + break; + + case Call.sendResultsTo.WHICH.Yourself: + pendingAnswer.Chain(false, async t => + { + try + { + await t; + } + catch + { + } + finally + { + ReturnCall(ret => + { + ret.which = Return.WHICH.ResultsSentElsewhere; + ret.ReleaseParamCaps = releaseParamCaps; + }); + } + }); + break; + } + } + + void CreateAnswerAwaitItAndReply() + { + var inParams = req.Params.Content; + inParams.Caps = ImportCapTable(req.Params); + + if (cap == null) + { + releaseParamCaps = true; + pendingAnswer = new PendingAnswer( + Task.FromException( + new RpcException("Call target resolved to null")), null); + } + else + { + try + { + var cts = new CancellationTokenSource(); + var callTask = cap.Invoke(req.InterfaceId, req.MethodId, inParams, cts.Token); + pendingAnswer = new PendingAnswer(callTask, cts); + } + catch (System.Exception exception) + { + releaseParamCaps = true; + pendingAnswer = new PendingAnswer( + Task.FromException(exception), null); + } + } + + AwaitAnswerAndReply(); + } + + switch (req.SendResultsTo.which) + { + case Call.sendResultsTo.WHICH.Caller: + case Call.sendResultsTo.WHICH.Yourself: + break; + + case Call.sendResultsTo.WHICH.ThirdParty: + Logger.LogWarning("Incoming RPC call: Peer requested sending results to 3rd party, which is not (yet) supported."); + throw new RpcUnimplementedException(); + + default: + Logger.LogWarning("Incoming RPC call: Peer requested unknown send-results-to mode."); + throw new RpcUnimplementedException(); + } + + _canDeferCalls.Value = true; + Impatient.AskingEndpoint = this; + + try + { + switch (req.Target.which) + { + case MessageTarget.WHICH.ImportedCap: + + lock (_reentrancyBlocker) + { + if (_exportTable.TryGetValue(req.Target.ImportedCap, out var rc)) + { + cap = rc.Cap; + } + else + { + Logger.LogWarning("Incoming RPC call: Peer asked for invalid (already released?) capability ID."); + + SendAbort($"Requested capability with ID {req.Target.ImportedCap} does not exist."); + return; + } + } + + CreateAnswerAwaitItAndReply(); + + break; + + case MessageTarget.WHICH.PromisedAnswer: + { + bool exists; + PendingAnswer previousAnswer; + + lock (_reentrancyBlocker) + { + exists = _answerTable.TryGetValue(req.Target.PromisedAnswer.QuestionId, out previousAnswer); + } + + if (exists) + { + previousAnswer.Chain( + false, + req.Target.PromisedAnswer, + async t => + { + try + { + using (var proxy = await t) + { + cap = proxy?.GetProvider(); + CreateAnswerAwaitItAndReply(); + } + } + catch (TaskCanceledException) + { + pendingAnswer = new PendingAnswer( + Task.FromCanceled(previousAnswer.CancellationToken), null); + + AwaitAnswerAndReply(); + } + catch (System.Exception exception) + { + pendingAnswer = new PendingAnswer( + Task.FromException(exception), null); + + AwaitAnswerAndReply(); + } + }); + } + else + { + Logger.LogWarning("Incoming RPC call: Peer asked for non-existing answer ID."); + SendAbort($"Did not find a promised answer for given ID {req.Target.PromisedAnswer.QuestionId}"); + return; + } + } + break; + + default: + Logger.LogWarning("Incoming RPC call: Peer specified unknown call target."); + + throw new RpcUnimplementedException(); + } + } + finally + { + _canDeferCalls.Value = false; + Impatient.AskingEndpoint = null; + _tailCall.Value?.Send(); + _tailCall.Value = null; + } + } + + void ProcessReturn(Return.READER req) + { + PendingQuestion question; + + lock (_reentrancyBlocker) + { + if (!_questionTable.TryGetValue(req.AnswerId, out question)) + { + Logger.LogWarning("Incoming RPC return: Unknown answer ID."); + + return; + } + } + + switch (req.which) + { + case Return.WHICH.Results: + var content = req.Results.Content; + content.Caps = ImportCapTable(req.Results); + question.OnReturn(content); + break; + + case Return.WHICH.AcceptFromThirdParty: + Logger.LogWarning( + "Incoming RPC return: Peer requested to accept results from 3rd party, which is not (yet) supported."); + + throw new RpcUnimplementedException(); + + case Return.WHICH.Canceled: + question.OnCanceled(); + break; + + case Return.WHICH.Exception: + question.OnException(req.Exception); + break; + + case Return.WHICH.ResultsSentElsewhere: + question.OnTailCallReturn(); + break; + + case Return.WHICH.TakeFromOtherQuestion: + { + bool exists; + PendingAnswer pendingAnswer; + + lock (_reentrancyBlocker) + { + exists = _answerTable.TryGetValue(req.TakeFromOtherQuestion, out pendingAnswer); + } + + if (exists) + { + pendingAnswer.Chain(false, async t => + { + try + { + var aorcq = await t; + var results = aorcq.Answer; + + if (results != null) + { + question.OnReturn(results); + } + else + { + question.OnTailCallReturn(); + } + } + catch (TaskCanceledException) + { + question.OnCanceled(); + } + catch (System.Exception exception) + { + question.OnException(exception); + } + }); + } + else + { + Logger.LogWarning("Incoming RPC return: Peer requested to take results from other question, but specified ID is unknown (already released?)"); + } + } + break; + + default: + throw new RpcUnimplementedException(); + } + } + + void ProcessResolve(Resolve.READER resolve) + { + if (!_importTable.TryGetValue(resolve.PromiseId, out var rcw)) + { + Logger.LogWarning("Received a resolve message with invalid ID"); + return; + } + + if (!rcw.Cap.TryGetTarget(out var cap)) + { + // Silently discard + return; + } + + if (!(cap is PromisedCapability resolvableCap)) + { + Logger.LogWarning("Received a resolve message for a capability which is not a promise"); + return; + } + + switch (resolve.which) + { + case Resolve.WHICH.Cap: + lock (_reentrancyBlocker) + { + var resolvedCap = ImportCap(resolve.Cap); + resolvableCap.ResolveTo(resolvedCap); + } + break; + + case Resolve.WHICH.Exception: + resolvableCap.Break(resolve.Exception.Reason); + break; + + default: + Logger.LogWarning("Received a resolve message with unknown category."); + throw new RpcUnimplementedException(); + } + } + + void ProcessSenderLoopback(Disembargo.READER disembargo) + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var wr = mb.BuildRoot(); + wr.which = Message.WHICH.Disembargo; + wr.Disembargo.Context.which = Disembargo.context.WHICH.ReceiverLoopback; + wr.Disembargo.Context.ReceiverLoopback = disembargo.Context.SenderLoopback; + var reply = wr.Disembargo; + + switch (disembargo.Target.which) + { + case MessageTarget.WHICH.ImportedCap: + + if (!_exportTable.TryGetValue(disembargo.Target.ImportedCap, out var cap)) + { + Logger.LogWarning("Sender loopback request: Peer asked for invalid (already released?) capability ID."); + + SendAbort("'Disembargo': Invalid capability ID"); + Dismiss(); + + return; + } + + reply.Target.which = MessageTarget.WHICH.ImportedCap; + reply.Target.ImportedCap = disembargo.Target.ImportedCap; + + Tx(mb.Frame); + + break; + + case MessageTarget.WHICH.PromisedAnswer: + + var promisedAnswer = disembargo.Target.PromisedAnswer; + reply.Target.which = MessageTarget.WHICH.PromisedAnswer; + var replyPromisedAnswer = reply.Target.PromisedAnswer; + replyPromisedAnswer.QuestionId = disembargo.Target.PromisedAnswer.QuestionId; + int count = promisedAnswer.Transform.Count; + replyPromisedAnswer.Transform.Init(count); + + for (int i = 0; i < count; i++) + { + replyPromisedAnswer.Transform[i].which = promisedAnswer.Transform[i].which; + replyPromisedAnswer.Transform[i].GetPointerField = promisedAnswer.Transform[i].GetPointerField; + } + + if (_answerTable.TryGetValue(promisedAnswer.QuestionId, out var previousAnswer)) + { + previousAnswer.Chain(true, + disembargo.Target.PromisedAnswer, + async t => + { + try + { + using (var proxy = await t) + { + proxy.Freeze(out var boundEndpoint); + + try + { + if (boundEndpoint == this) + { +#if DebugEmbargos + Logger.LogDebug($"Sender loopback disembargo. Thread = {Thread.CurrentThread.Name}"); +#endif + Tx(mb.Frame); + } + else + { + Logger.LogWarning("Sender loopback request: Peer asked for disembargoing an answer which does not resolve back to the sender."); + + SendAbort("'Disembargo': Answer does not resolve back to me"); + Dismiss(); + } + } + finally + { + proxy.Unfreeze(); + } + } + } + catch (System.Exception exception) + { + Logger.LogWarning($"Sender loopback request: Peer asked for disembargoing an answer which either has not yet returned, was canceled, or faulted: {exception.Message}"); + + SendAbort($"'Disembargo' failure: {exception}"); + Dismiss(); + + } + }); + } + else + { + Logger.LogWarning("Sender loopback request: Peer asked for non-existing answer ID."); + + SendAbort("'Disembargo': Invalid answer ID"); + Dismiss(); + + return; + } + + break; + + default: + Logger.LogWarning("Sender loopback request: Peer specified unknown call target."); + + throw new RpcUnimplementedException(); + } + } + + void ProcessReceiverLoopback(Disembargo.READER disembargo) + { + bool exists; + TaskCompletionSource tcs; + + lock (_reentrancyBlocker) + { + exists = _pendingDisembargos.Remove(disembargo.Context.ReceiverLoopback, out tcs); + } + + if (exists) + { + // FIXME: The current design does not admit for verifying the target/context components of + // the disembargo message. We just rely on the peer echoing the stuff back that we sent. + // Indeed, this should never be an issue in the absence of bugs and/or attacks. Even unsure, + // whether this is a security issue: Can the sloppy checking be exploited in some way? + +#if DebugEmbargos + Logger.LogDebug($"Receiver loopback disembargo, Thread = {Thread.CurrentThread.Name}"); +#endif + + if (!tcs.TrySetResult(0)) + { + Logger.LogError("Attempting to grant disembargo failed. Looks like an internal error / race condition."); + } + } + else + { + Logger.LogWarning("Peer sent receiver loopback with unknown ID"); + } + } + + void ProcessDisembargo(Disembargo.READER disembargo) + { + switch (disembargo.Context.which) + { + case Disembargo.context.WHICH.ReceiverLoopback: + ProcessReceiverLoopback(disembargo); + break; + + case Disembargo.context.WHICH.SenderLoopback: + ProcessSenderLoopback(disembargo); + break; + + case Disembargo.context.WHICH.Accept: + case Disembargo.context.WHICH.Provide: + default: + throw new RpcUnimplementedException(); + } + } + + void ReleaseResultCaps(PendingAnswer answer) + { + try + { + answer.Chain(false, async t => + { + var aorcq = await t; + var results = aorcq.Answer; + + if (results != null && results.Caps != null) + { + foreach (var cap in results.Caps) + { + cap.Release(); + } + } + }); + } + catch + { + } + } + + void ProcessFinish(Finish.READER finish) + { + bool exists; + PendingAnswer answer; + + lock (_reentrancyBlocker) + { + exists = _answerTable.Remove(finish.QuestionId, out answer); + } + + if (exists) + { + if (finish.ReleaseResultCaps) + { + ReleaseResultCaps(answer); + } + + answer.Cancel(); + answer.Dispose(); + } + else + { + Logger.LogWarning("Peer sent 'finish' message with unknown question ID"); + } + } + + void ReleaseExport(uint id, uint count) + { + bool exists, badrc = false; + + lock (_reentrancyBlocker) + { + exists = _exportTable.TryGetValue(id, out var rc); + + if (exists) + { + try + { + int icount = checked((int)count); + rc.Release(icount); + rc.Cap.Relinquish(icount); + + if (rc.RefCount == 0) + { + _exportTable.Remove(id); + _revExportTable.Remove(rc.Cap, out uint _); + } + } + catch (System.Exception) + { + badrc = true; + } + } + } + + if (!exists) + { + Logger.LogWarning("Attempting to release unknown capability ID"); + } + else if (badrc) + { + Logger.LogWarning("Attempting to release capability with invalid reference count"); + } + } + + void ProcessRelease(Release.READER release) + { + ReleaseExport(release.Id, release.ReferenceCount); + } + + void ProcessUnimplementedResolve(Resolve.READER resolve) + { + if (resolve.which == Resolve.WHICH.Cap) + { + switch (resolve.Cap.which) + { + case CapDescriptor.WHICH.SenderHosted: + ReleaseExport(resolve.Cap.SenderHosted, 1); + break; + + case CapDescriptor.WHICH.SenderPromise: + ReleaseExport(resolve.Cap.SenderPromise, 1); + break; + + default: + break; + } + } + } + + void ProcessUnimplementedCall(Call.READER call) + { + Finish(call.QuestionId); + } + + void ProcessUnimplemented(Message.READER unimplemented) + { + switch (unimplemented.which) + { + case Message.WHICH.Resolve: + //# For example, say `resolve` is received by a level 0 implementation (because a previous call + //# or return happened to contain a promise). The level 0 implementation will echo it back as + //# `unimplemented`. The original sender can then simply release the cap to which the promise + //# had resolved, thus avoiding a leak. + ProcessUnimplementedResolve(unimplemented.Resolve); + break; + + case Message.WHICH.Call: + //# For any message type that introduces a question, if the message comes back unimplemented, + //# the original sender may simply treat it as if the question failed with an exception. + ProcessUnimplementedCall(unimplemented.Call); + break; + + case Message.WHICH.Bootstrap: + //# In cases where there is no sensible way to react to an `unimplemented` message (without + //# resource leaks or other serious problems), the connection may need to be aborted. This is + //# a gray area; different implementations may take different approaches. + SendAbort("It's hopeless if you don't implement the bootstrap message"); + Dismiss(); + break; + + default: + // Looking at the various message types it feels OK to just not care about other 'unimplemented' + // responses: You don't support Abort? Not my problem, I will drop the connection anyway. Don't + // support Disembargo? At least I tried. Don't support Finish/Release/Return? Why should I care? + // Don't support Unimplemented? Umm, well. Don't support Accept/Join/Provide? Interesting, I never + // send such messages, since I'm not a level 3 implementation. + break; + } + } + + public ConsumedCapability QueryMain() + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var req = mb.BuildRoot(); + req.which = Message.WHICH.Bootstrap; + var pendingBootstrap = AllocateQuestion(null, null); + req.Bootstrap.QuestionId = pendingBootstrap.QuestionId; + + Tx(mb.Frame); + + var main = new RemoteAnswerCapability( + pendingBootstrap, + MemberAccessPath.BootstrapAccess); + + return main; + } + + void ProcessFrame(WireFrame frame) + { + var dec = DeserializerState.CreateRoot(frame); + var msg = Message.READER.create(dec); + + try + { + switch (msg.which) + { + case Message.WHICH.Abort: + Logger.LogInformation($"Got 'abort' '{msg.Abort.TheType}' message from peer: {msg.Abort.Reason}"); + break; + + case Message.WHICH.Bootstrap: + ProcessBootstrap(msg.Bootstrap); + break; + + case Message.WHICH.Call: + ProcessCall(msg.Call); + break; + + case Message.WHICH.Disembargo: + ProcessDisembargo(msg.Disembargo); + break; + + case Message.WHICH.Finish: + ProcessFinish(msg.Finish); + break; + + case Message.WHICH.Release: + ProcessRelease(msg.Release); + break; + + case Message.WHICH.Resolve: + ProcessResolve(msg.Resolve); + break; + + case Message.WHICH.Return: + ProcessReturn(msg.Return); + break; + + case Message.WHICH.Unimplemented: + ProcessUnimplemented(msg.Unimplemented); + break; + + case Message.WHICH.Accept: + case Message.WHICH.Join: + case Message.WHICH.Provide: + Logger.LogWarning("Received level-3 message from peer. I don't support that."); + throw new RpcUnimplementedException(); + + case Message.WHICH.ObsoleteDelete: + case Message.WHICH.ObsoleteSave: + default: + Logger.LogWarning("Received unknown or unimplemented message from peer"); + throw new RpcUnimplementedException(); + } + } + catch (RpcUnimplementedException) + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var reply = mb.BuildRoot(); + reply.which = Message.WHICH.Unimplemented; + Reserializing.DeepCopy(msg, reply.Unimplemented.Rewrap()); + + Tx(mb.Frame); + } + catch (System.Exception exception) + { + Logger.LogError(exception, "Uncaught exception during message processing."); + + // A first intuition might be to send the caught exception message. But this is probably a bad idea: + // First, we send implementation specific details of a - maybe internal - error, not very valuable for the + // receiver. But worse: From a security point of view, we might even reveil a secret here. + SendAbort("Uncaught exception during RPC processing. This may also happen due to invalid input."); + + Dismiss(); + } + } + + ConsumedCapability ImportCap(CapDescriptor.READER capDesc) + { + lock (_reentrancyBlocker) + { + switch (capDesc.which) + { + case CapDescriptor.WHICH.SenderHosted: + if (_importTable.TryGetValue(capDesc.SenderHosted, out var rcw)) + { + if (rcw.Cap.TryGetTarget(out var impCap)) + { + rcw.AddRef(); + return impCap; + } + else + { + impCap = new ImportedCapability(this, capDesc.SenderHosted); + rcw.Cap.SetTarget(impCap); + } + + Debug.Assert(impCap != null); + return impCap; + } + else + { + var newCap = new ImportedCapability(this, capDesc.SenderHosted); + rcw = new RefCounted>( + new WeakReference(newCap)); + _importTable.Add(capDesc.SenderHosted, rcw); + Debug.Assert(newCap != null); + return newCap; + } + + case CapDescriptor.WHICH.SenderPromise: + if (_importTable.TryGetValue(capDesc.SenderPromise, out var rcwp)) + { + if (rcwp.Cap.TryGetTarget(out var impCap)) + { + rcwp.AddRef(); + return impCap; + } + else + { + impCap = new PromisedCapability(this, capDesc.SenderPromise); + rcwp.Cap.SetTarget(impCap); + } + + Debug.Assert(impCap != null); + return impCap; + } + else + { + var newCap = new PromisedCapability(this, capDesc.SenderPromise); + rcw = new RefCounted>( + new WeakReference(newCap)); + _importTable.Add(capDesc.SenderPromise, rcw); + Debug.Assert(newCap != null); + return newCap; + } + + case CapDescriptor.WHICH.ReceiverHosted: + if (_exportTable.TryGetValue(capDesc.ReceiverHosted, out var rc)) + { + Debug.Assert(rc.Cap != null); + return LocalCapability.Create(rc.Cap); + } + else + { + Logger.LogWarning("Peer refers to receiver-hosted capability which does not exist."); + return null; + } + + case CapDescriptor.WHICH.ReceiverAnswer: + if (_answerTable.TryGetValue(capDesc.ReceiverAnswer.QuestionId, out var pendingAnswer)) + { + var tcs = new TaskCompletionSource(); + + pendingAnswer.Chain(false, + capDesc.ReceiverAnswer, + async t => + { + try + { + var proxy = await t; + tcs.SetResult(proxy); + } + catch (TaskCanceledException) + { + tcs.SetCanceled(); + } + catch (System.Exception exception) + { + tcs.SetException(exception); + } + }); + + return new LazyCapability(tcs.Task); + } + else + { + Logger.LogWarning("Peer refers to pending answer which does not exist."); + return null; + } + + case CapDescriptor.WHICH.ThirdPartyHosted: + if (_importTable.TryGetValue(capDesc.ThirdPartyHosted.VineId, out var rcv)) + { + if (rcv.Cap.TryGetTarget(out var impCap)) + { + rcv.AddRef(); + return impCap; + } + else + { + impCap = new ImportedCapability(this, capDesc.ThirdPartyHosted.VineId); + rcv.Cap.SetTarget(impCap); + } + + Debug.Assert(impCap != null); + return impCap; + } + else + { + var newCap = new ImportedCapability(this, capDesc.ThirdPartyHosted.VineId); + rcv = new RefCounted>( + new WeakReference(newCap)); + Debug.Assert(newCap != null); + return newCap; + } + + default: + Logger.LogWarning("Unknown capability descriptor category"); + throw new RpcUnimplementedException(); + } + } + } + + public IReadOnlyList ImportCapTable(Payload.READER payload) + { + var list = new List(); + + if (payload.CapTable != null) + { + lock (_reentrancyBlocker) + { + foreach (var capDesc in payload.CapTable) + { + list.Add(ImportCap(capDesc)); + } + } + } + + return list; + } + + void IRpcEndpoint.RequestPostAction(Action postAction) + { + _exportCapTablePostActions.Value += postAction; + } + + void ExportCapTableAndSend( + SerializerState state, + Payload.WRITER payload) + { + Debug.Assert(_exportCapTablePostActions.Value == null); + _exportCapTablePostActions.Value = null; + + payload.CapTable.Init(state.MsgBuilder.Caps.Count); + + int i = 0; + foreach (var cap in state.MsgBuilder.Caps) + { + var capDesc = payload.CapTable[i++]; + + if (cap == null) + { + LazyCapability.Null.Export(this, capDesc); + } + else + { + cap.Export(this, capDesc); + cap.Release(); + } + } + + Tx(state.MsgBuilder.Frame); + + // The reason for this seemingly cumbersome postAction handling is as follows: + // If a sender-promise capability happens to resolve concurrently, we must not + // send the "resolve" message before even sending the sender-promise descriptor. + // To avoid that situation, calls to "ReExportCapWhenResolved" are queued (and + // therefore deferred) to the postAction. + + var pa = _exportCapTablePostActions.Value; + _exportCapTablePostActions.Value = null; + pa?.Invoke(); + } + + PendingQuestion IRpcEndpoint.BeginQuestion(ConsumedCapability target, SerializerState inParams) + { + var question = AllocateQuestion(target, inParams); + + if (_canDeferCalls.Value) + { + _tailCall.Value?.Send(); + _tailCall.Value = question; + } + else + { + question.Send(); + } + + return question; + } + + void IRpcEndpoint.SendQuestion(SerializerState inParams, Payload.WRITER payload) + { + ExportCapTableAndSend(inParams, payload); + } + + void Finish(uint questionId) + { + var mb = MessageBuilder.Create(); + var msg = mb.BuildRoot(); + msg.which = Message.WHICH.Finish; + msg.Finish.QuestionId = questionId; + msg.Finish.ReleaseResultCaps = false; + + try + { + Tx(mb.Frame); + } + catch (System.Exception exception) + { + Logger.LogWarning($"Unable to send 'finish' message: {exception.Message}"); + } + + // Note: Keep question ID in the table, since a "return" message with either "canceled" or + // "results" is still expected (at least according to the spec). + } + + void IRpcEndpoint.Finish(uint questionId) + { + Finish(questionId); + } + + void IRpcEndpoint.ReleaseImport(uint importId) + { + bool exists; + int count = 0; + + lock (_reentrancyBlocker) + { + exists = _importTable.TryGetValue(importId, out var rc); + if (rc != null) + { + count = rc.RefCount; + rc.ReleaseAll(); + } + } + + if (exists && count > 0) + { + var mb = MessageBuilder.Create(); + var msg = mb.BuildRoot(); + msg.which = Message.WHICH.Release; + msg.Release.Id = importId; + msg.Release.ReferenceCount = (uint)count; + + try + { + Tx(mb.Frame); + } + catch (RpcException exception) + { + Logger.LogWarning($"Unable to release import: {exception.InnerException.Message}"); + } + } + } + + void IRpcEndpoint.RemoveImport(uint importId) + { + bool exists; + + lock (_reentrancyBlocker) + { + exists = _importTable.Remove(importId); + } + + if (!exists) + { + Logger.LogError("Inconsistent import table detected"); + } + } + + Task IRpcEndpoint.RequestSenderLoopback(Action describe) + { + (var tcs, uint id) = AllocateDisembargo(); + + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var msg = mb.BuildRoot(); + msg.which = Message.WHICH.Disembargo; + describe(msg.Disembargo.Target); + var ctx = msg.Disembargo.Context; + ctx.which = Disembargo.context.WHICH.SenderLoopback; + ctx.SenderLoopback = id; + + Tx(mb.Frame); + + return tcs.Task; + } + + void IRpcEndpoint.DeleteQuestion(PendingQuestion question) + { + DeleteQuestion(question.QuestionId, question); + } + } + + readonly ConcurrentBag _inboundEndpoints = new ConcurrentBag(); + + internal RpcEndpoint AddEndpoint(IEndpoint outboundEndpoint) + { + var inboundEndpoint = new RpcEndpoint(this, outboundEndpoint); + _inboundEndpoints.Add(inboundEndpoint); + return inboundEndpoint; + } + + Skeleton _bootstrapCap; + + /// + /// Gets or sets the bootstrap capability. + /// + public Skeleton BootstrapCap + { + get => _bootstrapCap; + set + { + value?.Claim(); + _bootstrapCap?.Relinquish(); + _bootstrapCap = value; + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RpcException.cs b/Capnp.Net.Runtime/Rpc/RpcException.cs new file mode 100644 index 0000000..fdee0eb --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RpcException.cs @@ -0,0 +1,16 @@ +namespace Capnp.Rpc +{ + /// + /// Thrown when an RPC-related error condition occurs. + /// + public class RpcException : System.Exception + { + public RpcException(string message) : base(message) + { + } + + public RpcException(string message, System.Exception innerException) : base(message, innerException) + { + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/RpcUnimplementedException.cs b/Capnp.Net.Runtime/Rpc/RpcUnimplementedException.cs new file mode 100644 index 0000000..f700e34 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/RpcUnimplementedException.cs @@ -0,0 +1,6 @@ +namespace Capnp.Rpc +{ + class RpcUnimplementedException : System.Exception + { + } +} diff --git a/Capnp.Net.Runtime/Rpc/Skeleton.cs b/Capnp.Net.Runtime/Rpc/Skeleton.cs new file mode 100644 index 0000000..a0de624 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/Skeleton.cs @@ -0,0 +1,244 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// A skeleton is a wrapper around a capability interface implementation which adapts it in the way it is + /// expected by the . + /// + public abstract class Skeleton: IProvidedCapability + { + class SkeletonRelinquisher: IDisposable + { + readonly Skeleton _skeleton; + + public SkeletonRelinquisher(Skeleton skeleton) + { + _skeleton = skeleton; + } + + public void Dispose() + { + _skeleton.Relinquish(); + } + } + + static readonly ConditionalWeakTable _implMap = + new ConditionalWeakTable(); + + internal static Skeleton GetOrCreateSkeleton(T impl, bool addRef) + where T: class + { + if (impl is Skeleton skel) + return skel; + + skel = _implMap.GetValue(impl, _ => CapabilityReflection.CreateSkeleton(_)); + + if (addRef) + { + skel.Claim(); + } + + return skel; + } + + /// + /// Claims ownership on the given capability, preventing its automatic disposal. + /// + /// Capability interface + /// Capability implementation + /// A disposable object. Calling Dispose() on the returned instance relinquishes ownership again. + public static IDisposable Claim(T impl) where T: class + { + return new SkeletonRelinquisher(GetOrCreateSkeleton(impl, true)); + } + + int _refCount = 0; + + /// + /// Calls an interface method of this capability. + /// + /// ID of interface to call + /// ID of method to call + /// Method arguments ("params struct") + /// Cancellation token, indicating when the call should cancelled. + /// A Task which will resolve to the call result + public abstract Task Invoke(ulong interfaceId, ushort methodId, DeserializerState args, CancellationToken cancellationToken = default); + + internal void Claim() + { + Interlocked.Increment(ref _refCount); + } + + internal void Relinquish() + { + int count = Interlocked.Decrement(ref _refCount); + if (0 == count) + { + Dispose(true); + GC.SuppressFinalize(this); + } + } + + internal void Relinquish(int count) + { + if (count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + while (count-- > 0) + Relinquish(); + } + + /// + /// Dispose pattern implementation + /// + protected virtual void Dispose(bool disposing) + { + } + + ~Skeleton() + { + Dispose(false); + } + + internal virtual void Bind(object impl) + { + throw new NotSupportedException(); + } + } + + /// + /// Skeleton for a specific capability interface. + /// + /// Capability interface + public abstract class Skeleton : Skeleton, IMonoSkeleton + { +#if DebugEmbargos + ILogger Logger { get; } = Logging.CreateLogger>(); +#endif + + Func>[] _methods; + CancellationTokenSource _disposed = new CancellationTokenSource(); + readonly object _reentrancyBlocker = new object(); + int _pendingCalls; + + /// + /// Constructs an instance. + /// + public Skeleton() + { + } + + /// + /// Populates this skeleton's method table. The method table maps method IDs (which are consecutively numbered from 0 + /// onwards) to the underlying capability's method implementations. + /// + /// The method table. Index is method ID. + protected void SetMethodTable(params Func>[] methods) + { + _methods = methods; + } + + /// + /// Gets the underlying capability implementation. + /// + protected T Impl { get; private set; } + + /// + /// Gets the ID of the implemented interface. + /// + public abstract ulong InterfaceId { get; } + + /// + /// Calls an interface method of this capability. + /// + /// ID of interface to call + /// ID of method to call + /// Method arguments ("params struct") + /// Cancellation token, indicating when the call should cancelled. + /// A Task which will resolve to the call result + /// This Skeleton was disposed + public override async Task Invoke(ulong interfaceId, ushort methodId, DeserializerState args, CancellationToken cancellationToken = default) + { + if (InterfaceId != InterfaceId) + throw new NotImplementedException("Wrong interface id"); + + if (methodId >= _methods.Length) + throw new NotImplementedException("Wrong method id"); + + lock (_reentrancyBlocker) + { + if (_disposed == null || _disposed.IsCancellationRequested) + { + throw new ObjectDisposedException(nameof(Skeleton)); + } + + ++_pendingCalls; + } + + var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_disposed.Token, cancellationToken); + + try + { + return await _methods[methodId](args, linkedSource.Token); + } + catch (System.Exception) + { + throw; + } + finally + { + lock (_reentrancyBlocker) + { + --_pendingCalls; + } + + linkedSource.Dispose(); + CheckCtsDisposal(); + } + } + + void CheckCtsDisposal() + { + if (_pendingCalls == 0 && _disposed != null && _disposed.IsCancellationRequested) + { + _disposed.Dispose(); + _disposed = null; + } + } + + /// + /// Dispose pattern implementation + /// + protected override void Dispose(bool disposing) + { + lock (_reentrancyBlocker) + { + if (_disposed == null || _disposed.IsCancellationRequested) + return; + + _disposed.Cancel(); + + CheckCtsDisposal(); + } + + if (Impl is IDisposable disposable) + { + disposable.Dispose(); + } + } + + internal override void Bind(object impl) + { + if (Impl != null) + throw new InvalidOperationException("Skeleton was already bound"); + + Impl = (T)impl; + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/SkeletonAttribute.cs b/Capnp.Net.Runtime/Rpc/SkeletonAttribute.cs new file mode 100644 index 0000000..b8b01d6 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/SkeletonAttribute.cs @@ -0,0 +1,34 @@ +using System; + +namespace Capnp.Rpc +{ + /// + /// Annotates a capability interface with its Skeleton implementation. + /// + [AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = true)] + public class SkeletonAttribute: Attribute + { + /// + /// Constructs this attribute. + /// + /// Skeleton type. This must be a class which inherits from and + /// exposes a public parameterless constructor. Moreover, it must have same amount of generic type + /// parameters like the annotated interface, with identical generic constraints. + /// is null. + public SkeletonAttribute(Type skeletonClass) + { + if (skeletonClass == null) + throw new ArgumentNullException(nameof(skeletonClass)); + + if (!typeof(Skeleton).IsAssignableFrom(skeletonClass)) + throw new ArgumentException("Must inherit from Skeleton"); + + SkeletonClass = skeletonClass; + } + + /// + /// Gets the skeleton type. + /// + public Type SkeletonClass { get; } + } +} diff --git a/Capnp.Net.Runtime/Rpc/TcpRpcClient.cs b/Capnp.Net.Runtime/Rpc/TcpRpcClient.cs new file mode 100644 index 0000000..89b2cbb --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/TcpRpcClient.cs @@ -0,0 +1,184 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// TCP-based RPC implementation which will establish a connection to a TCP server implementing + /// the Cap'n Proto RPC protocol. + /// + public class TcpRpcClient: IDisposable + { + ILogger Logger { get; } = Logging.CreateLogger(); + + class OutboundTcpEndpoint : IEndpoint + { + readonly TcpRpcClient _client; + readonly FramePump _pump; + + public OutboundTcpEndpoint(TcpRpcClient client, FramePump pump) + { + _client = client; + _pump = pump; + } + + public void Dismiss() + { + _pump.Dispose(); + } + + public void Forward(WireFrame frame) + { + _pump.Send(frame); + } + } + + readonly RpcEngine _rpcEngine; + readonly TcpClient _client; + RpcEngine.RpcEndpoint _inboundEndpoint; + OutboundTcpEndpoint _outboundEndpoint; + FramePump _pump; + Thread _pumpThread; + + /// + /// Gets a Task which completes when TCP is connected. + /// + public Task WhenConnected { get; } + + async Task ConnectAsync(string host, int port) + { + try + { + await _client.ConnectAsync(host, port); + } + catch (SocketException exception) + { + throw new RpcException("TcpRpcClient is unable to connect", exception); + } + + } + async Task Connect(string host, int port) + { + await ConnectAsync(host, port); + + _pump = new FramePump(_client.GetStream()); + _outboundEndpoint = new OutboundTcpEndpoint(this, _pump); + _inboundEndpoint = _rpcEngine.AddEndpoint(_outboundEndpoint); + _pumpThread = new Thread(() => + { + try + { + Thread.CurrentThread.Name = $"TCP RPC Client Thread {Thread.CurrentThread.ManagedThreadId}"; + + _pump.Run(); + } + finally + { + _outboundEndpoint.Dismiss(); + _inboundEndpoint.Dismiss(); + _pump.Dispose(); + } + }); + + _pump.FrameReceived += _inboundEndpoint.Forward; + _pumpThread.Start(); + } + + /// + /// Constructs an instance and attempts to connect it to given host. + /// + /// The DNS name of the remote RPC host + /// The port number of the remote RPC host + /// is null. + /// is not between System.Net.IPEndPoint.MinPort and System.Net.IPEndPoint.MaxPort. + /// An error occurred when accessing the socket. + public TcpRpcClient(string host, int port) + { + _rpcEngine = new RpcEngine(); + _client = new TcpClient(); + + WhenConnected = Connect(host, port); + } + + /// + /// Returns the remote bootstrap capability. + /// + /// Bootstrap capability interface + /// A proxy for the bootstrap capability + public TProxy GetMain() where TProxy: class + { + if (!WhenConnected.IsCompleted) + { + throw new InvalidOperationException("Connection not yet established"); + } + + if (!WhenConnected.IsCompletedSuccessfully) + { + throw new InvalidOperationException("Connection not successfully established"); + } + + Debug.Assert(_inboundEndpoint != null); + + return CapabilityReflection.CreateProxy(_inboundEndpoint.QueryMain()) as TProxy; + } + + /// + /// Dispose pattern implementation + /// + public void Dispose() + { + _client.Dispose(); + + try + { + if (!WhenConnected.Wait(500)) + { + Logger.LogError("Unable to join connection task within timeout"); + } + } + catch (System.Exception) + { + } + + if (_pumpThread != null && !_pumpThread.Join(500)) + { + Logger.LogError("Unable to join pump thread within timeout"); + } + + GC.SuppressFinalize(this); + } + + /// + /// Gets the number of RPC protocol messages sent by this client so far. + /// + public long SendCount => _inboundEndpoint.SendCount; + + /// + /// Gets the number of RPC protocol messages received by this client so far. + /// + public long RecvCount => _inboundEndpoint.RecvCount; + + /// + /// Gets the remote port number which this client is connected to, + /// or null if the connection is not yet established. + /// + public int? RemotePort => ((IPEndPoint)_client.Client?.RemoteEndPoint)?.Port; + + /// + /// Whether the I/O thread is currently running + /// + public bool IsComputing => _pumpThread.ThreadState == System.Threading.ThreadState.Running; + + /// + /// Whether the I/O thread is waiting for data to receive + /// + public bool IsWaitingForData => _pump.IsWaitingForData; + } +} diff --git a/Capnp.Net.Runtime/Rpc/TcpRpcServer.cs b/Capnp.Net.Runtime/Rpc/TcpRpcServer.cs new file mode 100644 index 0000000..e5dc638 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/TcpRpcServer.cs @@ -0,0 +1,232 @@ +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Sockets; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + /// + /// Cap'n Proto RPC TCP server. + /// + public class TcpRpcServer: IDisposable + { + public interface IConnection + { + int LocalPort { get; } + long RecvCount { get; } + long SendCount { get; } + bool IsComputing { get; } + bool IsWaitingForData { get; } + } + + ILogger Logger { get; } = Logging.CreateLogger(); + + class OutboundTcpEndpoint : IEndpoint + { + readonly TcpRpcServer _server; + readonly FramePump _pump; + + public OutboundTcpEndpoint(TcpRpcServer server, FramePump pump) + { + _server = server; + _pump = pump; + } + + public void Dismiss() + { + _pump.Dispose(); + } + + public void Forward(WireFrame frame) + { + _pump.Send(frame); + } + } + + class Connection: IConnection + { + public Connection(TcpRpcServer server, TcpClient client, FramePump pump, OutboundTcpEndpoint outboundEp, RpcEngine.RpcEndpoint inboundEp) + { + Client = client; + Pump = pump; + OutboundEp = outboundEp; + InboundEp = inboundEp; + + PumpRunner = new Thread(o => + { + try + { + Thread.CurrentThread.Name = $"TCP RPC Server Thread {Thread.CurrentThread.ManagedThreadId}"; + + Pump.Run(); + } + finally + { + OutboundEp.Dismiss(); + InboundEp.Dismiss(); + Pump.Dispose(); + lock (server._reentrancyBlocker) + { + --server.ConnectionCount; + server._connections.Remove(this); + } + } + }); + } + + public TcpClient Client { get; private set; } + public FramePump Pump { get; private set; } + public OutboundTcpEndpoint OutboundEp { get; private set; } + public RpcEngine.RpcEndpoint InboundEp { get; private set; } + public Thread PumpRunner { get; private set; } + public int LocalPort => ((IPEndPoint)Client.Client.LocalEndPoint).Port; + public long RecvCount => InboundEp.RecvCount; + public long SendCount => InboundEp.SendCount; + public bool IsComputing => PumpRunner.ThreadState == ThreadState.Running; + public bool IsWaitingForData => Pump.IsWaitingForData; + } + + readonly RpcEngine _rpcEngine; + readonly TcpListener _listener; + readonly object _reentrancyBlocker = new object(); + readonly Thread _acceptorThread; + readonly List _connections = new List(); + + /// + /// Gets the number of currently active inbound TCP connections. + /// + public int ConnectionCount { get; private set; } + + void AcceptClients() + { + try + { + if (Thread.CurrentThread.Name == null) + Thread.CurrentThread.Name = $"TCP RPC Acceptor Thread {Thread.CurrentThread.ManagedThreadId}"; + + while (true) + { + var client = _listener.AcceptTcpClient(); + var pump = new FramePump(client.GetStream()); + var outboundEndpoint = new OutboundTcpEndpoint(this, pump); + var inboundEndpoint = _rpcEngine.AddEndpoint(outboundEndpoint); + pump.FrameReceived += inboundEndpoint.Forward; + + var connection = new Connection(this, client, pump, outboundEndpoint, inboundEndpoint); + + lock (_reentrancyBlocker) + { + ++ConnectionCount; + _connections.Add(connection); + } + + connection.PumpRunner.Start(); + } + } + catch (SocketException) + { + // Listener was stopped. Maybe a little bit rude, but this is + // our way of shutting down the acceptor thread. + } + catch (System.Exception exception) + { + // Any other exception might be due to some other problem. + Logger.LogError(exception.Message); + } + } + + /// + /// Stops accepting incoming attempts and closes all existing connections. + /// + public void Dispose() + { + try + { + _listener.Stop(); + } + catch (SocketException) + { + } + + var connections = new List(); + + lock (_reentrancyBlocker) + { + connections.AddRange(_connections); + } + + foreach (var connection in connections) + { + connection.Client.Dispose(); + connection.Pump.Dispose(); + if (!connection.PumpRunner.Join(500)) + { + Logger.LogError("Unable to join frame pumping thread within timeout"); + } + } + + if (!_acceptorThread.Join(500)) + { + Logger.LogError("Unable to join TCP acceptor thread within timeout"); + } + + GC.SuppressFinalize(this); + } + + /// + /// Constructs an instance. + /// + /// An System.Net.IPAddress that represents the local IP address. + /// The port on which to listen for incoming connection attempts. + /// is null. + /// is not between System.Net.IPEndPoint.MinPort and System.Net.IPEndPoint.MaxPort. + public TcpRpcServer(IPAddress localAddr, int port) + { + _rpcEngine = new RpcEngine(); + _listener = new TcpListener(localAddr, port); + _listener.Start(); + + _acceptorThread = new Thread(() => + { + AcceptClients(); + }); + + _acceptorThread.Start(); + } + + /// + /// Whether the thread which is responsible for acception incoming attempts is still alive. + /// The thread will die upon disposal, but also in case of a socket error condition. + /// Errors which occur on a particular connection will just close that connection and won't interfere + /// with the acceptor thread. + /// + public bool IsAlive => _acceptorThread.IsAlive; + + /// + /// Sets the bootstrap capability. It must be an object which implements a valid capability interface + /// (). + /// + public object Main + { + set { _rpcEngine.BootstrapCap = Skeleton.GetOrCreateSkeleton(value, false); } + } + + /// + /// Gets a snapshot of currently active connections. + /// + public IConnection[] Connections + { + get + { + lock (_reentrancyBlocker) + { + return _connections.ToArray(); + } + } + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/Vine.cs b/Capnp.Net.Runtime/Rpc/Vine.cs new file mode 100644 index 0000000..7c661a3 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/Vine.cs @@ -0,0 +1,66 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + class Vine : Skeleton + { + public static Skeleton Create(ConsumedCapability cap) + { + if (cap is LocalCapability lcap) + return lcap.ProvidedCap; + else + return new Vine(cap); + } + + Vine(ConsumedCapability consumedCap) + { + Proxy = new Proxy(consumedCap ?? throw new ArgumentNullException(nameof(consumedCap))); + } + + internal override void Bind(object impl) + { + throw new NotImplementedException(); + } + + public Proxy Proxy { get; } + + public async override Task Invoke( + ulong interfaceId, ushort methodId, DeserializerState args, + CancellationToken cancellationToken = default) + { + var promisedAnswer = Proxy.Call(interfaceId, methodId, (DynamicSerializerState)args, false); + + if (promisedAnswer is PendingQuestion pendingQuestion && pendingQuestion.RpcEndpoint == Impatient.AskingEndpoint) + { + async void SetupCancellation() + { + using (var registration = cancellationToken.Register(promisedAnswer.Dispose)) + { + await promisedAnswer.WhenReturned; + } + } + + SetupCancellation(); + + return pendingQuestion; + } + else + { + using (var registration = cancellationToken.Register(promisedAnswer.Dispose)) + { + return (DynamicSerializerState)await promisedAnswer.WhenReturned; + } + } + } + + protected override void Dispose(bool disposing) + { + Proxy.Dispose(); + base.Dispose(disposing); + } + } +} diff --git a/Capnp.Net.Runtime/Rpc/rpc.cs b/Capnp.Net.Runtime/Rpc/rpc.cs new file mode 100644 index 0000000..35b0269 --- /dev/null +++ b/Capnp.Net.Runtime/Rpc/rpc.cs @@ -0,0 +1,2641 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + public class Message : ICapnpSerializable + { + public enum WHICH : ushort + { + Unimplemented = 0, + Abort = 1, + Call = 2, + Return = 3, + Finish = 4, + Resolve = 5, + Release = 6, + ObsoleteSave = 7, + Bootstrap = 8, + ObsoleteDelete = 9, + Provide = 10, + Accept = 11, + Join = 12, + Disembargo = 13, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Unimplemented: + Unimplemented = CapnpSerializable.Create(reader.Unimplemented); + break; + case WHICH.Abort: + Abort = CapnpSerializable.Create(reader.Abort); + break; + case WHICH.Call: + Call = CapnpSerializable.Create(reader.Call); + break; + case WHICH.Return: + Return = CapnpSerializable.Create(reader.Return); + break; + case WHICH.Finish: + Finish = CapnpSerializable.Create(reader.Finish); + break; + case WHICH.Resolve: + Resolve = CapnpSerializable.Create(reader.Resolve); + break; + case WHICH.Release: + Release = CapnpSerializable.Create(reader.Release); + break; + case WHICH.ObsoleteSave: + ObsoleteSave = CapnpSerializable.Create(reader.ObsoleteSave); + break; + case WHICH.Bootstrap: + Bootstrap = CapnpSerializable.Create(reader.Bootstrap); + break; + case WHICH.ObsoleteDelete: + ObsoleteDelete = CapnpSerializable.Create(reader.ObsoleteDelete); + break; + case WHICH.Provide: + Provide = CapnpSerializable.Create(reader.Provide); + break; + case WHICH.Accept: + Accept = CapnpSerializable.Create(reader.Accept); + break; + case WHICH.Join: + Join = CapnpSerializable.Create(reader.Join); + break; + case WHICH.Disembargo: + Disembargo = CapnpSerializable.Create(reader.Disembargo); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Unimplemented: + _content = null; + break; + case WHICH.Abort: + _content = null; + break; + case WHICH.Call: + _content = null; + break; + case WHICH.Return: + _content = null; + break; + case WHICH.Finish: + _content = null; + break; + case WHICH.Resolve: + _content = null; + break; + case WHICH.Release: + _content = null; + break; + case WHICH.ObsoleteSave: + _content = null; + break; + case WHICH.Bootstrap: + _content = null; + break; + case WHICH.ObsoleteDelete: + _content = null; + break; + case WHICH.Provide: + _content = null; + break; + case WHICH.Accept: + _content = null; + break; + case WHICH.Join: + _content = null; + break; + case WHICH.Disembargo: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Unimplemented: + Unimplemented?.serialize(writer.Unimplemented); + break; + case WHICH.Abort: + Abort?.serialize(writer.Abort); + break; + case WHICH.Call: + Call?.serialize(writer.Call); + break; + case WHICH.Return: + Return?.serialize(writer.Return); + break; + case WHICH.Finish: + Finish?.serialize(writer.Finish); + break; + case WHICH.Resolve: + Resolve?.serialize(writer.Resolve); + break; + case WHICH.Release: + Release?.serialize(writer.Release); + break; + case WHICH.ObsoleteSave: + writer.ObsoleteSave.SetObject(ObsoleteSave); + break; + case WHICH.Bootstrap: + Bootstrap?.serialize(writer.Bootstrap); + break; + case WHICH.ObsoleteDelete: + writer.ObsoleteDelete.SetObject(ObsoleteDelete); + break; + case WHICH.Provide: + Provide?.serialize(writer.Provide); + break; + case WHICH.Accept: + Accept?.serialize(writer.Accept); + break; + case WHICH.Join: + Join?.serialize(writer.Join); + break; + case WHICH.Disembargo: + Disembargo?.serialize(writer.Disembargo); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Rpc.Message Unimplemented + { + get => _which == WHICH.Unimplemented ? (Capnp.Rpc.Message)_content : null; + set + { + _which = WHICH.Unimplemented; + _content = value; + } + } + + public Capnp.Rpc.Exception Abort + { + get => _which == WHICH.Abort ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Abort; + _content = value; + } + } + + public Capnp.Rpc.Call Call + { + get => _which == WHICH.Call ? (Capnp.Rpc.Call)_content : null; + set + { + _which = WHICH.Call; + _content = value; + } + } + + public Capnp.Rpc.Return Return + { + get => _which == WHICH.Return ? (Capnp.Rpc.Return)_content : null; + set + { + _which = WHICH.Return; + _content = value; + } + } + + public Capnp.Rpc.Finish Finish + { + get => _which == WHICH.Finish ? (Capnp.Rpc.Finish)_content : null; + set + { + _which = WHICH.Finish; + _content = value; + } + } + + public Capnp.Rpc.Resolve Resolve + { + get => _which == WHICH.Resolve ? (Capnp.Rpc.Resolve)_content : null; + set + { + _which = WHICH.Resolve; + _content = value; + } + } + + public Capnp.Rpc.Release Release + { + get => _which == WHICH.Release ? (Capnp.Rpc.Release)_content : null; + set + { + _which = WHICH.Release; + _content = value; + } + } + + public AnyPointer ObsoleteSave + { + get => _which == WHICH.ObsoleteSave ? (AnyPointer)_content : null; + set + { + _which = WHICH.ObsoleteSave; + _content = value; + } + } + + public Capnp.Rpc.Bootstrap Bootstrap + { + get => _which == WHICH.Bootstrap ? (Capnp.Rpc.Bootstrap)_content : null; + set + { + _which = WHICH.Bootstrap; + _content = value; + } + } + + public AnyPointer ObsoleteDelete + { + get => _which == WHICH.ObsoleteDelete ? (AnyPointer)_content : null; + set + { + _which = WHICH.ObsoleteDelete; + _content = value; + } + } + + public Capnp.Rpc.Provide Provide + { + get => _which == WHICH.Provide ? (Capnp.Rpc.Provide)_content : null; + set + { + _which = WHICH.Provide; + _content = value; + } + } + + public Capnp.Rpc.Accept Accept + { + get => _which == WHICH.Accept ? (Capnp.Rpc.Accept)_content : null; + set + { + _which = WHICH.Accept; + _content = value; + } + } + + public Capnp.Rpc.Join Join + { + get => _which == WHICH.Join ? (Capnp.Rpc.Join)_content : null; + set + { + _which = WHICH.Join; + _content = value; + } + } + + public Capnp.Rpc.Disembargo Disembargo + { + get => _which == WHICH.Disembargo ? (Capnp.Rpc.Disembargo)_content : null; + set + { + _which = WHICH.Disembargo; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public Capnp.Rpc.Message.READER Unimplemented => which == WHICH.Unimplemented ? ctx.ReadStruct(0, Capnp.Rpc.Message.READER.create) : default; + public Capnp.Rpc.Exception.READER Abort => which == WHICH.Abort ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + public Capnp.Rpc.Call.READER Call => which == WHICH.Call ? ctx.ReadStruct(0, Capnp.Rpc.Call.READER.create) : default; + public Capnp.Rpc.Return.READER Return => which == WHICH.Return ? ctx.ReadStruct(0, Capnp.Rpc.Return.READER.create) : default; + public Capnp.Rpc.Finish.READER Finish => which == WHICH.Finish ? ctx.ReadStruct(0, Capnp.Rpc.Finish.READER.create) : default; + public Capnp.Rpc.Resolve.READER Resolve => which == WHICH.Resolve ? ctx.ReadStruct(0, Capnp.Rpc.Resolve.READER.create) : default; + public Capnp.Rpc.Release.READER Release => which == WHICH.Release ? ctx.ReadStruct(0, Capnp.Rpc.Release.READER.create) : default; + public DeserializerState ObsoleteSave => which == WHICH.ObsoleteSave ? ctx.StructReadPointer(0) : default; + public Capnp.Rpc.Bootstrap.READER Bootstrap => which == WHICH.Bootstrap ? ctx.ReadStruct(0, Capnp.Rpc.Bootstrap.READER.create) : default; + public DeserializerState ObsoleteDelete => which == WHICH.ObsoleteDelete ? ctx.StructReadPointer(0) : default; + public Capnp.Rpc.Provide.READER Provide => which == WHICH.Provide ? ctx.ReadStruct(0, Capnp.Rpc.Provide.READER.create) : default; + public Capnp.Rpc.Accept.READER Accept => which == WHICH.Accept ? ctx.ReadStruct(0, Capnp.Rpc.Accept.READER.create) : default; + public Capnp.Rpc.Join.READER Join => which == WHICH.Join ? ctx.ReadStruct(0, Capnp.Rpc.Join.READER.create) : default; + public Capnp.Rpc.Disembargo.READER Disembargo => which == WHICH.Disembargo ? ctx.ReadStruct(0, Capnp.Rpc.Disembargo.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public Capnp.Rpc.Message.WRITER Unimplemented + { + get => which == WHICH.Unimplemented ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Abort + { + get => which == WHICH.Abort ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Call.WRITER Call + { + get => which == WHICH.Call ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Return.WRITER Return + { + get => which == WHICH.Return ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Finish.WRITER Finish + { + get => which == WHICH.Finish ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Resolve.WRITER Resolve + { + get => which == WHICH.Resolve ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Release.WRITER Release + { + get => which == WHICH.Release ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState ObsoleteSave + { + get => which == WHICH.ObsoleteSave ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Bootstrap.WRITER Bootstrap + { + get => which == WHICH.Bootstrap ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState ObsoleteDelete + { + get => which == WHICH.ObsoleteDelete ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Provide.WRITER Provide + { + get => which == WHICH.Provide ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Accept.WRITER Accept + { + get => which == WHICH.Accept ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Join.WRITER Join + { + get => which == WHICH.Join ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Disembargo.WRITER Disembargo + { + get => which == WHICH.Disembargo ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Bootstrap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + DeprecatedObjectId = CapnpSerializable.Create(reader.DeprecatedObjectId); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.DeprecatedObjectId.SetObject(DeprecatedObjectId); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public AnyPointer DeprecatedObjectId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public DeserializerState DeprecatedObjectId => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public DynamicSerializerState DeprecatedObjectId + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class Call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + InterfaceId = reader.InterfaceId; + MethodId = reader.MethodId; + Params = CapnpSerializable.Create(reader.Params); + SendResultsTo = CapnpSerializable.Create(reader.SendResultsTo); + AllowThirdPartyTailCall = reader.AllowThirdPartyTailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.InterfaceId = InterfaceId; + writer.MethodId = MethodId; + Params?.serialize(writer.Params); + SendResultsTo?.serialize(writer.SendResultsTo); + writer.AllowThirdPartyTailCall = AllowThirdPartyTailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public ulong InterfaceId + { + get; + set; + } + + public ushort MethodId + { + get; + set; + } + + public Capnp.Rpc.Payload Params + { + get; + set; + } + + public Capnp.Rpc.Call.@sendResultsTo SendResultsTo + { + get; + set; + } + + public bool AllowThirdPartyTailCall + { + get; + set; + } + + = false; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public ulong InterfaceId => ctx.ReadDataULong(64UL, 0UL); + public ushort MethodId => ctx.ReadDataUShort(32UL, (ushort)0); + public Capnp.Rpc.Payload.READER Params => ctx.ReadStruct(1, Capnp.Rpc.Payload.READER.create); + public @sendResultsTo.READER SendResultsTo => new @sendResultsTo.READER(ctx); + public bool AllowThirdPartyTailCall => ctx.ReadDataBool(128UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 3); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public ulong InterfaceId + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public ushort MethodId + { + get => this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, value, (ushort)0); + } + + public Capnp.Rpc.Payload.WRITER Params + { + get => BuildPointer(1); + set => Link(1, value); + } + + public @sendResultsTo.WRITER SendResultsTo + { + get => Rewrap<@sendResultsTo.WRITER>(); + } + + public bool AllowThirdPartyTailCall + { + get => this.ReadDataBool(128UL, false); + set => this.WriteData(128UL, value, false); + } + } + + public class @sendResultsTo : ICapnpSerializable + { + public enum WHICH : ushort + { + Caller = 0, + Yourself = 1, + ThirdParty = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Caller: + which = reader.which; + break; + case WHICH.Yourself: + which = reader.which; + break; + case WHICH.ThirdParty: + ThirdParty = CapnpSerializable.Create(reader.ThirdParty); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Caller: + break; + case WHICH.Yourself: + break; + case WHICH.ThirdParty: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Caller: + break; + case WHICH.Yourself: + break; + case WHICH.ThirdParty: + writer.ThirdParty.SetObject(ThirdParty); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer ThirdParty + { + get => _which == WHICH.ThirdParty ? (AnyPointer)_content : null; + set + { + _which = WHICH.ThirdParty; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public DeserializerState ThirdParty => which == WHICH.ThirdParty ? ctx.StructReadPointer(2) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState ThirdParty + { + get => which == WHICH.ThirdParty ? BuildPointer(2) : default; + set => Link(2, value); + } + } + } + } + + public class Return : ICapnpSerializable + { + public enum WHICH : ushort + { + Results = 0, + Exception = 1, + Canceled = 2, + ResultsSentElsewhere = 3, + TakeFromOtherQuestion = 4, + AcceptFromThirdParty = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Results: + Results = CapnpSerializable.Create(reader.Results); + break; + case WHICH.Exception: + Exception = CapnpSerializable.Create(reader.Exception); + break; + case WHICH.Canceled: + which = reader.which; + break; + case WHICH.ResultsSentElsewhere: + which = reader.which; + break; + case WHICH.TakeFromOtherQuestion: + TakeFromOtherQuestion = reader.TakeFromOtherQuestion; + break; + case WHICH.AcceptFromThirdParty: + AcceptFromThirdParty = CapnpSerializable.Create(reader.AcceptFromThirdParty); + break; + } + + AnswerId = reader.AnswerId; + ReleaseParamCaps = reader.ReleaseParamCaps; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Results: + _content = null; + break; + case WHICH.Exception: + _content = null; + break; + case WHICH.Canceled: + break; + case WHICH.ResultsSentElsewhere: + break; + case WHICH.TakeFromOtherQuestion: + _content = 0; + break; + case WHICH.AcceptFromThirdParty: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Results: + Results?.serialize(writer.Results); + break; + case WHICH.Exception: + Exception?.serialize(writer.Exception); + break; + case WHICH.Canceled: + break; + case WHICH.ResultsSentElsewhere: + break; + case WHICH.TakeFromOtherQuestion: + writer.TakeFromOtherQuestion = TakeFromOtherQuestion.Value; + break; + case WHICH.AcceptFromThirdParty: + writer.AcceptFromThirdParty.SetObject(AcceptFromThirdParty); + break; + } + + writer.AnswerId = AnswerId; + writer.ReleaseParamCaps = ReleaseParamCaps; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint AnswerId + { + get; + set; + } + + public bool ReleaseParamCaps + { + get; + set; + } + + = true; + public Capnp.Rpc.Payload Results + { + get => _which == WHICH.Results ? (Capnp.Rpc.Payload)_content : null; + set + { + _which = WHICH.Results; + _content = value; + } + } + + public Capnp.Rpc.Exception Exception + { + get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Exception; + _content = value; + } + } + + public uint? TakeFromOtherQuestion + { + get => _which == WHICH.TakeFromOtherQuestion ? (uint? )_content : null; + set + { + _which = WHICH.TakeFromOtherQuestion; + _content = value; + } + } + + public AnyPointer AcceptFromThirdParty + { + get => _which == WHICH.AcceptFromThirdParty ? (AnyPointer)_content : null; + set + { + _which = WHICH.AcceptFromThirdParty; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public uint AnswerId => ctx.ReadDataUInt(0UL, 0U); + public bool ReleaseParamCaps => ctx.ReadDataBool(32UL, true); + public Capnp.Rpc.Payload.READER Results => which == WHICH.Results ? ctx.ReadStruct(0, Capnp.Rpc.Payload.READER.create) : default; + public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + public uint TakeFromOtherQuestion => which == WHICH.TakeFromOtherQuestion ? ctx.ReadDataUInt(64UL, 0U) : default; + public DeserializerState AcceptFromThirdParty => which == WHICH.AcceptFromThirdParty ? ctx.StructReadPointer(0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public uint AnswerId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool ReleaseParamCaps + { + get => this.ReadDataBool(32UL, true); + set => this.WriteData(32UL, value, true); + } + + public Capnp.Rpc.Payload.WRITER Results + { + get => which == WHICH.Results ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Exception + { + get => which == WHICH.Exception ? BuildPointer(0) : default; + set => Link(0, value); + } + + public uint TakeFromOtherQuestion + { + get => which == WHICH.TakeFromOtherQuestion ? this.ReadDataUInt(64UL, 0U) : default; + set => this.WriteData(64UL, value, 0U); + } + + public DynamicSerializerState AcceptFromThirdParty + { + get => which == WHICH.AcceptFromThirdParty ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Finish : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + ReleaseResultCaps = reader.ReleaseResultCaps; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.ReleaseResultCaps = ReleaseResultCaps; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public bool ReleaseResultCaps + { + get; + set; + } + + = true; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public bool ReleaseResultCaps => ctx.ReadDataBool(32UL, true); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool ReleaseResultCaps + { + get => this.ReadDataBool(32UL, true); + set => this.WriteData(32UL, value, true); + } + } + } + + public class Resolve : ICapnpSerializable + { + public enum WHICH : ushort + { + Cap = 0, + Exception = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Cap: + Cap = CapnpSerializable.Create(reader.Cap); + break; + case WHICH.Exception: + Exception = CapnpSerializable.Create(reader.Exception); + break; + } + + PromiseId = reader.PromiseId; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Cap: + _content = null; + break; + case WHICH.Exception: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Cap: + Cap?.serialize(writer.Cap); + break; + case WHICH.Exception: + Exception?.serialize(writer.Exception); + break; + } + + writer.PromiseId = PromiseId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint PromiseId + { + get; + set; + } + + public Capnp.Rpc.CapDescriptor Cap + { + get => _which == WHICH.Cap ? (Capnp.Rpc.CapDescriptor)_content : null; + set + { + _which = WHICH.Cap; + _content = value; + } + } + + public Capnp.Rpc.Exception Exception + { + get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Exception; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint PromiseId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.CapDescriptor.READER Cap => which == WHICH.Cap ? ctx.ReadStruct(0, Capnp.Rpc.CapDescriptor.READER.create) : default; + public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint PromiseId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.CapDescriptor.WRITER Cap + { + get => which == WHICH.Cap ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Exception + { + get => which == WHICH.Exception ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Release : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + ReferenceCount = reader.ReferenceCount; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.ReferenceCount = ReferenceCount; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Id + { + get; + set; + } + + public uint ReferenceCount + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Id => ctx.ReadDataUInt(0UL, 0U); + public uint ReferenceCount => ctx.ReadDataUInt(32UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint Id + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public uint ReferenceCount + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + } + } + + public class Disembargo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Target = CapnpSerializable.Create(reader.Target); + Context = CapnpSerializable.Create(reader.Context); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Target?.serialize(writer.Target); + Context?.serialize(writer.Context); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public Capnp.Rpc.Disembargo.@context Context + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public @context.READER Context => new @context.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public @context.WRITER Context + { + get => Rewrap<@context.WRITER>(); + } + } + + public class @context : ICapnpSerializable + { + public enum WHICH : ushort + { + SenderLoopback = 0, + ReceiverLoopback = 1, + Accept = 2, + Provide = 3, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.SenderLoopback: + SenderLoopback = reader.SenderLoopback; + break; + case WHICH.ReceiverLoopback: + ReceiverLoopback = reader.ReceiverLoopback; + break; + case WHICH.Accept: + which = reader.which; + break; + case WHICH.Provide: + Provide = reader.Provide; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.SenderLoopback: + _content = 0; + break; + case WHICH.ReceiverLoopback: + _content = 0; + break; + case WHICH.Accept: + break; + case WHICH.Provide: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.SenderLoopback: + writer.SenderLoopback = SenderLoopback.Value; + break; + case WHICH.ReceiverLoopback: + writer.ReceiverLoopback = ReceiverLoopback.Value; + break; + case WHICH.Accept: + break; + case WHICH.Provide: + writer.Provide = Provide.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? SenderLoopback + { + get => _which == WHICH.SenderLoopback ? (uint? )_content : null; + set + { + _which = WHICH.SenderLoopback; + _content = value; + } + } + + public uint? ReceiverLoopback + { + get => _which == WHICH.ReceiverLoopback ? (uint? )_content : null; + set + { + _which = WHICH.ReceiverLoopback; + _content = value; + } + } + + public uint? Provide + { + get => _which == WHICH.Provide ? (uint? )_content : null; + set + { + _which = WHICH.Provide; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint SenderLoopback => which == WHICH.SenderLoopback ? ctx.ReadDataUInt(0UL, 0U) : default; + public uint ReceiverLoopback => which == WHICH.ReceiverLoopback ? ctx.ReadDataUInt(0UL, 0U) : default; + public uint Provide => which == WHICH.Provide ? ctx.ReadDataUInt(0UL, 0U) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint SenderLoopback + { + get => which == WHICH.SenderLoopback ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public uint ReceiverLoopback + { + get => which == WHICH.ReceiverLoopback ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public uint Provide + { + get => which == WHICH.Provide ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + } + } + } + + public class Provide : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + Recipient = CapnpSerializable.Create(reader.Recipient); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.Recipient.SetObject(Recipient); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public AnyPointer Recipient + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public DeserializerState Recipient => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Recipient + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Accept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Provision = CapnpSerializable.Create(reader.Provision); + Embargo = reader.Embargo; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.Provision.SetObject(Provision); + writer.Embargo = Embargo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public AnyPointer Provision + { + get; + set; + } + + public bool Embargo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public DeserializerState Provision => ctx.StructReadPointer(0); + public bool Embargo => ctx.ReadDataBool(32UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public DynamicSerializerState Provision + { + get => BuildPointer(0); + set => Link(0, value); + } + + public bool Embargo + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + } + } + + public class Join : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + KeyPart = CapnpSerializable.Create(reader.KeyPart); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.KeyPart.SetObject(KeyPart); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public AnyPointer KeyPart + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public DeserializerState KeyPart => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState KeyPart + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class MessageTarget : ICapnpSerializable + { + public enum WHICH : ushort + { + ImportedCap = 0, + PromisedAnswer = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.ImportedCap: + ImportedCap = reader.ImportedCap; + break; + case WHICH.PromisedAnswer: + PromisedAnswer = CapnpSerializable.Create(reader.PromisedAnswer); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.ImportedCap: + _content = 0; + break; + case WHICH.PromisedAnswer: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.ImportedCap: + writer.ImportedCap = ImportedCap.Value; + break; + case WHICH.PromisedAnswer: + PromisedAnswer?.serialize(writer.PromisedAnswer); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? ImportedCap + { + get => _which == WHICH.ImportedCap ? (uint? )_content : null; + set + { + _which = WHICH.ImportedCap; + _content = value; + } + } + + public Capnp.Rpc.PromisedAnswer PromisedAnswer + { + get => _which == WHICH.PromisedAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null; + set + { + _which = WHICH.PromisedAnswer; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint ImportedCap => which == WHICH.ImportedCap ? ctx.ReadDataUInt(0UL, 0U) : default; + public Capnp.Rpc.PromisedAnswer.READER PromisedAnswer => which == WHICH.PromisedAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint ImportedCap + { + get => which == WHICH.ImportedCap ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.PromisedAnswer.WRITER PromisedAnswer + { + get => which == WHICH.PromisedAnswer ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Payload : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Content = CapnpSerializable.Create(reader.Content); + CapTable = reader.CapTable.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Content.SetObject(Content); + writer.CapTable.Init(CapTable, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer Content + { + get; + set; + } + + public IReadOnlyList CapTable + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Content => ctx.StructReadPointer(0); + public IReadOnlyList CapTable => ctx.ReadList(1).Cast(Capnp.Rpc.CapDescriptor.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Content + { + get => BuildPointer(0); + set => Link(0, value); + } + + public ListOfStructsSerializer CapTable + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public class CapDescriptor : ICapnpSerializable + { + public enum WHICH : ushort + { + None = 0, + SenderHosted = 1, + SenderPromise = 2, + ReceiverHosted = 3, + ReceiverAnswer = 4, + ThirdPartyHosted = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.None: + which = reader.which; + break; + case WHICH.SenderHosted: + SenderHosted = reader.SenderHosted; + break; + case WHICH.SenderPromise: + SenderPromise = reader.SenderPromise; + break; + case WHICH.ReceiverHosted: + ReceiverHosted = reader.ReceiverHosted; + break; + case WHICH.ReceiverAnswer: + ReceiverAnswer = CapnpSerializable.Create(reader.ReceiverAnswer); + break; + case WHICH.ThirdPartyHosted: + ThirdPartyHosted = CapnpSerializable.Create(reader.ThirdPartyHosted); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.None: + break; + case WHICH.SenderHosted: + _content = 0; + break; + case WHICH.SenderPromise: + _content = 0; + break; + case WHICH.ReceiverHosted: + _content = 0; + break; + case WHICH.ReceiverAnswer: + _content = null; + break; + case WHICH.ThirdPartyHosted: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.None: + break; + case WHICH.SenderHosted: + writer.SenderHosted = SenderHosted.Value; + break; + case WHICH.SenderPromise: + writer.SenderPromise = SenderPromise.Value; + break; + case WHICH.ReceiverHosted: + writer.ReceiverHosted = ReceiverHosted.Value; + break; + case WHICH.ReceiverAnswer: + ReceiverAnswer?.serialize(writer.ReceiverAnswer); + break; + case WHICH.ThirdPartyHosted: + ThirdPartyHosted?.serialize(writer.ThirdPartyHosted); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? SenderHosted + { + get => _which == WHICH.SenderHosted ? (uint? )_content : null; + set + { + _which = WHICH.SenderHosted; + _content = value; + } + } + + public uint? SenderPromise + { + get => _which == WHICH.SenderPromise ? (uint? )_content : null; + set + { + _which = WHICH.SenderPromise; + _content = value; + } + } + + public uint? ReceiverHosted + { + get => _which == WHICH.ReceiverHosted ? (uint? )_content : null; + set + { + _which = WHICH.ReceiverHosted; + _content = value; + } + } + + public Capnp.Rpc.PromisedAnswer ReceiverAnswer + { + get => _which == WHICH.ReceiverAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null; + set + { + _which = WHICH.ReceiverAnswer; + _content = value; + } + } + + public Capnp.Rpc.ThirdPartyCapDescriptor ThirdPartyHosted + { + get => _which == WHICH.ThirdPartyHosted ? (Capnp.Rpc.ThirdPartyCapDescriptor)_content : null; + set + { + _which = WHICH.ThirdPartyHosted; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public uint SenderHosted => which == WHICH.SenderHosted ? ctx.ReadDataUInt(32UL, 0U) : default; + public uint SenderPromise => which == WHICH.SenderPromise ? ctx.ReadDataUInt(32UL, 0U) : default; + public uint ReceiverHosted => which == WHICH.ReceiverHosted ? ctx.ReadDataUInt(32UL, 0U) : default; + public Capnp.Rpc.PromisedAnswer.READER ReceiverAnswer => which == WHICH.ReceiverAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default; + public Capnp.Rpc.ThirdPartyCapDescriptor.READER ThirdPartyHosted => which == WHICH.ThirdPartyHosted ? ctx.ReadStruct(0, Capnp.Rpc.ThirdPartyCapDescriptor.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public uint SenderHosted + { + get => which == WHICH.SenderHosted ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public uint SenderPromise + { + get => which == WHICH.SenderPromise ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public uint ReceiverHosted + { + get => which == WHICH.ReceiverHosted ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public Capnp.Rpc.PromisedAnswer.WRITER ReceiverAnswer + { + get => which == WHICH.ReceiverAnswer ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.ThirdPartyCapDescriptor.WRITER ThirdPartyHosted + { + get => which == WHICH.ThirdPartyHosted ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class PromisedAnswer : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Transform = reader.Transform.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.Transform.Init(Transform, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public IReadOnlyList Transform + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public IReadOnlyList Transform => ctx.ReadList(0).Cast(Capnp.Rpc.PromisedAnswer.Op.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public ListOfStructsSerializer Transform + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + + public class Op : ICapnpSerializable + { + public enum WHICH : ushort + { + Noop = 0, + GetPointerField = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Noop: + which = reader.which; + break; + case WHICH.GetPointerField: + GetPointerField = reader.GetPointerField; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Noop: + break; + case WHICH.GetPointerField: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Noop: + break; + case WHICH.GetPointerField: + writer.GetPointerField = GetPointerField.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort? GetPointerField + { + get => _which == WHICH.GetPointerField ? (ushort? )_content : null; + set + { + _which = WHICH.GetPointerField; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public ushort GetPointerField => which == WHICH.GetPointerField ? ctx.ReadDataUShort(16UL, (ushort)0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public ushort GetPointerField + { + get => which == WHICH.GetPointerField ? this.ReadDataUShort(16UL, (ushort)0) : default; + set => this.WriteData(16UL, value, (ushort)0); + } + } + } + } + + public class ThirdPartyCapDescriptor : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = CapnpSerializable.Create(reader.Id); + VineId = reader.VineId; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id.SetObject(Id); + writer.VineId = VineId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer Id + { + get; + set; + } + + public uint VineId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Id => ctx.StructReadPointer(0); + public uint VineId => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public DynamicSerializerState Id + { + get => BuildPointer(0); + set => Link(0, value); + } + + public uint VineId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Exception : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Reason = reader.Reason; + ObsoleteIsCallersFault = reader.ObsoleteIsCallersFault; + ObsoleteDurability = reader.ObsoleteDurability; + TheType = reader.TheType; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Reason = Reason; + writer.ObsoleteIsCallersFault = ObsoleteIsCallersFault; + writer.ObsoleteDurability = ObsoleteDurability; + writer.TheType = TheType; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Reason + { + get; + set; + } + + public bool ObsoleteIsCallersFault + { + get; + set; + } + + public ushort ObsoleteDurability + { + get; + set; + } + + public Capnp.Rpc.Exception.Type TheType + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Reason => ctx.ReadText(0, ""); + public bool ObsoleteIsCallersFault => ctx.ReadDataBool(0UL, false); + public ushort ObsoleteDurability => ctx.ReadDataUShort(16UL, (ushort)0); + public Capnp.Rpc.Exception.Type TheType => (Capnp.Rpc.Exception.Type)ctx.ReadDataUShort(32UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string Reason + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public bool ObsoleteIsCallersFault + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public ushort ObsoleteDurability + { + get => this.ReadDataUShort(16UL, (ushort)0); + set => this.WriteData(16UL, value, (ushort)0); + } + + public Capnp.Rpc.Exception.Type TheType + { + get => (Capnp.Rpc.Exception.Type)this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, (ushort)value, (ushort)0); + } + } + + public enum Type : ushort + { + failed, + overloaded, + disconnected, + unimplemented + } + } +} \ No newline at end of file diff --git a/Capnp.Net.Runtime/SecurityOptions.cs b/Capnp.Net.Runtime/SecurityOptions.cs new file mode 100644 index 0000000..eb0b463 --- /dev/null +++ b/Capnp.Net.Runtime/SecurityOptions.cs @@ -0,0 +1,18 @@ +namespace Capnp +{ + /// + /// Provides the security bounds for defeating amplification and stack overflow DoS attacks. + /// See https://capnproto.org/encoding.html#security-considerations for details. + /// + public static class SecurityOptions + { + /// + /// The traversal limit, see https://capnproto.org/encoding.html#amplification-attack + /// + public static uint TraversalLimit { get; set; } = 64 * 1024 * 1024; + /// + /// The recursion limit, see https://capnproto.org/encoding.html#stack-overflow-dos-attack + /// + public static int RecursionLimit { get; set; } = 64; + } +} diff --git a/Capnp.Net.Runtime/SegmentAllocator.cs b/Capnp.Net.Runtime/SegmentAllocator.cs new file mode 100644 index 0000000..36c67ea --- /dev/null +++ b/Capnp.Net.Runtime/SegmentAllocator.cs @@ -0,0 +1,147 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + /// + /// The segment allocator default implementation. + /// + public class SegmentAllocator : ISegmentAllocator + { + class Segment + { + public Segment(Memory mem, uint id) + { + Mem = mem; + Id = id; + } + + public uint Id { get; } + public Memory Mem { get; } + public int FreeOffset { get; set; } + + public bool TryAllocate(uint nwords, out int offset) + { + if (checked(FreeOffset + (int)nwords) <= Mem.Length) + { + offset = FreeOffset; + int count = (int)nwords; + FreeOffset += count; + return true; + } + else + { + offset = -1; + return false; + } + } + + public bool IsFull => FreeOffset >= Mem.Length; + } + + readonly int _defaultSegmentSize; + readonly List _segments = new List(); + readonly List _nonFullSegments = new List(); + + /// + /// Constructs an instance. + /// + /// Default size (in words) of a newly allocated segment. If a single allocation requires + /// a bigger size, a bigger dedicated segment will be allocated. On the wire, segments will be truncated to their actual + /// occupancies. + public SegmentAllocator(int defaultSegmentSize = 128) + { + _defaultSegmentSize = defaultSegmentSize; + } + + /// + /// The list of currently allocated segments, each one truncated to its actual occupancy. + /// + public IReadOnlyList> Segments => _segments.LazyListSelect(s => s.Mem.Slice(0, s.FreeOffset)); + + /// + /// Allocates memory. + /// + /// Number of words to allocate + /// Preferred segment index. If enough space is available, + /// memory will be allocated inside that segment. Otherwise, a different segment will be chosen, or + /// a new one will be allocated, or allocation will fail (depending on ). + /// The allocated memory slice in case of success (default(SegmentSlice) otherwise) + /// Whether using the preferred segment is mandatory. If it is and there is not + /// enough space available, allocation will fail. + /// Whether allocation was successful. + public bool Allocate(uint nwords, uint preferredSegmentIndex, out SegmentSlice result, bool forcePreferredSegment) + { + result = default; + Segment segment; + + if (preferredSegmentIndex < _segments.Count) + { + segment = _segments[(int)preferredSegmentIndex]; + + if (segment.TryAllocate(nwords, out result.Offset)) + { + result.SegmentIndex = preferredSegmentIndex; + return true; + } + } + + if (forcePreferredSegment) + { + return false; + } + + for (int i = 0; i < _nonFullSegments.Count; i++) + { + segment = _nonFullSegments[i]; + + if (segment.TryAllocate(nwords, out result.Offset)) + { + result.SegmentIndex = segment.Id; + + if (segment.IsFull) + { + int n = _nonFullSegments.Count - 1; + var tmp = _nonFullSegments[i]; + _nonFullSegments[i] = _nonFullSegments[n]; + _nonFullSegments[n] = tmp; + _nonFullSegments.RemoveAt(n); + } + else if (i > 0) + { + var tmp = _nonFullSegments[i]; + _nonFullSegments[i] = _nonFullSegments[0]; + _nonFullSegments[0] = tmp; + } + + return true; + } + } + + int size = Math.Max((int)nwords, _defaultSegmentSize); + var storage = new ulong[size]; + var mem = new Memory(storage); + segment = new Segment(mem, (uint)_segments.Count); + + _segments.Add(segment); + + if (!segment.TryAllocate(nwords, out result.Offset)) + throw new InvalidProgramException(); + + result.SegmentIndex = segment.Id; + + if (!segment.IsFull) + { + _nonFullSegments.Add(segment); + + int n = _nonFullSegments.Count - 1; + var tmp = _nonFullSegments[0]; + _nonFullSegments[0] = _nonFullSegments[n]; + _nonFullSegments[n] = tmp; + } + + return true; + } + } +} diff --git a/Capnp.Net.Runtime/SegmentSlice.cs b/Capnp.Net.Runtime/SegmentSlice.cs new file mode 100644 index 0000000..68e3e76 --- /dev/null +++ b/Capnp.Net.Runtime/SegmentSlice.cs @@ -0,0 +1,13 @@ +using System; + +namespace Capnp +{ + /// + /// Helper struct to represent the tuple (segment index, offset) + /// + public struct SegmentSlice + { + public uint SegmentIndex; + public int Offset; + } +} diff --git a/Capnp.Net.Runtime/SerializerExtensions.cs b/Capnp.Net.Runtime/SerializerExtensions.cs new file mode 100644 index 0000000..97a2249 --- /dev/null +++ b/Capnp.Net.Runtime/SerializerExtensions.cs @@ -0,0 +1,341 @@ +using System; +using System.Runtime.InteropServices; + +namespace Capnp +{ + /// + /// Provides extensions to the and interfaces for type-safe reading and writing. + /// + public static class SerializerExtensions + { + /// + /// Reads a boolean field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static bool ReadDataBool(this T d, ulong bitOffset, bool defaultValue = false) + where T: IStructDeserializer + { + return (d.StructReadData(bitOffset, 1) != 0) != defaultValue; + } + + /// + /// Writes a boolean field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, bool value, bool defaultValue = false) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 1, value != defaultValue ? 1ul : 0); + } + + /// + /// Reads a byte field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static byte ReadDataByte(this T d, ulong bitOffset, byte defaultValue = 0) + where T : IStructDeserializer + { + return (byte)(d.StructReadData(bitOffset, 8) ^ defaultValue); + } + + /// + /// Writes a byte field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, byte value, byte defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 8, (byte)(value ^ defaultValue)); + } + + /// + /// Reads a signed byte field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static sbyte ReadDataSByte(this T d, ulong bitOffset, sbyte defaultValue = 0) + where T : IStructDeserializer + { + return (sbyte)((sbyte)d.StructReadData(bitOffset, 8) ^ defaultValue); + } + + /// + /// Writes a signed byte field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, sbyte value, sbyte defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 8, unchecked((ulong)(value ^ defaultValue))); + } + + /// + /// Reads a ushort field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static ushort ReadDataUShort(this T d, ulong bitOffset, ushort defaultValue = 0) + where T : IStructDeserializer + { + return (ushort)(d.StructReadData(bitOffset, 16) ^ defaultValue); + } + + /// + /// Writes a ushort field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, ushort value, ushort defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 16, (ushort)(value ^ defaultValue)); + } + + /// + /// Reads a short field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static short ReadDataShort(this T d, ulong bitOffset, short defaultValue = 0) + where T : IStructDeserializer + { + return (short)((short)d.StructReadData(bitOffset, 16) ^ defaultValue); + } + + /// + /// Writes a short field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, short value, short defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 16, unchecked((ulong)(value ^ defaultValue))); + } + + /// + /// Reads a uint field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static uint ReadDataUInt(this T d, ulong bitOffset, uint defaultValue = 0) + where T : IStructDeserializer + { + return (uint)(d.StructReadData(bitOffset, 32) ^ defaultValue); + } + + /// + /// Writes a uint field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, uint value, uint defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 32, value ^ defaultValue); + } + + /// + /// Performs a "reinterpret cast" of the struct's data section and returns a reference to a single element of the cast result. + /// + /// The cast target type. Must be a primitive type which qualifies for ()]]> + /// "this" instance + /// Index within the cast result, conceptually into U[] + /// A reference to the data element + public static ref U RefData(this IStructSerializer d, int woffset) + where U: struct + { + var data = MemoryMarshal.Cast(d.StructDataSection); + return ref MemoryMarshal.GetReference(data.Slice(woffset, 1)); + } + + /// + /// Reads an int field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static int ReadDataInt(this T d, ulong bitOffset, int defaultValue = 0) + where T : IStructDeserializer + { + return (int)d.StructReadData(bitOffset, 32) ^ defaultValue; + } + + /// + /// Writes an int field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, int value, int defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 32, unchecked((ulong)(value ^ defaultValue))); + } + + /// + /// Reads a ulong field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static ulong ReadDataULong(this T d, ulong bitOffset, ulong defaultValue = 0) + where T : IStructDeserializer + { + return d.StructReadData(bitOffset, 64) ^ defaultValue; + } + + /// + /// Writes a ulong field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, ulong value, ulong defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 64, value ^ defaultValue); + } + + /// + /// Reads a long field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (will be XORed with the result) + /// The read value + public static long ReadDataLong(this T d, ulong bitOffset, long defaultValue = 0) + where T : IStructDeserializer + { + return (long)d.StructReadData(bitOffset, 64) ^ defaultValue; + } + + /// + /// Writes a long field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, long value, long defaultValue = 0) + where T : IStructSerializer + { + d.StructWriteData(bitOffset, 64, unchecked((ulong)(value ^ defaultValue))); + } + + /// + /// Reads a float field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (raw bits will be XORed with the result) + /// The read value + public static float ReadDataFloat(this T d, ulong bitOffset, float defaultValue = 0) + where T : IStructDeserializer + { + int defaultBits = BitConverter.SingleToInt32Bits(defaultValue); + int bits = (int)d.StructReadData(bitOffset, 32) ^ defaultBits; + return BitConverter.Int32BitsToSingle(bits); + } + + /// + /// Writes a float field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (raw bits will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, float value, float defaultValue = 0.0f) + where T : IStructSerializer + { + int bits = BitConverter.SingleToInt32Bits(value); + int defaultBits = BitConverter.SingleToInt32Bits(defaultValue); + WriteData(d, bitOffset, bits, defaultBits); + } + + /// + /// Reads a double field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Field default value (raw bits will be XORed with the result) + /// The read value + public static double ReadDataDouble(this T d, ulong bitOffset, double defaultValue = 0) + where T : IStructDeserializer + { + long defaultBits = BitConverter.DoubleToInt64Bits(defaultValue); + long bits = (long)d.StructReadData(bitOffset, 64) ^ defaultBits; + return BitConverter.Int64BitsToDouble(bits); + } + + /// + /// Writes a double field. + /// + /// Type implementing + /// "this" instance + /// Start bit + /// Value to write + /// Field default value (raw bits will be XORed with the value to write) + public static void WriteData(this T d, ulong bitOffset, double value, double defaultValue = 0.0) + where T : IStructSerializer + { + long bits = BitConverter.DoubleToInt64Bits(value); + long defaultBits = BitConverter.DoubleToInt64Bits(defaultValue); + WriteData(d, bitOffset, bits, defaultBits); + } + } +} diff --git a/Capnp.Net.Runtime/SerializerState.cs b/Capnp.Net.Runtime/SerializerState.cs new file mode 100644 index 0000000..c5a1452 --- /dev/null +++ b/Capnp.Net.Runtime/SerializerState.cs @@ -0,0 +1,1379 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +namespace Capnp +{ + /// + /// Implements the heart of serialization. Exposes all functionality to encode serialized data. + /// Although it is public, you should not use it directly. Instead, use the reader, writer, and domain class adapters which are produced + /// by the code generator. Particularly, those writer classes are actually specializations of SerializerState, adding convenience methods + /// for accessing the struct's fields. + /// + public class SerializerState : IStructSerializer + { + /// + /// Constructs a SerializerState instance for use in RPC context. + /// This particularly means that the capability table will be initialized. + /// + /// Type of state (must inherit from SerializerState) + /// root object state + public static T CreateForRpc() where T: SerializerState, new() + { + var mb = MessageBuilder.Create(); + mb.InitCapTable(); + var s = new T(); + s.Bind(mb); + return s; + } + + internal MessageBuilder MsgBuilder { get; set; } + internal ISegmentAllocator Allocator => MsgBuilder?.Allocator; + internal List Caps => MsgBuilder?.Caps; + internal SerializerState Owner { get; set; } + internal int OwnerSlot { get; set; } + internal uint SegmentIndex { get; set; } + internal int Offset { get; set; } + internal uint WordsAllocated { get; set; } + internal int ListElementCount { get; set; } + internal ushort StructDataCount { get; set; } + internal ushort StructPtrCount { get; set; } + internal ObjectKind Kind { get; set; } + internal uint CapabilityIndex { get; set; } + + SerializerState[] _linkedStates; + + /// + /// Constructs an unbound serializer state. + /// + public SerializerState() + { + Offset = -1; + ListElementCount = -1; + } + + /// + /// Constructs a serializer state which is bound to a particular message builder. + /// + /// message builder to bind + public SerializerState(MessageBuilder messageBuilder) + { + MsgBuilder = messageBuilder ?? throw new ArgumentNullException(nameof(messageBuilder)); + Offset = -1; + ListElementCount = -1; + } + + internal void Bind(MessageBuilder messageBuilder) + { + MsgBuilder = messageBuilder ?? throw new ArgumentNullException(nameof(messageBuilder)); + } + + internal void Bind(SerializerState owner, int ownerSlot) + { + Owner = owner ?? throw new ArgumentNullException(nameof(owner)); + OwnerSlot = ownerSlot; + MsgBuilder = owner.MsgBuilder; + } + + /// + /// Represents this state by a different serializer state specialization. This is similar to a type-cast: The underlying object remains the same, + /// but the specialization adds a particular "view" on that data. + /// + /// target serializer state type + /// serializer state instance + /// The target serializer state is incompatible to this instance, because the instances do not agree on the + /// kind of underlying object (e.g. struct with particular data/pointer section size, list of something) + public TS Rewrap() where TS: SerializerState, new() + { + if (this is TS ts) + return ts; + + ts = new TS(); + + InvalidOperationException InvalidWrap() => + new InvalidOperationException("Incompatible cast"); + + switch (ts.Kind) + { + case ObjectKind.Struct: + case ObjectKind.ListOfStructs: + if (ts.Kind != Kind || + ts.StructDataCount != StructDataCount || + ts.StructPtrCount != StructPtrCount) + throw InvalidWrap(); + break; + + case ObjectKind.Nil: + break; + + default: + if (ts.Kind != Kind) + throw InvalidWrap(); + break; + } + + if (Owner != null) + ts.Bind(Owner, OwnerSlot); + else + ts.Bind(MsgBuilder); + + ts.SegmentIndex = SegmentIndex; + ts.Offset = Offset; + ts.ListElementCount = ListElementCount; + ts.StructDataCount = StructDataCount; + ts.StructPtrCount = StructPtrCount; + ts.Kind = Kind; + ts.CapabilityIndex = CapabilityIndex; + ts._linkedStates = _linkedStates; + + return ts; + } + + internal void InheritFrom(SerializerState other) + { + SegmentIndex = other.SegmentIndex; + Offset = other.Offset; + ListElementCount = other.ListElementCount; + StructDataCount = other.StructDataCount; + StructPtrCount = other.StructPtrCount; + Kind = other.Kind; + CapabilityIndex = other.CapabilityIndex; + _linkedStates = other._linkedStates; + } + + /// + /// Whether storage space for the underlying object was already allocated. Note that allocation happens + /// lazily, i.e. constructing a SerializerState and binding it to a MessageBuilder does NOT yet result in allocation. + /// + public bool IsAllocated => Offset >= 0; + + Span SegmentSpan => IsAllocated ? Allocator.Segments[(int)SegmentIndex].Span : Span.Empty; + Span FarSpan(uint index) => Allocator.Segments[(int)index].Span; + + /// + /// Given this state describes a struct and is allocated, returns the struct's data section. + /// + public Span StructDataSection => SegmentSpan.Slice(Offset, StructDataCount); + + /// + /// Returns the allocated memory slice (given this state already is allocated). Note that this definition is somewhat + /// non-symmetric to DeserializerState.RawData. Never mind: You should not use it directly, anyway. + /// + public Span RawData => SegmentSpan.Slice(Offset, (int)WordsAllocated); + + void AllocateWords(uint count) + { + if (count == 0) + { + SegmentIndex = 0; + Offset = 0; + } + else if (Owner?.Kind == ObjectKind.ListOfStructs) + { + Owner.Allocate(); + SegmentIndex = Owner.SegmentIndex; + Offset = Owner.Offset + OwnerSlot + 1; + } + else + { + SegmentIndex = Owner?.SegmentIndex ?? SegmentIndex; + Allocator.Allocate(count, SegmentIndex, out var slice, false); + SegmentIndex = slice.SegmentIndex; + Offset = slice.Offset; + } + + WordsAllocated = count; + } + + /// + /// Allocates storage for the underlying object. Does nothing if it is already allocated. From the point the object is allocated, its type cannot by changed + /// anymore (e.g. changing from struct to list, or modifying the struct's section sizes). + /// + public void Allocate() + { + if (!IsAllocated) + { + switch (Kind) + { + case ObjectKind.ListOfBits: + AllocateWords(checked((uint)ListElementCount + 63u) / 64); + break; + + case ObjectKind.ListOfBytes: + AllocateWords(checked((uint)ListElementCount + 7u) / 8); + break; + + case ObjectKind.ListOfInts: + AllocateWords(checked((uint)ListElementCount + 1u) / 2); + break; + + case ObjectKind.ListOfLongs: + case ObjectKind.ListOfPointers: + AllocateWords(checked((uint)ListElementCount)); + break; + + case ObjectKind.ListOfShorts: + AllocateWords(checked((uint)ListElementCount + 3u) / 4); + break; + + case ObjectKind.ListOfStructs: + AllocateWords(checked(1u + (uint)ListElementCount * (uint)(StructDataCount + StructPtrCount))); + var tag = default(WirePointer); + tag.BeginStruct(StructDataCount, StructPtrCount); + tag.ListOfStructsElementCount = ListElementCount; + SegmentSpan[Offset] = tag; + break; + + case ObjectKind.Struct: + AllocateWords((uint)(StructDataCount + StructPtrCount)); + break; + + default: + AllocateWords(0); + break; + } + + Owner?.Link(OwnerSlot, this); + } + } + + internal void EncodePointer(int offset, SerializerState target, bool allowCopy) + { + if (target == null) + throw new ArgumentNullException(nameof(target)); + + if (!target.IsAllocated) + throw new InvalidOperationException("Target must be allocated before a pointer can be built"); + + try + { + if (SegmentSpan[offset] != 0) + throw new InvalidOperationException("Won't replace an already allocated pointer to prevent memory leaks and security flaws"); + } + catch (IndexOutOfRangeException) + { + throw new ArgumentOutOfRangeException(nameof(offset)); + } + + if (target.Allocator != null && + target.Allocator != Allocator) + { + if (allowCopy) + { + Allocate(); + + var targetCopy = new DynamicSerializerState(MsgBuilder); + Reserializing.DeepCopy(target, targetCopy); + target = targetCopy; + } + else + { + throw new InvalidOperationException("target was allocated on a different segment allocator"); + } + } + else + { + Allocate(); + } + + WirePointer targetPtr = default(WirePointer); + + switch (target.Kind) + { + case ObjectKind.ListOfBits: + targetPtr.BeginList(ListKind.ListOfBits, target.ListElementCount); + break; + + case ObjectKind.ListOfBytes: + targetPtr.BeginList(ListKind.ListOfBytes, target.ListElementCount); + break; + + case ObjectKind.ListOfEmpty: + targetPtr.BeginList(ListKind.ListOfEmpty, target.ListElementCount); + break; + + case ObjectKind.ListOfInts: + targetPtr.BeginList(ListKind.ListOfInts, target.ListElementCount); + break; + + case ObjectKind.ListOfLongs: + targetPtr.BeginList(ListKind.ListOfLongs, target.ListElementCount); + break; + + case ObjectKind.ListOfPointers: + targetPtr.BeginList(ListKind.ListOfPointers, target.ListElementCount); + break; + + case ObjectKind.ListOfShorts: + targetPtr.BeginList(ListKind.ListOfShorts, target.ListElementCount); + break; + + case ObjectKind.ListOfStructs: + int wordCount = target.ListElementCount * (target.StructDataCount + target.StructPtrCount); + targetPtr.BeginList(ListKind.ListOfStructs, wordCount); + break; + + case ObjectKind.Capability: + targetPtr.SetCapability(target.CapabilityIndex); + SegmentSpan[offset] = targetPtr; + return; + + case ObjectKind.Struct: + targetPtr.BeginStruct(target.StructDataCount, target.StructPtrCount); + if (target.StructDataCount == 0 && target.StructPtrCount == 0) + { + targetPtr.Offset = -1; + SegmentSpan[offset] = targetPtr; + return; + } + break; + + case ObjectKind.Nil: + SegmentSpan[offset] = 0; + return; + + default: + throw new NotImplementedException(); + } + + if (SegmentIndex != target.SegmentIndex) + { + WirePointer farPtr = default; + + if (Allocator.Allocate(1, target.SegmentIndex, out var landingPadSlice, true)) + { + farPtr.SetFarPointer(target.SegmentIndex, landingPadSlice.Offset, false); + SegmentSpan[offset] = farPtr; + targetPtr.Offset = target.Offset - (landingPadSlice.Offset + 1); + FarSpan(target.SegmentIndex)[landingPadSlice.Offset] = targetPtr; + } + else + { + Allocator.Allocate(2, 0, out landingPadSlice, false); + farPtr.SetFarPointer(landingPadSlice.SegmentIndex, landingPadSlice.Offset, true); + SegmentSpan[offset] = farPtr; + WirePointer farPtr2 = default; + farPtr2.SetFarPointer(target.SegmentIndex, target.Offset, false); + var farSpan = FarSpan(landingPadSlice.SegmentIndex); + farSpan[landingPadSlice.Offset] = farPtr2; + targetPtr.Offset = target.Offset; + farSpan[landingPadSlice.Offset + 1] = targetPtr; + } + } + else + { + targetPtr.Offset = target.Offset - (offset + 1); + SegmentSpan[offset] = targetPtr; + } + } + + internal Rpc.ConsumedCapability DecodeCapPointer(int offset) + { + if (offset < 0) + throw new IndexOutOfRangeException(nameof(offset)); + + if (Caps == null) + throw new InvalidOperationException("Capbility table not set"); + + WirePointer pointer = RawData[offset]; + + if (pointer.Kind != PointerKind.Other) + { + throw new Rpc.RpcException( + "Expected a capability pointer, but got something different"); + } + + if (pointer.CapabilityIndex >= Caps.Count) + { + throw new Rpc.RpcException( + "Capability index out of range"); + } + + return Caps[(int)pointer.CapabilityIndex]; + } + + /// + /// Links a sub-item (struct field or list element) of this state to another state. Usually, this operation is not necessary, since objects are constructed top-down. + /// However, there might be some advanced scenarios where you want to reference the same object twice (also interesting for designing amplification attacks). + /// The Cap'n Proto serialization intrinsically supports this, since messages are object graphs, not trees. + /// + /// If this state describes a struct: Index into this struct's pointer table. + /// If this state describes a list of pointers: List element index. + /// state to be linked + /// Whether to deep copy the target state if it belongs to a different message builder than this state. + /// is null + /// out of range + /// + /// This state does neither describe a struct, nor a list of pointers + /// Another state is already linked to the specified position (sorry, no overwrite allowed) + /// This state and belong to different message builder, and is false + /// + protected void Link(int slot, SerializerState target, bool allowCopy = true) + { + if (target == null) + throw new ArgumentNullException(nameof(target)); + + if (slot < 0) + throw new ArgumentOutOfRangeException(nameof(slot)); + + if (!IsAllocated) + { + SegmentIndex = target.SegmentIndex; + Allocate(); + } + + if (!target.IsAllocated) + { + target.Allocate(); + } + + switch (Kind) + { + case ObjectKind.Struct: + if (slot >= StructPtrCount) + throw new ArgumentOutOfRangeException(nameof(slot)); + + EncodePointer(Offset + StructDataCount + slot, target, allowCopy); + + break; + + case ObjectKind.ListOfPointers: + if (slot >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(slot)); + + EncodePointer(Offset + slot, target, allowCopy); + + break; + + default: + throw new InvalidOperationException("This object cannot own pointers to sub-objects"); + } + + _linkedStates[slot] = target; + } + + /// + /// Links a sub-item (struct field or list element) of this state to a capability. + /// + /// If this state describes a struct: Index into this struct's pointer table. + /// If this state describes a list of pointers: List element index. + /// capability index inside the capability table + /// + /// This state does neither describe a struct, nor a list of pointers + /// Another state is already linked to the specified position (sorry, no overwrite allowed) + /// + protected void LinkToCapability(int slot, uint capabilityIndex) + { + var cstate = new SerializerState(); + cstate.SetCapability(capabilityIndex); + Link(slot, cstate); + } + + static InvalidOperationException AlreadySet() => new InvalidOperationException("The object type was already set"); + + void VerifyNotYetAllocated() + { + if (IsAllocated) + throw new InvalidOperationException("Not permitted since the state is already allocated"); + } + + /// + /// Determines the underlying object to be a struct. + /// + /// Desired size of the struct's data section, in words + /// Desired size of the struct's pointer section, in words + /// The object type was already set to something different + protected void SetStruct(ushort dataCount, ushort ptrCount) + { + if (Kind == ObjectKind.Nil) + { + VerifyNotYetAllocated(); + + Kind = ObjectKind.Struct; + StructDataCount = dataCount; + StructPtrCount = ptrCount; + + _linkedStates = new SerializerState[ptrCount]; + } + else if (Kind != ObjectKind.Struct || StructDataCount != dataCount || StructPtrCount != ptrCount) + { + throw AlreadySet(); + } + } + + internal void SetCapability(uint capabilityIndex) + { + if (Kind == ObjectKind.Nil) + { + VerifyNotYetAllocated(); + + Kind = ObjectKind.Capability; + CapabilityIndex = capabilityIndex; + Allocate(); + } + else if (Kind != ObjectKind.Capability || CapabilityIndex != capabilityIndex) + { + throw AlreadySet(); + } + } + + /// + /// Determines the underlying object to be a list of (primitive) values. + /// + /// Element size in bits, must be 0 (void), 1 (bool), 8, 16, 32, or 64 + /// Desired element count + /// The object type was already set to something different + /// outside allowed range, + /// negative or exceeding 2^29-1 + protected void SetListOfValues(byte bitsPerElement, int totalCount) + { + ObjectKind kind; + + switch (bitsPerElement) + { + case 0: + kind = ObjectKind.ListOfEmpty; + break; + + case 1: + kind = ObjectKind.ListOfBits; + break; + + case 8: + kind = ObjectKind.ListOfBytes; + break; + + case 16: + kind = ObjectKind.ListOfShorts; + break; + + case 32: + kind = ObjectKind.ListOfInts; + break; + + case 64: + kind = ObjectKind.ListOfLongs; + break; + + default: + throw new ArgumentOutOfRangeException(nameof(bitsPerElement)); + } + + if (Kind == ObjectKind.Nil) + { + if (totalCount < 0) + throw new ArgumentOutOfRangeException(nameof(totalCount)); + + VerifyNotYetAllocated(); + + Kind = kind; + ListElementCount = totalCount; + + Allocate(); + } + else if (Kind != kind || ListElementCount != totalCount) + { + throw AlreadySet(); + } + } + + /// + /// Determines the underlying object to be a list of pointers. + /// + /// Desired element count + /// The object type was already set to something different + /// negative or exceeding 2^29-1 + protected void SetListOfPointers(int totalCount) + { + if (Kind == ObjectKind.Nil) + { + if (totalCount < 0) + throw new ArgumentOutOfRangeException(nameof(totalCount)); + + VerifyNotYetAllocated(); + + Kind = ObjectKind.ListOfPointers; + ListElementCount = totalCount; + + _linkedStates = new SerializerState[totalCount]; + + Allocate(); + } + else if (Kind != ObjectKind.ListOfPointers || ListElementCount != totalCount) + { + throw AlreadySet(); + } + } + + /// + /// Determines the underlying object to be a list of structs (fixed-width compound list). + /// + /// Desired element count + /// Desired size of each struct's data section, in words + /// Desired size of each struct's pointer section, in words + /// The object type was already set to something different + /// negative, or total word count would exceed 2^29-1 + protected void SetListOfStructs(int totalCount, ushort dataCount, ushort ptrCount) + { + if (Kind == ObjectKind.Nil) + { + if (totalCount < 0) + throw new ArgumentOutOfRangeException(nameof(totalCount)); + + VerifyNotYetAllocated(); + + Kind = ObjectKind.ListOfStructs; + ListElementCount = totalCount; + StructDataCount = dataCount; + StructPtrCount = ptrCount; + + _linkedStates = new SerializerState[totalCount]; + + Allocate(); + } + else if (Kind != ObjectKind.ListOfStructs || + ListElementCount != totalCount || + StructDataCount != dataCount || + StructPtrCount != ptrCount) + { + throw AlreadySet(); + } + } + + /// + /// Determines the underlying object to be a list of bytes and encodes the given text. + /// + /// text to encode + /// is null + /// Trying to obtain the UTF-8 encoding might throw this exception. + /// The object type was already set to something different + /// UTF-8 encoding exceeds 2^29-2 bytes + protected void WriteText(string text) + { + byte[] srcBytes = Encoding.UTF8.GetBytes(text); + SetListOfValues(8, srcBytes.Length + 1); + var srcSpan = new ReadOnlySpan(srcBytes); + var dstSpan = ListGetBytes(); + dstSpan = dstSpan.Slice(0, dstSpan.Length - 1); + srcSpan.CopyTo(dstSpan); + } + + /// + /// Writes data (up to 64 bits) into the underlying struct's data section. + /// The write operation must be aligned to fit within a single word. + /// + /// Start bit relative to the struct's data section, little endian + /// Number of bits to write + /// Data bits to write + /// The object was not determined to be a struct + /// The data slice specified by and + /// is not completely within the struct's data section, misaligned, exceeds one word, or is negative + public void StructWriteData(ulong bitOffset, int bitCount, ulong value) + { + if (Kind != ObjectKind.Struct) + throw new InvalidOperationException("This is not a struct"); + + Allocate(); + + int index = checked((int)(bitOffset / 64)); + int relBitOffset = (int)(bitOffset % 64); + + var data = StructDataSection; + + if (relBitOffset + bitCount > 64) + throw new ArgumentOutOfRangeException(nameof(bitCount)); + + ulong word = data[index]; + + if (bitCount == 64) + { + data[index] = value; + } + else + { + ulong mask = ~(((1ul << bitCount) - 1) << relBitOffset); + data[index] = data[index] & mask | (value << relBitOffset); + } + } + + /// + /// Reads data (up to 64 bits) from the underlying struct's data section. + /// The write operation must be aligned to fit within a single word. + /// + /// Start bit relative to the struct's data section, little endian + /// Number of bits to read + /// Data bits which were read + /// The object was not determined to be a struct + /// The data slice specified by and + /// is not completely within the struct's data section, misaligned, exceeds one word, or is negative + public ulong StructReadData(ulong bitOffset, int count) + { + if (Kind != ObjectKind.Struct) + throw new InvalidOperationException("This is not a struct"); + + if (!IsAllocated) + return 0; + + int index = checked((int)(bitOffset / 64)); + int relBitOffset = (int)(bitOffset % 64); + + var data = StructDataSection; + + if (index >= data.Length) + return 0; // Assume backwards-compatible change + + if (relBitOffset + count > 64) + throw new ArgumentOutOfRangeException(nameof(count)); + + ulong word = data[index]; + + if (count == 64) + { + return word; + } + else + { + ulong mask = (1ul << count) - 1; + return (word >> relBitOffset) & mask; + } + } + + /// + /// Constructs a new object at a struct field or list element, or returns the serializer state for an existing object. + /// + /// Target state type + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Bound serializer state instance + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position was already built and is not compatible with the desired target serializer type. + /// + /// is out of bounds. + public TS BuildPointer(int index) where TS: SerializerState, new() + { + if (Kind != ObjectKind.Struct && Kind != ObjectKind.ListOfPointers) + throw new InvalidOperationException("This is not a struct or list of pointers"); + + ref var state = ref _linkedStates[index]; + + if (state == null) + { + state = new TS(); + state.Bind(this, index); + } + + return state.Rewrap(); + } + + /// + /// Returns an existing serializer state for a struct field or list element, or null if no such object exists. + /// + /// Target state type + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Bound serializer state instance + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position is not compatible with the desired target serializer type. + /// + /// is out of bounds. + public TS TryGetPointer(int index) where TS : SerializerState, new() + { + if (Kind != ObjectKind.Struct && Kind != ObjectKind.ListOfPointers) + throw new InvalidOperationException("This is not a struct or list of pointers"); + + var state = _linkedStates[index]; + + if (state == null) return null; + + return state.Rewrap(); + } + + /// + /// Convenience method for ]]> + /// + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Bound serializer state instance + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position was already built and is not compatible with the desired target serializer type. + /// + /// is out of bounds. + public DynamicSerializerState BuildPointer(int index) => BuildPointer(index); + + /// + /// Convenience method for ]]> + /// + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Bound serializer state instance + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position is not compatible with the desired target serializer type. + /// + /// is out of bounds. + public SerializerState TryGetPointer(int index) => TryGetPointer(index); + + public string ReadText(int index, string defaultText = null) + { + var b = BuildPointer(index); + + if (b.IsAllocated) + return b.ListReadAsText(); + else + return defaultText; + } + + /// + /// Encodes text into a struct field or list element. + /// + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Text to encode + /// is null + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position was already set. + /// + /// is out of bounds. + public void WriteText(int index, string text) + { + BuildPointer(index).WriteText(text); + } + + /// + /// Encodes text into a struct field or list element, with fallback to a default text. + /// + /// If the underlying object is a struct: index into the struct's pointer section. + /// If the underlying object is a list of pointers: Element index + /// Text to encode + /// Default text of > is null + /// Both and are null + /// + /// The underlying object was not determined to be a struct or list of pointers. + /// Object at given position was already set. + /// + /// is out of bounds. + public void WriteText(int index, string text, string defaultText) + { + BuildPointer(index).WriteText(text ?? defaultText); + } + + /// + /// Returns a state which represents a fixed-width composite list element. + /// + /// Element index + /// Bound serializer state + /// Underlying object was not determined to be a fixed-width composite list. + /// is out of bounds. + public SerializerState ListBuildStruct(int index) + { + if (Kind != ObjectKind.ListOfStructs) + throw new InvalidOperationException("This is not a list of structs"); + + ref var state = ref _linkedStates[index]; + + if (state == null) + { + state = new SerializerState(MsgBuilder); + state.SetStruct(StructDataCount, StructPtrCount); + state.SegmentIndex = SegmentIndex; + state.Offset = Offset + 1 + index * (StructDataCount + StructPtrCount); + } + + return _linkedStates[index]; + } + + /// + /// Returns a state which represents a fixed-width composite list element. + /// + /// Target serializer state type + /// + /// Bound serializer state + /// Underlying object was not determined to be a fixed-width composite list. + /// is out of bounds. + public TS ListBuildStruct(int index) + where TS: SerializerState, new() + { + if (Kind != ObjectKind.ListOfStructs) + throw new InvalidOperationException("This is not a list of structs"); + + ref var state = ref _linkedStates[index]; + + if (state == null) + { + state = new TS(); + state.Bind(MsgBuilder); + state.SetStruct(StructDataCount, StructPtrCount); + state.SegmentIndex = SegmentIndex; + int stride = StructDataCount + StructPtrCount; + state.Offset = Offset + stride * index + 1; + } + + return (TS)state; + } + + internal IReadOnlyList ListEnumerateStructs() + where TS: SerializerState, new() + { + if (Kind != ObjectKind.ListOfStructs) + throw new InvalidOperationException("This is not a list of structs"); + + if (ListElementCount < 0) + throw new InvalidOperationException("Define element count first"); + + int minOffset = Offset + 1; + int maxOffset = minOffset + ListElementCount; + + for (int offset = minOffset; offset < maxOffset; offset++) + { + ref var state = ref _linkedStates[offset - minOffset]; + + if (state == null) + { + state = new TS(); + state.Bind(MsgBuilder); + state.SetStruct(StructDataCount, StructPtrCount); + state.SegmentIndex = SegmentIndex; + state.Offset = offset; + } + } + + return _linkedStates.LazyListSelect(ts => (TS)ts); + } + + /// + /// Sets an element of a list of bits. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of bits. + /// is out of bounds. + public void ListWriteValue(int index, bool value, bool defaultValue = false) + { + if (Kind != ObjectKind.ListOfBits) + throw new InvalidOperationException("This is not a list of bits"); + + if (index < 0 || index >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(index)); + + bool bit = value != defaultValue; + int wordIndex = index / 64; + int relBitOffset = index % 64; + + if (bit) + SegmentSpan[Offset + wordIndex] |= (1ul << relBitOffset); + else + SegmentSpan[Offset + wordIndex] &= ~(1ul << relBitOffset); + } + + /// + /// Sets the list-of-bits' content. + /// + /// Content to set + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of bits. + /// is null. + /// The given element count does not match the underlying list's element count. + public void ListWriteValues(IReadOnlyList values, bool defaultValue = false) + { + if (Kind != ObjectKind.ListOfBits) + throw new InvalidOperationException("This is not a list of bits"); + + if (values == null) + throw new ArgumentNullException(nameof(values)); + + if (values.Count != ListElementCount) + throw new ArgumentOutOfRangeException(nameof(values)); + + int i, w = Offset; + ulong v; + + for (i = 0; i < ListElementCount - 63; i += 64) + { + v = 0; + + for (int j = 63; j >= 0; j--) + { + v <<= 1; + if (values[i + j]) v |= 1; + } + + if (defaultValue) v = ~v; + + SegmentSpan[w++] = v; + } + + if (i < ListElementCount) + { + v = 0; + + for (int k = ListElementCount - 1; k >= i; k--) + { + v <<= 1; + if (values[k]) v |= 1; + } + + if (defaultValue) v = ~v; + + SegmentSpan[w] = v; + } + } + + /// + /// Sets an element of a list of bytes. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of bytes. + /// is out of bounds. + public void ListWriteValue(int index, byte value, byte defaultValue = 0) + { + if (Kind != ObjectKind.ListOfBytes) + throw new InvalidOperationException("This is not a list of bytes"); + + if (index < 0 || index >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(index)); + + byte x = (byte)(value ^ defaultValue); + MemoryMarshal.Cast(SegmentSpan.Slice(Offset))[index] = x; + } + + /// + /// Returns the content of a list of bytes. + /// + /// The list bytes + /// The underlying object was not set to a list of bytes. + Span ListGetBytes() + { + if (Kind != ObjectKind.ListOfBytes) + throw new InvalidOperationException("This is not a list of bytes"); + + return MemoryMarshal.Cast(SegmentSpan.Slice(Offset)).Slice(0, ListElementCount); + } + + /// + /// Decodes a list of bytes as text. + /// + /// The decoded text. + /// The underlying object was not set to a list of bytes. + /// Might theoretically be thrown during decoding. + public string ListReadAsText() + { + var bytes = ListGetBytes(); + if (bytes.Length == 0) return string.Empty; + return Encoding.UTF8.GetString(bytes.Slice(0, bytes.Length - 1)); + } + + /// + /// Sets an element of a list of (signed) bytes. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of bytes. + /// is out of bounds. + public void ListWriteValue(int index, sbyte value, sbyte defaultValue = 0) + { + ListWriteValue(index, unchecked((byte)value), unchecked((byte)defaultValue)); + } + + /// + /// Sets an element of a list of 16 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 16 bit words. + /// is out of bounds. + public void ListWriteValue(int index, ushort value, ushort defaultValue = 0) + { + if (Kind != ObjectKind.ListOfShorts) + throw new InvalidOperationException("This is not a list of 16-bit values"); + + if (index < 0 || index >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(index)); + + Allocate(); + + ushort x = (ushort)(value ^ defaultValue); + MemoryMarshal.Cast(SegmentSpan.Slice(Offset))[index] = x; + } + + /// + /// Sets an element of a list of 16 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 16 bit words. + /// is out of bounds. + public void ListWriteValue(int index, short value, short defaultValue = 0) + { + ListWriteValue(index, unchecked((ushort)value), unchecked((ushort)defaultValue)); + } + + /// + /// Sets an element of a list of 32 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 32 bit words. + /// is out of bounds. + public void ListWriteValue(int index, uint value, uint defaultValue = 0) + { + if (Kind != ObjectKind.ListOfInts) + throw new InvalidOperationException("This is not a list of 32-bit values"); + + if (index < 0 || index >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(index)); + + Allocate(); + + uint x = value ^ defaultValue; + MemoryMarshal.Cast(SegmentSpan.Slice(Offset))[index] = x; + } + + /// + /// Sets an element of a list of 32 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 32 bit words. + /// is out of bounds. + public void ListWriteValue(int index, int value, int defaultValue = 0) + { + ListWriteValue(index, unchecked((uint)value), unchecked((uint)defaultValue)); + } + + /// + /// Sets an element of a list of 32 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 32 bit words. + /// is out of bounds. + public void ListWriteValue(int index, float value, float defaultValue = 0) + { + int rcastValue = BitConverter.SingleToInt32Bits(value); + int rcastDefaultValue = BitConverter.SingleToInt32Bits(defaultValue); + ListWriteValue(index, rcastValue, rcastDefaultValue); + } + + /// + /// Sets an element of a list of 64 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 64 bit words. + /// is out of bounds. + public void ListWriteValue(int index, ulong value, ulong defaultValue = 0) + { + if (Kind != ObjectKind.ListOfLongs) + throw new InvalidOperationException("This is not a list of 64-bit values"); + + if (index < 0 || index >= ListElementCount) + throw new ArgumentOutOfRangeException(nameof(index)); + + Allocate(); + + ulong x = value ^ defaultValue; + SegmentSpan.Slice(Offset)[index] = x; + } + + /// + /// Sets an element of a list of 64 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 64 bit words. + /// is out of bounds. + public void ListWriteValue(int index, long value, long defaultValue = 0) + { + ListWriteValue(index, unchecked((ulong)value), unchecked((ulong)defaultValue)); + } + + /// + /// Sets an element of a list of 64 bit words. + /// + /// Element index + /// Element value + /// Element default value (serialized value will be XORed with the default value) + /// The underlying object was not set to a list of 64 bit words. + /// is out of bounds. + public void ListWriteValue(int index, double value, double defaultValue = 0) + { + long rcastValue = BitConverter.DoubleToInt64Bits(value); + long rcastDefaultValue = BitConverter.DoubleToInt64Bits(defaultValue); + ListWriteValue(index, rcastValue, rcastDefaultValue); + } + + /// + /// Adds an entry to the capability table if the provided capability does not yet exist. + /// + /// The low-level capability object to provide. + /// Index of the given capability in the capability table + /// The underlying message builder was not configured for capability table support. + public uint ProvideCapability(Rpc.ConsumedCapability capability) + { + if (Caps == null) + throw new InvalidOperationException("Underlying MessageBuilder was not enabled to support capabilities"); + + int index = Caps.IndexOf(capability); + + if (index < 0) + { + index = Caps.Count; + Caps.Add(capability); + capability?.AddRef(); + } + + return (uint)index; + } + + /// + /// Adds an entry to the capability table if the provided capability does not yet exist. + /// + /// The capability to provide, in terms of its skeleton. + /// Index of the given capability in the capability table + /// The underlying message builder was not configured for capability table support. + public uint ProvideCapability(Rpc.Skeleton capability) + { + return ProvideCapability(Rpc.LocalCapability.Create(capability)); + } + + /// + /// Adds an entry to the capability table if the provided capability does not yet exist. + /// + /// The capability, in one of the following forms: + /// Low-level capability object (Rpc.ConsumedCapability) + /// Proxy object (Rpc.Proxy) + /// Skeleton object (Rpc.Skeleton) + /// Capability interface implementation + /// + /// Index of the given capability in the capability table + /// The underlying message builder was not configured for capability table support. + public uint ProvideCapability(object obj) + { + if (obj == null) + return ProvideCapability(default(Rpc.ConsumedCapability)); + else if (obj is Rpc.Proxy proxy) + return ProvideCapability(proxy.ConsumedCap); + else if (obj is Rpc.ConsumedCapability consumedCapability) + return ProvideCapability(consumedCapability); + else if (obj is Rpc.Skeleton providedCapability) + return ProvideCapability(providedCapability); + else + return ProvideCapability(Rpc.Skeleton.GetOrCreateSkeleton(obj, false)); + } + + /// + /// Links a sub-item (struct field or list element) of this state to another object. + /// In contrast to , this method also accepts deserializer states, domain objects, capabilites, and lists thereof. + /// If necessary, it will perform a deep copy. + /// + /// If this state describes a struct: Index into this struct's pointer table. + /// If this state describes a list of pointers: List element index. + /// Object to be linked. Must be one of the following: + /// Another + /// A (will always deep copy) + /// An object implementing + /// A low-level capability object () + /// A proxy object () + /// A skeleton object () + /// A capability interface implementation + /// A of one of the things listed here. + /// + /// is out of range. + /// + /// This state does neither describe a struct, nor a list of pointers + /// Another state is already linked to the specified position (sorry, no overwrite allowed) + /// + public void LinkObject(int slot, T obj) + { + switch (obj) + { + case SerializerState s: + Link(slot, s); + break; + + case DeserializerState d: + Reserializing.DeepCopy(d, BuildPointer(slot)); + break; + + case ICapnpSerializable serializable: + serializable.Serialize(BuildPointer(slot)); + break; + + case IReadOnlyList list: + { + var builder = BuildPointer(slot); + builder.SetListOfPointers(list.Count); + int i = 0; + foreach (var item in list) + { + builder.LinkObject(i++, item); + } + } + break; + + default: + if (Rpc.CapabilityReflection.IsValidCapabilityInterface(typeof(T))) + { + LinkToCapability(slot, ProvideCapability(obj)); + } + break; + } + } + + internal Rpc.ConsumedCapability StructReadRawCap(int index) + { + if (Kind != ObjectKind.Struct && Kind != ObjectKind.Nil) + throw new InvalidOperationException("Allowed on structs only"); + + if (index >= StructPtrCount) + return null; + + return DecodeCapPointer(index + StructDataCount); + } + + /// + /// Reads a struct field as capability and returns a proxy to that capability. + /// + /// Desired capability interface + /// Index into this struct's pointer table. + /// The proxy instance + /// is out of range. + /// The desired interface does not qualify as capability interface ( + /// This state does not represent a struct. + public T ReadCap(int slot) where T : class + { + var cap = StructReadRawCap(slot); + return Rpc.CapabilityReflection.CreateProxy(cap) as T; + } + + /// + /// Reads a struct field as capability and returns a bare (generic) proxy to that capability. + /// + /// Index into this struct's pointer table. + /// The proxy instance + /// is out of range. + /// This state does not represent a struct. + public Rpc.BareProxy ReadCap(int slot) + { + var cap = StructReadRawCap(slot); + return new Rpc.BareProxy(cap); + } + } +} diff --git a/Capnp.Net.Runtime/WireFrame.cs b/Capnp.Net.Runtime/WireFrame.cs new file mode 100644 index 0000000..0de1f7e --- /dev/null +++ b/Capnp.Net.Runtime/WireFrame.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; + +namespace Capnp +{ + /// + /// Represents a Cap'n Proto message. Actually a lightweight wrapper struct around a read-only list of memory segments. + /// + public struct WireFrame + { + /// + /// The message segments + /// + public readonly IReadOnlyList> Segments; + + /// + /// Constructs a message from a list of segments. + /// + public WireFrame(IReadOnlyList> segments) + { + Segments = segments; + } + } +} diff --git a/Capnp.Net.Runtime/WirePointer.cs b/Capnp.Net.Runtime/WirePointer.cs new file mode 100644 index 0000000..9dfb8d0 --- /dev/null +++ b/Capnp.Net.Runtime/WirePointer.cs @@ -0,0 +1,215 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Capnp +{ + /// + /// Pointer tag, + /// + public enum PointerKind : byte + { + Struct = 0, + List = 1, + Far = 2, + Other = 3 + } + + /// + /// Lightweight wrapper struct around a Cap'n Proto pointer. Useful for both encoding and decoding pointers. + /// + public struct WirePointer + { + ulong _ptrData; + + /// + /// Constructs this struct from pointer raw data + /// + public WirePointer(ulong ptrData) + { + _ptrData = ptrData; + } + + /// + /// Interprets any ulong value as Cap'n Proto pointer + /// + public static implicit operator WirePointer (ulong value) => new WirePointer(value); + + /// + /// Extracts the wire data from the pointer. + /// + public static implicit operator ulong (WirePointer pointer) => pointer._ptrData; + + /// + /// Pointer tag "A" + /// + public PointerKind Kind + { + get => (PointerKind)(_ptrData & 3); + set { _ptrData = _ptrData & ~3ul | (ulong)value; } + } + + /// + /// Returns true iff this is a null pointer. + /// + public bool IsNull => _ptrData == 0; + + /// + /// The Offset (field "B") for struct and list pointers. + /// + /// Thrown by setter if encoded value would require more than 30 bits + public int Offset + { + get => unchecked((int)_ptrData) >> 2; + set + { + if (value >= (1 << 29) || value < -(1 << 29)) + throw new ArgumentOutOfRangeException(nameof(value)); + + _ptrData |= (uint)(value << 2); + } + } + + /// + /// Returns the landing pad offset (field "C") for inter-segment pointers. + /// + public int LandingPadOffset + { + get => unchecked((int)((_ptrData >> 3) & 0x1fffffff)); + } + + /// + /// Returns the size of the struct's data section (field "C"), in words, for struct pointers. + /// + public ushort StructDataCount + { + get => unchecked((ushort)(_ptrData >> 32)); + } + + /// + /// Returns the size of the struct's pointer section (field "D"), in words, for struct pointers. + /// + public ushort StructPtrCount + { + get => unchecked((ushort)(_ptrData >> 48)); + } + + /// + /// Convenience getter which returns the sum of the struct's pointer and data section sizes. + /// + public uint StructSize + { + get => (uint)StructDataCount + StructPtrCount; + } + + /// + /// Begins encoding a struct pointer. + /// + /// the size of the struct's data section, in words + /// the size of the struct's pointer section, in words + public void BeginStruct(ushort dataCount, ushort ptrCount) + { + _ptrData = ((ulong)dataCount << 32) | ((ulong)ptrCount << 48); + } + + /// + /// Returns the list "size" (field "C") for list pointers. + /// + public ListKind ListKind + { + get => (ListKind)((int)(_ptrData >> 32) & 0x7); + } + + /// + /// Gets or sets the element count if this pointer represents a list of fixed-width composite values. + /// + /// negative value, or encoded value would require more than 30 bits + public int ListOfStructsElementCount + { + get => (int)((_ptrData >> 2) & 0x3fffffff); + set { _ptrData = _ptrData & 0xffffffff00000000ul | checked((uint)value << 2); } + } + + /// + /// Returns the element count if this pointer represents a list of anything, except fixed-width composite values. + /// + public int ListElementCount + { + get => (int)(_ptrData >> 35); + } + + /// + /// Begins encoding a list pointer + /// + /// element "size" (field "C") + /// element count + /// element count would require more than 29 bits + public void BeginList(ListKind kind, int count) + { + if (count < 0 || count >= (1 << 29)) + throw new ArgumentOutOfRangeException(nameof(count)); + + _ptrData = ((ulong)count << 35) | ((ulong)kind << 32) | (ulong)PointerKind.List; + } + + /// + /// Returns the target segment index (field "D") for inter-segment pointers. + /// + public uint TargetSegmentIndex + { + get => (uint)(_ptrData >> 32); + } + + /// + /// Whether the landing pad is two words (field "B") for inter-segment pointers. + /// + public bool IsDoubleFar + { + get => (_ptrData & 4) != 0; + } + + /// + /// Encodes an inter-segment pointer. + /// + /// target segment index + /// landing pad offset + /// whether the landing pad is two words + /// negative landing pad offset, or encoding would require more than 29 bits + public void SetFarPointer(uint targetSegmentIndex, int landingPadOffset, bool isDoubleFar) + { + if (landingPadOffset < 0 || landingPadOffset >= (1 << 29)) + throw new ArgumentOutOfRangeException(nameof(landingPadOffset)); + + _ptrData = ((ulong)targetSegmentIndex << 32) | + ((uint)landingPadOffset << 3) | + (ulong)PointerKind.Far; + if (isDoubleFar) _ptrData |= 4; + } + + /// + /// Returns the sub-kind of pointer (field "B") if this is an "other" pointer. + /// Currently, only 0 is specified, which is a capability pointer. + /// + public uint OtherPointerKind + { + get => unchecked((uint)_ptrData) >> 2; + } + + /// + /// Returns the capability index (field "C") if this is a capability pointer. + /// + public uint CapabilityIndex + { + get => (uint)(_ptrData >> 32); + } + + /// + /// Encodes a capability pointer. + /// + /// capability index + public void SetCapability(uint index) + { + _ptrData = ((ulong)index << 32) | (ulong)PointerKind.Other; + } + } +} diff --git a/Capnp.Net.sln b/Capnp.Net.sln new file mode 100644 index 0000000..e6d4e04 --- /dev/null +++ b/Capnp.Net.sln @@ -0,0 +1,43 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29001.49 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Capnp.Net.Runtime", "Capnp.Net.Runtime\Capnp.Net.Runtime.csproj", "{D4326221-63C9-4AC5-805A-B4D8CA47546A}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "capnpc-csharp", "capnpc-csharp\capnpc-csharp.csproj", "{D19E5EA7-D35B-4A1F-99CB-ED136316B577}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "capnpc-binblob", "capnpc-binblob\capnpc-binblob.csproj", "{8C17F147-D784-4584-80FF-21BE03AC0D17}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Capnp.Net.Runtime.Tests", "Capnp.Net.Runtime.Tests\Capnp.Net.Runtime.Tests.csproj", "{9ED38750-F83F-4B10-B3A3-4FD6183F9E86}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D4326221-63C9-4AC5-805A-B4D8CA47546A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D4326221-63C9-4AC5-805A-B4D8CA47546A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D4326221-63C9-4AC5-805A-B4D8CA47546A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D4326221-63C9-4AC5-805A-B4D8CA47546A}.Release|Any CPU.Build.0 = Release|Any CPU + {D19E5EA7-D35B-4A1F-99CB-ED136316B577}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D19E5EA7-D35B-4A1F-99CB-ED136316B577}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D19E5EA7-D35B-4A1F-99CB-ED136316B577}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D19E5EA7-D35B-4A1F-99CB-ED136316B577}.Release|Any CPU.Build.0 = Release|Any CPU + {8C17F147-D784-4584-80FF-21BE03AC0D17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8C17F147-D784-4584-80FF-21BE03AC0D17}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8C17F147-D784-4584-80FF-21BE03AC0D17}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8C17F147-D784-4584-80FF-21BE03AC0D17}.Release|Any CPU.Build.0 = Release|Any CPU + {9ED38750-F83F-4B10-B3A3-4FD6183F9E86}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9ED38750-F83F-4B10-B3A3-4FD6183F9E86}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9ED38750-F83F-4B10-B3A3-4FD6183F9E86}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9ED38750-F83F-4B10-B3A3-4FD6183F9E86}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0287DA2E-5CB2-4B60-921D-D9B7AC7CA38C} + EndGlobalSection +EndGlobal diff --git a/CapnpCompatTest.sln b/CapnpCompatTest.sln new file mode 100644 index 0000000..f5bf7f5 --- /dev/null +++ b/CapnpCompatTest.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.28922.388 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CapnpCompatTest", "CapnpCompatTest\CapnpCompatTest.vcxproj", "{7A64A9FC-83B4-4248-B75A-754EB155B89C}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {7A64A9FC-83B4-4248-B75A-754EB155B89C}.Debug|x86.ActiveCfg = Debug|Win32 + {7A64A9FC-83B4-4248-B75A-754EB155B89C}.Debug|x86.Build.0 = Debug|Win32 + {7A64A9FC-83B4-4248-B75A-754EB155B89C}.Release|x86.ActiveCfg = Release|Win32 + {7A64A9FC-83B4-4248-B75A-754EB155B89C}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0A935F8E-223C-41AB-866D-D580FB86EA99} + EndGlobalSection +EndGlobal diff --git a/CapnpCompatTest/CapnpCompatTest.cpp b/CapnpCompatTest/CapnpCompatTest.cpp new file mode 100644 index 0000000..84259ce --- /dev/null +++ b/CapnpCompatTest/CapnpCompatTest.cpp @@ -0,0 +1,1413 @@ +// Build preconditions: +// - Have vcpkg installed +// > vcpkg integrate install +// > vcpkg install capnproto + +#include +#include +#include +#include "test.capnp.h" + +using namespace std; +using namespace capnp; +using namespace kj; +using namespace capnproto_test::capnp::test; + +void PrintUsage(const char* argv[]) +{ + cerr << "usage: " << argv[0] << "{client|server} HOST[:PORT]" << std::endl; +} + +inline Data::Reader data(const char* str) { + return Data::Reader(reinterpret_cast(str), strlen(str)); +} + +template +void genericInitTestMessage(Builder builder) { + builder.setVoidField(VOID); + builder.setVoidField(); // Means the same as above. + builder.setBoolField(true); + builder.setInt8Field(-123); + builder.setInt16Field(-12345); + builder.setInt32Field(-12345678); + builder.setInt64Field(-123456789012345ll); + builder.setUInt8Field(234u); + builder.setUInt16Field(45678u); + builder.setUInt32Field(3456789012u); + builder.setUInt64Field(12345678901234567890ull); + builder.setFloat32Field(1234.5); + builder.setFloat64Field(-123e45); + builder.setTextField("foo"); + builder.setDataField(data("bar")); + { + auto subBuilder = builder.initStructField(); + subBuilder.setVoidField(VOID); + subBuilder.setBoolField(true); + subBuilder.setInt8Field(-12); + subBuilder.setInt16Field(3456); + subBuilder.setInt32Field(-78901234); + subBuilder.setInt64Field(56789012345678ll); + subBuilder.setUInt8Field(90u); + subBuilder.setUInt16Field(1234u); + subBuilder.setUInt32Field(56789012u); + subBuilder.setUInt64Field(345678901234567890ull); + subBuilder.setFloat32Field(-1.25e-10f); + subBuilder.setFloat64Field(345); + subBuilder.setTextField("baz"); + subBuilder.setDataField(data("qux")); + { + auto subSubBuilder = subBuilder.initStructField(); + subSubBuilder.setTextField("nested"); + subSubBuilder.initStructField().setTextField("really nested"); + } + subBuilder.setEnumField(TestEnum::BAZ); + + subBuilder.setVoidList({ VOID, VOID, VOID }); + subBuilder.setBoolList({ false, true, false, true, true }); + subBuilder.setInt8List({ 12, -34, -0x80, 0x7f }); + subBuilder.setInt16List({ 1234, -5678, -0x8000, 0x7fff }); + // gcc warns on -0x800... and the only work-around I could find was to do -0x7ff...-1. + subBuilder.setInt32List({ 12345678, -90123456, -0x7fffffff - 1, 0x7fffffff }); + subBuilder.setInt64List({ 123456789012345ll, -678901234567890ll, -0x7fffffffffffffffll - 1, 0x7fffffffffffffffll }); + subBuilder.setUInt8List({ 12u, 34u, 0u, 0xffu }); + subBuilder.setUInt16List({ 1234u, 5678u, 0u, 0xffffu }); + subBuilder.setUInt32List({ 12345678u, 90123456u, 0u, 0xffffffffu }); + subBuilder.setUInt64List({ 123456789012345ull, 678901234567890ull, 0ull, 0xffffffffffffffffull }); + subBuilder.setFloat32List({ 0, 1234567, 1e37f, -1e37f, 1e-37f, -1e-37f }); + subBuilder.setFloat64List({ 0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306 }); + subBuilder.setTextList({ "quux", "corge", "grault" }); + subBuilder.setDataList({ data("garply"), data("waldo"), data("fred") }); + { + auto listBuilder = subBuilder.initStructList(3); + listBuilder[0].setTextField("x structlist 1"); + listBuilder[1].setTextField("x structlist 2"); + listBuilder[2].setTextField("x structlist 3"); + } + subBuilder.setEnumList({ TestEnum::QUX, TestEnum::BAR, TestEnum::GRAULT }); + } + builder.setEnumField(TestEnum::CORGE); + + builder.initVoidList(6); + builder.setBoolList({ true, false, false, true }); + builder.setInt8List({ 111, -111 }); + builder.setInt16List({ 11111, -11111 }); + builder.setInt32List({ 111111111, -111111111 }); + builder.setInt64List({ 1111111111111111111ll, -1111111111111111111ll }); + builder.setUInt8List({ 111u, 222u }); + builder.setUInt16List({ 33333u, 44444u }); + builder.setUInt32List({ 3333333333u }); + builder.setUInt64List({ 11111111111111111111ull }); + builder.setFloat32List({ 5555.5, kj::inf(), -kj::inf(), kj::nan() }); + builder.setFloat64List({ 7777.75, kj::inf(), -kj::inf(), kj::nan() }); + builder.setTextList({ "plugh", "xyzzy", "thud" }); + builder.setDataList({ data("oops"), data("exhausted"), data("rfc3092") }); + { + auto listBuilder = builder.initStructList(3); + listBuilder[0].setTextField("structlist 1"); + listBuilder[1].setTextField("structlist 2"); + listBuilder[2].setTextField("structlist 3"); + } + builder.setEnumList({ TestEnum::FOO, TestEnum::GARPLY }); +} + +template +void EXPECT_EQ(const T1& expected, const T2& actual) +{ + if (expected != actual) + cout << "Fail" << endl; +} + +void EXPECT_TRUE(bool truth) +{ + if (!truth) + cout << "Fail: Not true" << endl; +} + +void EXPECT_FALSE(bool lie) +{ + if (lie) + cout << "Fail: Not false" << endl; +} + +template +void ASSERT_EQ(const T1& expected, const T2& actual) +{ + if (expected != actual) + { + cout << "Fatal" << endl; + throw runtime_error("Failed assertion"); + } +} + +void EXPECT_FLOAT_EQ(float expected, float actual) +{ + EXPECT_EQ(expected, actual); +} + +void EXPECT_DOUBLE_EQ(double expected, double actual) +{ + EXPECT_EQ(expected, actual); +} + +template +inline void checkElement(T a, T b) { + EXPECT_EQ(a, b); +} + +template <> +inline void checkElement(float a, float b) { + EXPECT_FLOAT_EQ(a, b); +} + +template <> +inline void checkElement(double a, double b) { + EXPECT_DOUBLE_EQ(a, b); +} + +template +void checkList(T reader, std::initializer_list expected) { + ASSERT_EQ(expected.size(), reader.size()); + for (uint i = 0; i < expected.size(); i++) { + checkElement(expected.begin()[i], reader[i]); + } +} + +template +void checkList(T reader, std::initializer_list expected) { + ASSERT_EQ(expected.size(), reader.size()); + for (uint i = 0; i < expected.size(); i++) { + checkElement(expected.begin()[i], reader[i]); + } +} + +template +void genericCheckTestMessage(Reader reader) { + EXPECT_EQ(VOID, reader.getVoidField()); + EXPECT_EQ(true, reader.getBoolField()); + EXPECT_EQ(-123, reader.getInt8Field()); + EXPECT_EQ(-12345, reader.getInt16Field()); + EXPECT_EQ(-12345678, reader.getInt32Field()); + EXPECT_EQ(-123456789012345ll, reader.getInt64Field()); + EXPECT_EQ(234u, reader.getUInt8Field()); + EXPECT_EQ(45678u, reader.getUInt16Field()); + EXPECT_EQ(3456789012u, reader.getUInt32Field()); + EXPECT_EQ(12345678901234567890ull, reader.getUInt64Field()); + EXPECT_FLOAT_EQ(1234.5f, reader.getFloat32Field()); + EXPECT_DOUBLE_EQ(-123e45, reader.getFloat64Field()); + EXPECT_EQ("foo", reader.getTextField()); + EXPECT_EQ(data("bar"), reader.getDataField()); + { + auto subReader = reader.getStructField(); + EXPECT_EQ(VOID, subReader.getVoidField()); + EXPECT_EQ(true, subReader.getBoolField()); + EXPECT_EQ(-12, subReader.getInt8Field()); + EXPECT_EQ(3456, subReader.getInt16Field()); + EXPECT_EQ(-78901234, subReader.getInt32Field()); + EXPECT_EQ(56789012345678ll, subReader.getInt64Field()); + EXPECT_EQ(90u, subReader.getUInt8Field()); + EXPECT_EQ(1234u, subReader.getUInt16Field()); + EXPECT_EQ(56789012u, subReader.getUInt32Field()); + EXPECT_EQ(345678901234567890ull, subReader.getUInt64Field()); + EXPECT_FLOAT_EQ(-1.25e-10f, subReader.getFloat32Field()); + EXPECT_DOUBLE_EQ(345, subReader.getFloat64Field()); + EXPECT_EQ("baz", subReader.getTextField()); + EXPECT_EQ(data("qux"), subReader.getDataField()); + { + auto subSubReader = subReader.getStructField(); + EXPECT_EQ("nested", subSubReader.getTextField()); + EXPECT_EQ("really nested", subSubReader.getStructField().getTextField()); + } + EXPECT_EQ(TestEnum::BAZ, subReader.getEnumField()); + + checkList(subReader.getVoidList(), { VOID, VOID, VOID }); + checkList(subReader.getBoolList(), { false, true, false, true, true }); + checkList(subReader.getInt8List(), { 12, -34, -0x80, 0x7f }); + checkList(subReader.getInt16List(), { 1234, -5678, -0x8000, 0x7fff }); + // gcc warns on -0x800... and the only work-around I could find was to do -0x7ff...-1. + checkList(subReader.getInt32List(), { 12345678, -90123456, -0x7fffffff - 1, 0x7fffffff }); + checkList(subReader.getInt64List(), { 123456789012345ll, -678901234567890ll, -0x7fffffffffffffffll - 1, 0x7fffffffffffffffll }); + checkList(subReader.getUInt8List(), { 12u, 34u, 0u, 0xffu }); + checkList(subReader.getUInt16List(), { 1234u, 5678u, 0u, 0xffffu }); + checkList(subReader.getUInt32List(), { 12345678u, 90123456u, 0u, 0xffffffffu }); + checkList(subReader.getUInt64List(), { 123456789012345ull, 678901234567890ull, 0ull, 0xffffffffffffffffull }); + checkList(subReader.getFloat32List(), { 0.0f, 1234567.0f, 1e37f, -1e37f, 1e-37f, -1e-37f }); + checkList(subReader.getFloat64List(), { 0.0, 123456789012345.0, 1e306, -1e306, 1e-306, -1e-306 }); + checkList(subReader.getTextList(), { "quux", "corge", "grault" }); + checkList(subReader.getDataList(), { data("garply"), data("waldo"), data("fred") }); + { + auto listReader = subReader.getStructList(); + ASSERT_EQ(3u, listReader.size()); + EXPECT_EQ("x structlist 1", listReader[0].getTextField()); + EXPECT_EQ("x structlist 2", listReader[1].getTextField()); + EXPECT_EQ("x structlist 3", listReader[2].getTextField()); + } + checkList(subReader.getEnumList(), { TestEnum::QUX, TestEnum::BAR, TestEnum::GRAULT }); + } + EXPECT_EQ(TestEnum::CORGE, reader.getEnumField()); + + EXPECT_EQ(6u, reader.getVoidList().size()); + checkList(reader.getBoolList(), { true, false, false, true }); + checkList(reader.getInt8List(), { 111, -111 }); + checkList(reader.getInt16List(), { 11111, -11111 }); + checkList(reader.getInt32List(), { 111111111, -111111111 }); + checkList(reader.getInt64List(), { 1111111111111111111ll, -1111111111111111111ll }); + checkList(reader.getUInt8List(), { 111u, 222u }); + checkList(reader.getUInt16List(), { 33333u, 44444u }); + checkList(reader.getUInt32List(), { 3333333333u }); + checkList(reader.getUInt64List(), { 11111111111111111111ull }); + { + auto listReader = reader.getFloat32List(); + ASSERT_EQ(4u, listReader.size()); + EXPECT_EQ(5555.5f, listReader[0]); + EXPECT_EQ(kj::inf(), listReader[1]); + EXPECT_EQ(-kj::inf(), listReader[2]); + EXPECT_TRUE(isNaN(listReader[3])); + } + { + auto listReader = reader.getFloat64List(); + ASSERT_EQ(4u, listReader.size()); + EXPECT_EQ(7777.75, listReader[0]); + EXPECT_EQ(kj::inf(), listReader[1]); + EXPECT_EQ(-kj::inf(), listReader[2]); + EXPECT_TRUE(isNaN(listReader[3])); + } + checkList(reader.getTextList(), { "plugh", "xyzzy", "thud" }); + checkList(reader.getDataList(), { data("oops"), data("exhausted"), data("rfc3092") }); + { + auto listReader = reader.getStructList(); + ASSERT_EQ(3u, listReader.size()); + EXPECT_EQ("structlist 1", listReader[0].getTextField()); + EXPECT_EQ("structlist 2", listReader[1].getTextField()); + EXPECT_EQ("structlist 3", listReader[2].getTextField()); + } + checkList(reader.getEnumList(), { TestEnum::FOO, TestEnum::GARPLY }); +} + +class TestInterfaceImpl final : public TestInterface::Server +{ + int& callCount_; + +public: + TestInterfaceImpl(int& callCount): + callCount_(callCount) + { + } + + ~TestInterfaceImpl() + { + cout << "~" << endl; + } + + kj::Promise foo(FooContext context) override + { + ++callCount_; + auto params = context.getParams(); + cout << "foo " << params.getI() << " " << params.getJ() << endl; + context.initResults().setX("foo"); + return kj::READY_NOW; + } + + kj::Promise baz(BazContext context) override + { + ++callCount_; + cout << "baz" << endl; + try + { + genericCheckTestMessage(context.getParams().getS()); + } + catch (const runtime_error&) + { + } + cout << "baz fin" << endl; + return kj::READY_NOW; + } + +}; + +class TestCapDestructor final : public TestInterface::Server { + // Implementation of TestInterface that notifies when it is destroyed. + +public: + TestCapDestructor(kj::Own>&& fulfiller) + : fulfiller(kj::mv(fulfiller)), impl(dummy) {} + + ~TestCapDestructor() { + fulfiller->fulfill(); + } + + kj::Promise foo(FooContext context) { + return impl.foo(context); + } + +private: + kj::Own> fulfiller; + int dummy = 0; + TestInterfaceImpl impl; +}; + +class TestExtendsImpl final : public TestExtends::Server +{ +public: + ~TestExtendsImpl() + { + cout << "~" << endl; + } + + kj::Promise foo(FooContext context) { + cout << "foo" << endl; + auto params = context.getParams(); + auto result = context.getResults(); + EXPECT_EQ(321, params.getI()); + EXPECT_FALSE(params.getJ()); + result.setX("bar"); + return kj::READY_NOW; + } + + kj::Promise grault(GraultContext context) { + cout << "grault" << endl; + context.releaseParams(); + + genericInitTestMessage(context.getResults()); + + return kj::READY_NOW; + } + +}; + +class TestPipelineImpl final : public TestPipeline::Server +{ +public: + ~TestPipelineImpl() + { + cout << "~" << endl; + } + + kj::Promise getCap(GetCapContext context) override { + cout << "getCap" << endl; + + auto params = context.getParams(); + EXPECT_EQ(234, params.getN()); + + auto cap = params.getInCap(); + context.releaseParams(); + + auto request = cap.fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [this, KJ_CPCAP(context)](Response&& response) mutable { + EXPECT_EQ("foo", response.getX()); + + auto result = context.getResults(); + result.setS("bar"); + result.initOutBox().setCap(kj::heap()); + cout << "getCap fin" << endl; + }); + } + + kj::Promise getAnyCap(GetAnyCapContext context) override { + cout << "getAnyCap" << endl; + + auto params = context.getParams(); + EXPECT_EQ(234, params.getN()); + + auto cap = params.getInCap(); + context.releaseParams(); + + auto request = cap.castAs().fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [this, KJ_CPCAP(context)](Response&& response) mutable { + EXPECT_EQ("foo", response.getX()); + + auto result = context.getResults(); + result.setS("bar"); + result.initOutBox().setCap(kj::heap()); + cout << "getAnyCap fin" << endl; + }); + } + +}; + +class TestCallOrderImpl final : public TestCallOrder::Server +{ +public: + uint32_t count; + + TestCallOrderImpl() : count(0) + { + } + + ~TestCallOrderImpl() + { + cout << "~" << endl; + } + + kj::Promise getCallSequence(GetCallSequenceContext context) override + { + auto result = context.getResults(); + result.setN(count++); + return kj::READY_NOW; + } +}; + +class TestTailCallerImpl final : public TestTailCaller::Server +{ +public: + ~TestTailCallerImpl() + { + cout << "~" << endl; + } + + kj::Promise foo(FooContext context) override + { + cout << "foo" << endl; + + auto params = context.getParams(); + auto tailRequest = params.getCallee().fooRequest(); + tailRequest.setI(params.getI()); + tailRequest.setT("from TestTailCaller"); + return context.tailCall(kj::mv(tailRequest)); + } +}; + +class TestTailCalleeImpl final : public TestTailCallee::Server +{ + int& callCount_; + +public: + TestTailCalleeImpl(int& callCount) : callCount_(callCount) + { + } + + ~TestTailCalleeImpl() + { + cout << "~" << endl; + } + + kj::Promise foo(FooContext context) override + { + ++callCount_; + + cout << "foo" << endl; + + auto params = context.getParams(); + auto results = context.getResults(); + + results.setI(params.getI()); + results.setT(params.getT()); + results.setC(kj::heap()); + + return kj::READY_NOW; + } +}; + +class HandleImpl final : public TestHandle::Server +{ +public: + HandleImpl() + { + cout << "++" << endl; + } + + ~HandleImpl() + { + cout << "--" << endl; + } +}; + +class TestMoreStuffImpl final : public TestMoreStuff::Server +{ +public: + uint32_t callCount; + TestInterface::Client clientToHold; + + TestMoreStuffImpl() : + callCount(0), + clientToHold(nullptr) + { + } + + ~TestMoreStuffImpl() + { + cout << "~" << endl; + } + + kj::Promise getCallSequence(GetCallSequenceContext context) override + { + cout << "getCallSequence" << endl; + + auto result = context.getResults(); + result.setN(callCount++); + return kj::READY_NOW; + } + + kj::Promise callFoo(CallFooContext context) override + { + ++callCount; + cout << "callFoo" << endl; + + auto params = context.getParams(); + auto cap = params.getCap(); + + auto request = cap.fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [KJ_CPCAP(context)](Response&& response) mutable { + EXPECT_EQ("foo", response.getX()); + context.getResults().setS("bar"); + cout << "fin" << endl; + }); + } + + kj::Promise callFooWhenResolved(CallFooWhenResolvedContext context) override { + ++callCount; + cout << "callFooWhenResolved" << endl; + + auto params = context.getParams(); + auto cap = params.getCap(); + + return cap.whenResolved().then([KJ_CPCAP(cap), KJ_CPCAP(context)]() mutable { + auto request = cap.fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [KJ_CPCAP(context)](Response&& response) mutable { + EXPECT_EQ("foo", response.getX()); + context.getResults().setS("bar"); + cout << "fin" << endl; + }); + }); + } + + kj::Promise neverReturn(NeverReturnContext context) override { + ++callCount; + cout << "neverReturn" << endl; + + // Attach `cap` to the promise to make sure it is released. + auto promise = kj::Promise(kj::NEVER_DONE).attach(context.getParams().getCap()); + + // Also attach `cap` to the result struct to make sure that is released. + context.getResults().setCapCopy(context.getParams().getCap()); + + context.allowCancellation(); + return kj::mv(promise); + } + + kj::Promise hold(HoldContext context) override + { + ++callCount; + cout << "hold" << endl; + + auto params = context.getParams(); + clientToHold = params.getCap(); + return kj::READY_NOW; + } + + kj::Promise callHeld(CallHeldContext context) override + { + ++callCount; + cout << "callHeld" << endl; + + auto request = clientToHold.fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [KJ_CPCAP(context)](Response&& response) mutable { + EXPECT_EQ("foo", response.getX()); + context.getResults().setS("bar"); + }); + } + + kj::Promise getHeld(GetHeldContext context) + { + ++callCount; + cout << "getHeld" << endl; + + auto result = context.getResults(); + result.setCap(clientToHold); + return kj::READY_NOW; + } + + kj::Promise echo(EchoContext context) + { + ++callCount; + cout << "echo" << endl; + + auto params = context.getParams(); + auto result = context.getResults(); + result.setCap(params.getCap()); + return kj::READY_NOW; + } + + kj::Promise expectCancel(ExpectCancelContext context) + { + cout << "expectCancel" << endl; + auto cap = context.getParams().getCap(); + context.allowCancellation(); + // return loop(0, cap, context); + return kj::NEVER_DONE; + } + + kj::Promise loop(uint depth, TestInterface::Client cap, ExpectCancelContext context) + { + if (depth > 100000000) { + cout << "Looped too long, giving up." << endl; + return kj::READY_NOW; + } + else { + return kj::evalLater([this, depth, KJ_CPCAP(cap), KJ_CPCAP(context)]() mutable { + return loop(depth + 1, cap, context); + }); + } + } + + kj::Promise getHandle(GetHandleContext context) override + { + cout << "getHandle" << endl; + context.getResults().setHandle(kj::heap()); + return kj::READY_NOW; + } + + kj::Promise getNull(GetNullContext context) + { + cout << "getNull" << endl; + return kj::READY_NOW; + } + + kj::Promise getEnormousString(GetEnormousStringContext context) + { + cout << "getEnormousString" << endl; + context.getResults().initStr(100000000); // 100MB + return kj::READY_NOW; + } +}; + +void BasicTest(capnp::EzRpcClient& rpc) +{ + cout << "Basic test start" << endl; + + auto client = rpc.getMain(); + + auto request1 = client.fooRequest(); + request1.setI(123); + request1.setJ(true); + auto promise1 = request1.send(); + + // We used to call bar() after baz(), hence the numbering, but this masked the case where the + // RPC system actually disconnected on bar() (thus returning an exception, which we decided + // was expected). + bool barFailed = false; + auto request3 = client.barRequest(); + auto promise3 = request3.send().then( + [](Response&& response) { + cout << "Expected bar() call to fail." << endl; + }, [&](kj::Exception&& e) { + barFailed = true; + }); + + auto request2 = client.bazRequest(); + genericInitTestMessage(request2.initS()); + auto promise2 = request2.send(); + + auto response1 = promise1.wait(rpc.getWaitScope()); + + EXPECT_EQ("foo", response1.getX()); + + auto response2 = promise2.wait(rpc.getWaitScope()); + + promise3.wait(rpc.getWaitScope()); + + EXPECT_TRUE(barFailed); + + cout << "Basic test end" << endl; +} + +void PipeliningTest(capnp::EzRpcClient& rpc) +{ + cout << "Pipelining test start" << endl; + + auto client = rpc.getMain(); + + int chainedCallCount = 0; + + auto request = client.getCapRequest(); + request.setN(234); + request.setInCap(kj::heap(chainedCallCount)); + + auto promise = request.send(); + + auto pipelineRequest = promise.getOutBox().getCap().fooRequest(); + pipelineRequest.setI(321); + auto pipelinePromise = pipelineRequest.send(); + + auto pipelineRequest2 = promise.getOutBox().getCap().castAs().graultRequest(); + auto pipelinePromise2 = pipelineRequest2.send(); + + promise = nullptr; // Just to be annoying, drop the original promise. + + EXPECT_EQ(0, chainedCallCount); + + auto response = pipelinePromise.wait(rpc.getWaitScope()); + EXPECT_EQ("bar", response.getX()); + + auto response2 = pipelinePromise2.wait(rpc.getWaitScope()); + genericCheckTestMessage((TestAllTypes::Reader)response2); + + EXPECT_EQ(1, chainedCallCount); + + cout << "Pipelining test end" << endl; +} + +void ReleaseTest(capnp::EzRpcClient& rpc) +{ + cout << "Release test start" << endl; + + auto client = rpc.getMain(); + + auto& waitScope = rpc.getWaitScope(); + auto handle1 = client.getHandleRequest().send().wait(waitScope).getHandle(); + auto promise = client.getHandleRequest().send(); + auto handle2 = promise.wait(waitScope).getHandle(); + + string s; + cout << "sync" << endl; + cin >> s; + + handle1 = nullptr; + for (uint i = 0; i < 16; i++) kj::evalLater([]() {}).wait(waitScope); + + cout << "handle1 null" << endl; + cin >> s; + + handle2 = nullptr; + for (uint i = 0; i < 16; i++) kj::evalLater([]() {}).wait(waitScope); + + cout << "handle2 null" << endl; + cin >> s; + + promise = nullptr; + for (uint i = 0; i < 16; i++) kj::evalLater([]() {}).wait(waitScope); + waitScope.poll(); + + cout << "promise null" << endl; + cin >> s; + + cout << "Release test end" << endl; +} + +void ReleaseOnCancelTest(capnp::EzRpcClient& rpc) +{ + cout << "ReleaseOnCancel test start" << endl; + + auto client = rpc.getMain(); + + auto& waitScope = rpc.getWaitScope(); + + { + auto promise = client.getHandleRequest().send(); + + // If the server receives cancellation too early, it won't even return a capability in the + // results, it will just return "canceled". We want to emulate the case where the return message + // and the cancel (finish) message cross paths. It turns out that exactly two evalLater()s get + // us there. + // + // TODO(cleanup): This is fragile, but I'm not sure how else to write it without a ton + // of scaffolding. + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + waitScope.poll(); + } + + for (uint i = 0; i < 16; i++) kj::evalLater([]() {}).wait(waitScope); + waitScope.poll(); + + cout << "ReleaseOnCancel test end" << endl; +} + +void TailCallTest(capnp::EzRpcClient& rpc) +{ + cout << "TailCall test start" << endl; + + auto caller = rpc.getMain(); + + auto& waitScope = rpc.getWaitScope(); + + int calleeCallCount = 0; + + TestTailCallee::Client callee(kj::heap(calleeCallCount)); + + auto request = caller.fooRequest(); + request.setI(456); + request.setCallee(callee); + + auto promise = request.send(); + + auto dependentCall0 = promise.getC().getCallSequenceRequest().send(); + + auto response = promise.wait(waitScope); + EXPECT_EQ(456, response.getI()); + EXPECT_EQ("from TestTailCaller", response.getT()); + + auto dependentCall1 = promise.getC().getCallSequenceRequest().send(); + + auto dependentCall2 = response.getC().getCallSequenceRequest().send(); + + EXPECT_EQ(0, dependentCall0.wait(waitScope).getN()); + EXPECT_EQ(1, dependentCall1.wait(waitScope).getN()); + EXPECT_EQ(2, dependentCall2.wait(waitScope).getN()); + + EXPECT_EQ(1, calleeCallCount); + + cout << "TailCall test end" << endl; +} + +void CancelationTest(capnp::EzRpcClient& rpc) +{ + cout << "Cancelation test start" << endl; + + auto paf = kj::newPromiseAndFulfiller(); + bool destroyed = false; + auto destructionPromise = paf.promise.then([&]() { destroyed = true; }).eagerlyEvaluate(nullptr); + + auto client = rpc.getMain(); + + kj::Promise promise = nullptr; + + bool returned = false; + { + auto request = client.expectCancelRequest(); + request.setCap(kj::heap(kj::mv(paf.fulfiller))); + promise = request.send().then( + [&](Response&& response) { + returned = true; + }).eagerlyEvaluate(nullptr); + } + + auto& waitScope = rpc.getWaitScope(); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + + // We can detect that the method was canceled because it will drop the cap. + EXPECT_FALSE(destroyed); + EXPECT_FALSE(returned); + + promise = nullptr; // request cancellation + destructionPromise.wait(waitScope); + + EXPECT_TRUE(destroyed); + EXPECT_FALSE(returned); + + cout << "Cancelation test end" << endl; +} + +void PromiseResolveTest(capnp::EzRpcClient& rpc) +{ + cout << "PromiseResolve test start" << endl; + + auto client = rpc.getMain(); + + int chainedCallCount = 0; + + auto request = client.callFooRequest(); + auto request2 = client.callFooWhenResolvedRequest(); + + auto paf = kj::newPromiseAndFulfiller(); + + { + auto fork = paf.promise.fork(); + request.setCap(fork.addBranch()); + request2.setCap(fork.addBranch()); + } + + auto promise = request.send(); + auto promise2 = request2.send(); + + auto& waitScope = rpc.getWaitScope(); + + // Make sure getCap() has been called on the server side by sending another call and waiting + // for it. + EXPECT_EQ(2, client.getCallSequenceRequest().send().wait(waitScope).getN()); + + // OK, now fulfill the local promise. + paf.fulfiller->fulfill(kj::heap(chainedCallCount)); + + // We should now be able to wait for getCap() to finish. + EXPECT_EQ("bar", promise.wait(waitScope).getS()); + EXPECT_EQ("bar", promise2.wait(waitScope).getS()); + + EXPECT_EQ(2, chainedCallCount); + + cout << "PromiseResolve test end" << endl; +} + +void RetainAndReleaseTest(capnp::EzRpcClient& rpc) +{ + cout << "RetainAndRelease test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto paf = kj::newPromiseAndFulfiller(); + bool destroyed = false; + auto destructionPromise = paf.promise.then([&]() { destroyed = true; }).eagerlyEvaluate(nullptr); + + { + auto client = rpc.getMain(); + + { + auto request = client.holdRequest(); + request.setCap(kj::heap(kj::mv(paf.fulfiller))); + request.send().wait(waitScope); + } + + // Do some other call to add a round trip. + EXPECT_EQ(1, client.getCallSequenceRequest().send().wait(waitScope).getN()); + + // Shouldn't be destroyed because it's being held by the server. + EXPECT_FALSE(destroyed); + + // We can ask it to call the held capability. + EXPECT_EQ("bar", client.callHeldRequest().send().wait(waitScope).getS()); + + { + // We can get the cap back from it. + auto capCopy = client.getHeldRequest().send().wait(waitScope).getCap(); + + { + // And call it, without any network communications. + auto request = capCopy.fooRequest(); + request.setI(123); + request.setJ(true); + EXPECT_EQ("foo", request.send().wait(waitScope).getX()); + } + + { + // We can send another copy of the same cap to another method, and it works. + auto request = client.callFooRequest(); + request.setCap(capCopy); + EXPECT_EQ("bar", request.send().wait(waitScope).getS()); + } + } + + // Give some time to settle. + EXPECT_EQ(5, client.getCallSequenceRequest().send().wait(waitScope).getN()); + EXPECT_EQ(6, client.getCallSequenceRequest().send().wait(waitScope).getN()); + EXPECT_EQ(7, client.getCallSequenceRequest().send().wait(waitScope).getN()); + + // Can't be destroyed, we haven't released it. + EXPECT_FALSE(destroyed); + + // Different from original test, request the server to hold a null cap, + // leading to the destruction of the former cap. + auto holdNull = client.holdRequest(); + holdNull.send().wait(waitScope); + } + + destructionPromise.wait(waitScope); + EXPECT_TRUE(destroyed); + + cout << "RetainAndRelease test end" << endl; +} + +void CancelTest(capnp::EzRpcClient& rpc) +{ + cout << "Cancel test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto paf = kj::newPromiseAndFulfiller(); + bool destroyed = false; + auto destructionPromise = paf.promise.then([&]() { destroyed = true; }).eagerlyEvaluate(nullptr); + + { + auto request = client.neverReturnRequest(); + request.setCap(kj::heap(kj::mv(paf.fulfiller))); + + { + auto responsePromise = request.send(); + + // Allow some time to settle. + EXPECT_EQ(1u, client.getCallSequenceRequest().send().wait(waitScope).getN()); + EXPECT_EQ(2u, client.getCallSequenceRequest().send().wait(waitScope).getN()); + + // The cap shouldn't have been destroyed yet because the call never returned. + EXPECT_FALSE(destroyed); + } + } + + // Now the cap should be released. + destructionPromise.wait(waitScope); + EXPECT_TRUE(destroyed); + + cout << "Cancel test end" << endl; +} + +void SendTwiceTest(capnp::EzRpcClient& rpc) +{ + cout << "SendTwice test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto paf = kj::newPromiseAndFulfiller(); + bool destroyed = false; + auto destructionPromise = paf.promise.then([&]() { destroyed = true; }).eagerlyEvaluate(nullptr); + + auto cap = TestInterface::Client(kj::heap(kj::mv(paf.fulfiller))); + + { + auto request = client.callFooRequest(); + request.setCap(cap); + + EXPECT_EQ("bar", request.send().wait(waitScope).getS()); + } + + // Allow some time for the server to release `cap`. + EXPECT_EQ(1, client.getCallSequenceRequest().send().wait(waitScope).getN()); + + { + // More requests with the same cap. + auto request = client.callFooRequest(); + auto request2 = client.callFooRequest(); + request.setCap(cap); + request2.setCap(kj::mv(cap)); + + auto promise = request.send(); + auto promise2 = request2.send(); + + EXPECT_EQ("bar", promise.wait(waitScope).getS()); + EXPECT_EQ("bar", promise2.wait(waitScope).getS()); + } + + // Now the cap should be released. + destructionPromise.wait(waitScope); + EXPECT_TRUE(destroyed); + + cout << "SendTwice test end" << endl; +} + +RemotePromise getCallSequence( + TestCallOrder::Client& client, uint expected) { + auto req = client.getCallSequenceRequest(); + req.setExpected(expected); + return req.send(); +} + +void EmbargoTest(capnp::EzRpcClient& rpc) +{ + cout << "Embargo test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto cap = TestCallOrder::Client(kj::heap()); + + auto earlyCall = client.getCallSequenceRequest().send(); + + auto echoRequest = client.echoRequest(); + echoRequest.setCap(cap); + auto echo = echoRequest.send(); + + auto pipeline = echo.getCap(); + + auto call0 = getCallSequence(pipeline, 0); + auto call1 = getCallSequence(pipeline, 1); + + earlyCall.wait(waitScope); + + auto call2 = getCallSequence(pipeline, 2); + + auto resolved = echo.wait(waitScope).getCap(); + + auto call3 = getCallSequence(pipeline, 3); + auto call4 = getCallSequence(pipeline, 4); + auto call5 = getCallSequence(pipeline, 5); + + EXPECT_EQ(0, call0.wait(waitScope).getN()); + EXPECT_EQ(1, call1.wait(waitScope).getN()); + EXPECT_EQ(2, call2.wait(waitScope).getN()); + EXPECT_EQ(3, call3.wait(waitScope).getN()); + EXPECT_EQ(4, call4.wait(waitScope).getN()); + EXPECT_EQ(5, call5.wait(waitScope).getN()); + + cout << "Embargo test end" << endl; +} + +template +void expectPromiseThrows(kj::Promise&& promise, kj::WaitScope& waitScope) { + EXPECT_TRUE(promise.then([](T&&) { return false; }, [](kj::Exception&&) { return true; }) + .wait(waitScope)); +} + +template <> +void expectPromiseThrows(kj::Promise&& promise, kj::WaitScope& waitScope) { + EXPECT_TRUE(promise.then([]() { return false; }, [](kj::Exception&&) { return true; }) + .wait(waitScope)); +} + +void EmbargoErrorTest(capnp::EzRpcClient& rpc) +{ + cout << "EmbargoError test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto paf = kj::newPromiseAndFulfiller(); + + auto cap = TestCallOrder::Client(kj::mv(paf.promise)); + + auto earlyCall = client.getCallSequenceRequest().send(); + + auto echoRequest = client.echoRequest(); + echoRequest.setCap(cap); + auto echo = echoRequest.send(); + + auto pipeline = echo.getCap(); + + auto call0 = getCallSequence(pipeline, 0); + auto call1 = getCallSequence(pipeline, 1); + + earlyCall.wait(waitScope); + + auto call2 = getCallSequence(pipeline, 2); + + auto resolved = echo.wait(waitScope).getCap(); + + auto call3 = getCallSequence(pipeline, 3); + auto call4 = getCallSequence(pipeline, 4); + auto call5 = getCallSequence(pipeline, 5); + + paf.fulfiller->rejectIfThrows([]() { KJ_FAIL_ASSERT("foo") { break; } }); + + expectPromiseThrows(kj::mv(call0), waitScope); + expectPromiseThrows(kj::mv(call1), waitScope); + expectPromiseThrows(kj::mv(call2), waitScope); + expectPromiseThrows(kj::mv(call3), waitScope); + expectPromiseThrows(kj::mv(call4), waitScope); + expectPromiseThrows(kj::mv(call5), waitScope); + + // Verify that we're still connected (there were no protocol errors). + getCallSequence(client, 1).wait(waitScope); + + cout << "EmbargoError test end" << endl; +} + +void EmbargoNullTest(capnp::EzRpcClient& rpc) +{ + cout << "EmbargoNull test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto promise = client.getNullRequest().send(); + + auto cap = promise.getNullCap(); + + auto call0 = cap.getCallSequenceRequest().send(); + + promise.wait(waitScope); + + auto call1 = cap.getCallSequenceRequest().send(); + + expectPromiseThrows(kj::mv(call0), waitScope); + expectPromiseThrows(kj::mv(call1), waitScope); + + // Verify that we're still connected (there were no protocol errors). + getCallSequence(client, 0).wait(waitScope); + + cout << "EmbargoNull test end" << endl; +} + +void CallBrokenPromiseTest(capnp::EzRpcClient& rpc) +{ + cout << "CallBrokenPromise test start" << endl; + + auto& waitScope = rpc.getWaitScope(); + + auto client = rpc.getMain(); + + auto paf = kj::newPromiseAndFulfiller(); + + { + auto req = client.holdRequest(); + req.setCap(kj::mv(paf.promise)); + req.send().wait(waitScope); + } + + bool returned = false; + auto req = client.callHeldRequest().send() + .then([&](capnp::Response&&) { + returned = true; + }, [&](kj::Exception&& e) { + returned = true; + kj::throwRecoverableException(kj::mv(e)); + }).eagerlyEvaluate(nullptr); + + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + + EXPECT_FALSE(returned); + + paf.fulfiller->rejectIfThrows([]() { KJ_FAIL_ASSERT("foo") { break; } }); + + expectPromiseThrows(kj::mv(req), waitScope); + EXPECT_TRUE(returned); + + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + kj::evalLater([]() {}).wait(waitScope); + + // Verify that we're still connected (there were no protocol errors). + getCallSequence(client, 1).wait(waitScope); + + cout << "CallBrokenPromise test end" << endl; +} + +int main(int argc, const char* argv[]) +{ + if (argc != 3) + { + PrintUsage(argv); + return 1; + } + + if (strncmp(argv[1], "client", 6) == 0) + { + try + { + capnp::EzRpcClient client(argv[2], 33444); + cout << "Connecting" << endl; + + auto& waitScope = client.getWaitScope(); + + if (strcmp(argv[1], "client:Basic") == 0) + { + BasicTest(client); + } + else if (strcmp(argv[1], "client:Pipelining") == 0) + { + PipeliningTest(client); + } + else if (strcmp(argv[1], "client:Release") == 0) + { + ReleaseTest(client); + } + else if (strcmp(argv[1], "client:ReleaseOnCancel") == 0) + { + ReleaseOnCancelTest(client); + } + else if (strcmp(argv[1], "client:TailCall") == 0) + { + TailCallTest(client); + } + else if (strcmp(argv[1], "client:Cancelation") == 0) + { + CancelationTest(client); + } + else if (strcmp(argv[1], "client:PromiseResolve") == 0) + { + PromiseResolveTest(client); + } + else if (strcmp(argv[1], "client:RetainAndRelease") == 0) + { + RetainAndReleaseTest(client); + } + else if (strcmp(argv[1], "client:Cancel") == 0) + { + CancelTest(client); + } + else if (strcmp(argv[1], "client:SendTwice") == 0) + { + SendTwiceTest(client); + } + else if (strcmp(argv[1], "client:Embargo") == 0) + { + EmbargoTest(client); + } + else if (strcmp(argv[1], "client:EmbargoError") == 0) + { + EmbargoErrorTest(client); + } + else if (strcmp(argv[1], "client:EmbargoNull") == 0) + { + EmbargoNullTest(client); + } + else if (strcmp(argv[1], "client:CallBrokenPromise") == 0) + { + CallBrokenPromiseTest(client); + } + } + catch (const std::exception& exception) + { + cerr << exception.what() << endl; + } + } + else if (strncmp(argv[1], "server", 6) == 0) + { + int callCount = 0; + Capability::Client mainInterface = nullptr; + + if (strcmp(argv[1], "server:Interface") == 0) + { + mainInterface = kj::heap(callCount); + } + else if (strcmp(argv[1], "server:Pipeline") == 0) + { + mainInterface = kj::heap(); + } + else if (strcmp(argv[1], "server:MoreStuff") == 0) + { + mainInterface = kj::heap(); + } + else if (strcmp(argv[1], "server:TailCaller") == 0) + { + mainInterface = kj::heap(); + } + else + { + PrintUsage(argv); + return 2; + } + + capnp::EzRpcServer server(mainInterface, argv[2], 33444); + auto& waitScope = server.getWaitScope(); + + uint port = server.getPort().wait(waitScope); + cout << "Listening on port " << port << "..." << endl; + + kj::NEVER_DONE.wait(waitScope); + } + else + { + PrintUsage(argv); + return 2; + } +} diff --git a/CapnpCompatTest/CapnpCompatTest.vcxproj b/CapnpCompatTest/CapnpCompatTest.vcxproj new file mode 100644 index 0000000..82cc32f --- /dev/null +++ b/CapnpCompatTest/CapnpCompatTest.vcxproj @@ -0,0 +1,170 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + {7A64A9FC-83B4-4248-B75A-754EB155B89C} + Win32Proj + CapnpCompatTest + 10.0 + + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + + + Level3 + Disabled + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + ws2_32.lib;capnp.lib;capnp-rpc.lib;kj.lib;kj-async.lib;%(AdditionalDependencies) + + + + + + + Level3 + Disabled + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + + + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + ws2_32.lib;capnp.lib;capnp-rpc.lib;kj.lib;kj-async.lib;%(AdditionalDependencies) + + + + + + + Level3 + MaxSpeed + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + Document + + + + + + + + + \ No newline at end of file diff --git a/CapnpCompatTest/CapnpCompatTest.vcxproj.filters b/CapnpCompatTest/CapnpCompatTest.vcxproj.filters new file mode 100644 index 0000000..c3136b5 --- /dev/null +++ b/CapnpCompatTest/CapnpCompatTest.vcxproj.filters @@ -0,0 +1,38 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {7e4601d4-505e-49cf-8c37-16a70803f36a} + + + + + Quelldateien + + + + + Schema + + + Schema + + + + + Schema + + + \ No newline at end of file diff --git a/CapnpCompatTest/c++.capnp b/CapnpCompatTest/c++.capnp new file mode 100644 index 0000000..2bda547 --- /dev/null +++ b/CapnpCompatTest/c++.capnp @@ -0,0 +1,26 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0xbdf87d7bb8304e81; +$namespace("capnp::annotations"); + +annotation namespace(file): Text; +annotation name(field, enumerant, struct, enum, interface, method, param, group, union): Text; diff --git a/CapnpCompatTest/test.capnp b/CapnpCompatTest/test.capnp new file mode 100644 index 0000000..0a4a507 --- /dev/null +++ b/CapnpCompatTest/test.capnp @@ -0,0 +1,969 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0xd508eebdc2dc42b8; + +using Cxx = import "c++.capnp"; + +# Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified +# names for stuff in the capnproto namespace. +$Cxx.namespace("capnproto_test::capnp::test"); + +enum TestEnum { + foo @0; + bar @1; + baz @2; + qux @3; + quux @4; + corge @5; + grault @6; + garply @7; +} + +struct TestAllTypes { + voidField @0 : Void; + boolField @1 : Bool; + int8Field @2 : Int8; + int16Field @3 : Int16; + int32Field @4 : Int32; + int64Field @5 : Int64; + uInt8Field @6 : UInt8; + uInt16Field @7 : UInt16; + uInt32Field @8 : UInt32; + uInt64Field @9 : UInt64; + float32Field @10 : Float32; + float64Field @11 : Float64; + textField @12 : Text; + dataField @13 : Data; + structField @14 : TestAllTypes; + enumField @15 : TestEnum; + interfaceField @16 : Void; # TODO + + voidList @17 : List(Void); + boolList @18 : List(Bool); + int8List @19 : List(Int8); + int16List @20 : List(Int16); + int32List @21 : List(Int32); + int64List @22 : List(Int64); + uInt8List @23 : List(UInt8); + uInt16List @24 : List(UInt16); + uInt32List @25 : List(UInt32); + uInt64List @26 : List(UInt64); + float32List @27 : List(Float32); + float64List @28 : List(Float64); + textList @29 : List(Text); + dataList @30 : List(Data); + structList @31 : List(TestAllTypes); + enumList @32 : List(TestEnum); + interfaceList @33 : List(Void); # TODO +} + +struct TestDefaults { + voidField @0 : Void = void; + boolField @1 : Bool = true; + int8Field @2 : Int8 = -123; + int16Field @3 : Int16 = -12345; + int32Field @4 : Int32 = -12345678; + int64Field @5 : Int64 = -123456789012345; + uInt8Field @6 : UInt8 = 234; + uInt16Field @7 : UInt16 = 45678; + uInt32Field @8 : UInt32 = 3456789012; + uInt64Field @9 : UInt64 = 12345678901234567890; + float32Field @10 : Float32 = 1234.5; + float64Field @11 : Float64 = -123e45; + textField @12 : Text = "foo"; + dataField @13 : Data = 0x"62 61 72"; # "bar" + structField @14 : TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x " "structlist" + " 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + enumField @15 : TestEnum = corge; + interfaceField @16 : Void; # TODO + + voidList @17 : List(Void) = [void, void, void, void, void, void]; + boolList @18 : List(Bool) = [true, false, false, true]; + int8List @19 : List(Int8) = [111, -111]; + int16List @20 : List(Int16) = [11111, -11111]; + int32List @21 : List(Int32) = [111111111, -111111111]; + int64List @22 : List(Int64) = [1111111111111111111, -1111111111111111111]; + uInt8List @23 : List(UInt8) = [111, 222] ; + uInt16List @24 : List(UInt16) = [33333, 44444]; + uInt32List @25 : List(UInt32) = [3333333333]; + uInt64List @26 : List(UInt64) = [11111111111111111111]; + float32List @27 : List(Float32) = [5555.5, inf, -inf, nan]; + float64List @28 : List(Float64) = [7777.75, inf, -inf, nan]; + textList @29 : List(Text) = ["plugh", "xyzzy", "thud"]; + dataList @30 : List(Data) = ["oops", "exhausted", "rfc3092"]; + structList @31 : List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + enumList @32 : List(TestEnum) = [foo, garply]; + interfaceList @33 : List(Void); # TODO +} + +struct TestAnyPointer { + anyPointerField @0 :AnyPointer; + + # Do not add any other fields here! Some tests rely on anyPointerField being the last pointer + # in the struct. +} + +struct TestAnyOthers { + anyStructField @0 :AnyStruct; + anyListField @1 :AnyList; + capabilityField @2 :Capability; +} + +struct TestOutOfOrder { + foo @3 :Text; + bar @2 :Text; + baz @8 :Text; + qux @0 :Text; + quux @6 :Text; + corge @4 :Text; + grault @1 :Text; + garply @7 :Text; + waldo @5 :Text; +} + +struct TestUnion { + union0 @0! :union { + # Pack union 0 under ideal conditions: there is no unused padding space prior to it. + u0f0s0 @4: Void; + u0f0s1 @5: Bool; + u0f0s8 @6: Int8; + u0f0s16 @7: Int16; + u0f0s32 @8: Int32; + u0f0s64 @9: Int64; + u0f0sp @10: Text; + + # Pack more stuff into union0 -- should go in same space. + u0f1s0 @11: Void; + u0f1s1 @12: Bool; + u0f1s8 @13: Int8; + u0f1s16 @14: Int16; + u0f1s32 @15: Int32; + u0f1s64 @16: Int64; + u0f1sp @17: Text; + } + + # Pack one bit in order to make pathological situation for union1. + bit0 @18: Bool; + + union1 @1! :union { + # Pack pathologically bad case. Each field takes up new space. + u1f0s0 @19: Void; + u1f0s1 @20: Bool; + u1f1s1 @21: Bool; + u1f0s8 @22: Int8; + u1f1s8 @23: Int8; + u1f0s16 @24: Int16; + u1f1s16 @25: Int16; + u1f0s32 @26: Int32; + u1f1s32 @27: Int32; + u1f0s64 @28: Int64; + u1f1s64 @29: Int64; + u1f0sp @30: Text; + u1f1sp @31: Text; + + # Pack more stuff into union1 -- each should go into the same space as corresponding u1f0s*. + u1f2s0 @32: Void; + u1f2s1 @33: Bool; + u1f2s8 @34: Int8; + u1f2s16 @35: Int16; + u1f2s32 @36: Int32; + u1f2s64 @37: Int64; + u1f2sp @38: Text; + } + + # Fill in the rest of that bitfield from earlier. + bit2 @39: Bool; + bit3 @40: Bool; + bit4 @41: Bool; + bit5 @42: Bool; + bit6 @43: Bool; + bit7 @44: Bool; + + # Interleave two unions to be really annoying. + # Also declare in reverse order to make sure union discriminant values are sorted by field number + # and not by declaration order. + union2 @2! :union { + u2f0s64 @54: Int64; + u2f0s32 @52: Int32; + u2f0s16 @50: Int16; + u2f0s8 @47: Int8; + u2f0s1 @45: Bool; + } + + union3 @3! :union { + u3f0s64 @55: Int64; + u3f0s32 @53: Int32; + u3f0s16 @51: Int16; + u3f0s8 @48: Int8; + u3f0s1 @46: Bool; + } + + byte0 @49: UInt8; +} + +struct TestUnnamedUnion { + before @0 :Text; + + union { + foo @1 :UInt16; + bar @3 :UInt32; + } + + middle @2 :UInt16; + + after @4 :Text; +} + +struct TestUnionInUnion { + # There is no reason to ever do this. + outer :union { + inner :union { + foo @0 :Int32; + bar @1 :Int32; + } + baz @2 :Int32; + } +} + +struct TestGroups { + groups :union { + foo :group { + corge @0 :Int32; + grault @2 :Int64; + garply @8 :Text; + } + bar :group { + corge @3 :Int32; + grault @4 :Text; + garply @5 :Int64; + } + baz :group { + corge @1 :Int32; + grault @6 :Text; + garply @7 :Text; + } + } +} + +struct TestInterleavedGroups { + group1 :group { + foo @0 :UInt32; + bar @2 :UInt64; + union { + qux @4 :UInt16; + corge :group { + grault @6 :UInt64; + garply @8 :UInt16; + plugh @14 :Text; + xyzzy @16 :Text; + } + + fred @12 :Text; + } + + waldo @10 :Text; + } + + group2 :group { + foo @1 :UInt32; + bar @3 :UInt64; + union { + qux @5 :UInt16; + corge :group { + grault @7 :UInt64; + garply @9 :UInt16; + plugh @15 :Text; + xyzzy @17 :Text; + } + + fred @13 :Text; + } + + waldo @11 :Text; + } +} + +struct TestUnionDefaults { + s16s8s64s8Set @0 :TestUnion = + (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567), + union3 = (u3f0s8 = 55)); + s0sps1s32Set @1 :TestUnion = + (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true), + union3 = (u3f0s32 = 12345678)); + + unnamed1 @2 :TestUnnamedUnion = (foo = 123); + unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar"); +} + +struct TestNestedTypes { + enum NestedEnum { + foo @0; + bar @1; + } + + struct NestedStruct { + enum NestedEnum { + baz @0; + qux @1; + quux @2; + } + + outerNestedEnum @0 :TestNestedTypes.NestedEnum = bar; + innerNestedEnum @1 :NestedEnum = quux; + } + + nestedStruct @0 :NestedStruct; + + outerNestedEnum @1 :NestedEnum = bar; + innerNestedEnum @2 :NestedStruct.NestedEnum = quux; +} + +struct TestUsing { + using OuterNestedEnum = TestNestedTypes.NestedEnum; + using TestNestedTypes.NestedStruct.NestedEnum; + + outerNestedEnum @1 :OuterNestedEnum = bar; + innerNestedEnum @0 :NestedEnum = quux; +} + +struct TestLists { + # Small structs, when encoded as list, will be encoded as primitive lists rather than struct + # lists, to save space. + struct Struct0 { f @0 :Void; } + struct Struct1 { f @0 :Bool; } + struct Struct8 { f @0 :UInt8; } + struct Struct16 { f @0 :UInt16; } + struct Struct32 { f @0 :UInt32; } + struct Struct64 { f @0 :UInt64; } + struct StructP { f @0 :Text; } + + # Versions of the above which cannot be encoded as primitive lists. + struct Struct0c { f @0 :Void; pad @1 :Text; } + struct Struct1c { f @0 :Bool; pad @1 :Text; } + struct Struct8c { f @0 :UInt8; pad @1 :Text; } + struct Struct16c { f @0 :UInt16; pad @1 :Text; } + struct Struct32c { f @0 :UInt32; pad @1 :Text; } + struct Struct64c { f @0 :UInt64; pad @1 :Text; } + struct StructPc { f @0 :Text; pad @1 :UInt64; } + + list0 @0 :List(Struct0); + list1 @1 :List(Struct1); + list8 @2 :List(Struct8); + list16 @3 :List(Struct16); + list32 @4 :List(Struct32); + list64 @5 :List(Struct64); + listP @6 :List(StructP); + + int32ListList @7 :List(List(Int32)); + textListList @8 :List(List(Text)); + structListList @9 :List(List(TestAllTypes)); +} + +struct TestFieldZeroIsBit { + bit @0 :Bool; + secondBit @1 :Bool = true; + thirdField @2 :UInt8 = 123; +} + +struct TestListDefaults { + lists @0 :TestLists = ( + list0 = [(f = void), (f = void)], + list1 = [(f = true), (f = false), (f = true), (f = true)], + list8 = [(f = 123), (f = 45)], + list16 = [(f = 12345), (f = 6789)], + list32 = [(f = 123456789), (f = 234567890)], + list64 = [(f = 1234567890123456), (f = 2345678901234567)], + listP = [(f = "foo"), (f = "bar")], + int32ListList = [[1, 2, 3], [4, 5], [12341234]], + textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]], + structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]); +} + +struct TestLateUnion { + # Test what happens if the unions are not the first ordinals in the struct. At one point this + # was broken for the dynamic API. + + foo @0 :Int32; + bar @1 :Text; + baz @2 :Int16; + + theUnion @3! :union { + qux @4 :Text; + corge @5 :List(Int32); + grault @6 :Float32; + } + + anotherUnion @7! :union { + qux @8 :Text; + corge @9 :List(Int32); + grault @10 :Float32; + } +} + +struct TestOldVersion { + # A subset of TestNewVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestOldVersion; +} + +struct TestNewVersion { + # A superset of TestOldVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestNewVersion; + new1 @3 :Int64 = 987; + new2 @4 :Text = "baz"; +} + +struct TestOldUnionVersion { + union { + a @0 :Void; + b @1 :UInt64; + } +} + +struct TestNewUnionVersion { + union { + a :union { + a0 @0 :Void; + a1 @2 :UInt64; + } + b @1 :UInt64; + } +} + +struct TestStructUnion { + un @0! :union { + struct @1 :SomeStruct; + object @2 :TestAnyPointer; + } + + struct SomeStruct { + someText @0 :Text; + moreText @1 :Text; + } +} + +struct TestPrintInlineStructs { + someText @0 :Text; + + structList @1 :List(InlineStruct); + struct InlineStruct { + int32Field @0 :Int32; + textField @1 :Text; + } +} + +struct TestWholeFloatDefault { + # At one point, these failed to compile in C++ because it would produce literals like "123f", + # which is not valid; it needs to be "123.0f". + field @0 :Float32 = 123; + bigField @1 :Float32 = 2e30; + const constant :Float32 = 456; + const bigConstant :Float32 = 4e30; +} + +struct TestGenerics(Foo, Bar) { + foo @0 :Foo; + rev @1 :TestGenerics(Bar, Foo); + + union { + uv @2:Void; + ug :group { + ugfoo @3:Int32; + } + } + + list @4 :List(Inner); + # At one time this failed to compile with MSVC due to poor expression SFINAE support. + + struct Inner { + foo @0 :Foo; + bar @1 :Bar; + } + + struct Inner2(Baz) { + bar @0 :Bar; + baz @1 :Baz; + innerBound @2 :Inner; + innerUnbound @3 :TestGenerics.Inner; + + struct DeepNest(Qux) { + foo @0 :Foo; + bar @1 :Bar; + baz @2 :Baz; + qux @3 :Qux; + + interface DeepNestInterface(Quux) { + # At one time this failed to compile. + call @0 () -> (); + } + } + } + + interface Interface(Qux) { + call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer)); + } + + annotation ann(struct) :Foo; + + using AliasFoo = Foo; + using AliasInner = Inner; + using AliasInner2 = Inner2; + using AliasInner2Text = Inner2(Text); + using AliasRev = TestGenerics(Bar, Foo); + + struct UseAliases { + foo @0 :AliasFoo; + inner @1 :AliasInner; + inner2 @2 :AliasInner2; + inner2Bind @3 :AliasInner2(Text); + inner2Text @4 :AliasInner2Text; + revFoo @5 :AliasRev.AliasFoo; + } +} + +struct TestGenericsWrapper(Foo, Bar) { + value @0 :TestGenerics(Foo, Bar); +} + +struct TestGenericsWrapper2 { + value @0 :TestGenericsWrapper(Text, TestAllTypes); +} + +interface TestImplicitMethodParams { + call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U); +} + +interface TestImplicitMethodParamsInGeneric(V) { + call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U); +} + +struct TestGenericsUnion(Foo, Bar) { + # At one point this failed to compile. + + union { + foo @0 :Foo; + bar @1 :Bar; + } +} + +struct TestUseGenerics $TestGenerics(Text, Data).ann("foo") { + basic @0 :TestGenerics(TestAllTypes, TestAnyPointer); + inner @1 :TestGenerics(TestAllTypes, TestAnyPointer).Inner; + inner2 @2 :TestGenerics(TestAllTypes, TestAnyPointer).Inner2(Text); + unspecified @3 :TestGenerics; + unspecifiedInner @4 :TestGenerics.Inner2(Text); + wrapper @8 :TestGenericsWrapper(TestAllTypes, TestAnyPointer); + cap @18 :TestGenerics(TestInterface, Text); + genericCap @19 :TestGenerics(TestAllTypes, List(UInt32)).Interface(Data); + + default @5 :TestGenerics(TestAllTypes, Text) = + (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321)))); + defaultInner @6 :TestGenerics(TestAllTypes, Text).Inner = + (foo = (int16Field = 123), bar = "text"); + defaultUser @7 :TestUseGenerics = (basic = (foo = (int16Field = 123))); + defaultWrapper @9 :TestGenericsWrapper(Text, TestAllTypes) = + (value = (foo = "text", rev = (foo = (int16Field = 321)))); + defaultWrapper2 @10 :TestGenericsWrapper2 = + (value = (value = (foo = "text", rev = (foo = (int16Field = 321))))); + + aliasFoo @11 :TestGenerics(TestAllTypes, TestAnyPointer).AliasFoo = (int16Field = 123); + aliasInner @12 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner + = (foo = (int16Field = 123)); + aliasInner2 @13 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2 + = (innerBound = (foo = (int16Field = 123))); + aliasInner2Bind @14 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2(List(UInt32)) + = (baz = [12, 34], innerBound = (foo = (int16Field = 123))); + aliasInner2Text @15 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2Text + = (baz = "text", innerBound = (foo = (int16Field = 123))); + aliasRev @16 :TestGenerics(TestAnyPointer, Text).AliasRev.AliasFoo = "text"; + + useAliases @17 :TestGenerics(TestAllTypes, List(UInt32)).UseAliases = ( + foo = (int16Field = 123), + inner = (foo = (int16Field = 123)), + inner2 = (innerBound = (foo = (int16Field = 123))), + inner2Bind = (baz = "text", innerBound = (foo = (int16Field = 123))), + inner2Text = (baz = "text", innerBound = (foo = (int16Field = 123))), + revFoo = [12, 34, 56]); +} + +struct TestEmptyStruct {} + +struct TestConstants { + const voidConst :Void = void; + const boolConst :Bool = true; + const int8Const :Int8 = -123; + const int16Const :Int16 = -12345; + const int32Const :Int32 = -12345678; + const int64Const :Int64 = -123456789012345; + const uint8Const :UInt8 = 234; + const uint16Const :UInt16 = 45678; + const uint32Const :UInt32 = 3456789012; + const uint64Const :UInt64 = 12345678901234567890; + const float32Const :Float32 = 1234.5; + const float64Const :Float64 = -123e45; + const textConst :Text = "foo"; + const dataConst :Data = "bar"; + const structConst :TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x " "structlist" + " 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + const enumConst :TestEnum = corge; + + const voidListConst :List(Void) = [void, void, void, void, void, void]; + const boolListConst :List(Bool) = [true, false, false, true]; + const int8ListConst :List(Int8) = [111, -111]; + const int16ListConst :List(Int16) = [11111, -11111]; + const int32ListConst :List(Int32) = [111111111, -111111111]; + const int64ListConst :List(Int64) = [1111111111111111111, -1111111111111111111]; + const uint8ListConst :List(UInt8) = [111, 222] ; + const uint16ListConst :List(UInt16) = [33333, 44444]; + const uint32ListConst :List(UInt32) = [3333333333]; + const uint64ListConst :List(UInt64) = [11111111111111111111]; + const float32ListConst :List(Float32) = [5555.5, inf, -inf, nan]; + const float64ListConst :List(Float64) = [7777.75, inf, -inf, nan]; + const textListConst :List(Text) = ["plugh", "xyzzy", "thud"]; + const dataListConst :List(Data) = ["oops", "exhausted", "rfc3092"]; + const structListConst :List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + const enumListConst :List(TestEnum) = [foo, garply]; +} + +const globalInt :UInt32 = 12345; +const globalText :Text = "foobar"; +const globalStruct :TestAllTypes = (int32Field = 54321); +const globalPrintableStruct :TestPrintInlineStructs = (someText = "foo"); +const derivedConstant :TestAllTypes = ( + uInt32Field = .globalInt, + textField = TestConstants.textConst, + structField = TestConstants.structConst, + int16List = TestConstants.int16ListConst, + structList = TestConstants.structListConst); + +const genericConstant :TestGenerics(TestAllTypes, Text) = + (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321)))); + +const embeddedData :Data = embed "testdata/packed"; +const embeddedText :Text = embed "testdata/short.txt"; +const embeddedStruct :TestAllTypes = embed "testdata/binary"; + +const nonAsciiText :Text = "♫ é ✓"; + +struct TestAnyPointerConstants { + anyKindAsStruct @0 :AnyPointer; + anyStructAsStruct @1 :AnyStruct; + anyKindAsList @2 :AnyPointer; + anyListAsList @3 :AnyList; + +} + +const anyPointerConstants :TestAnyPointerConstants = ( + anyKindAsStruct = TestConstants.structConst, + anyStructAsStruct = TestConstants.structConst, + anyKindAsList = TestConstants.int32ListConst, + anyListAsList = TestConstants.int32ListConst, +); + +interface TestInterface { + foo @0 (i :UInt32, j :Bool) -> (x :Text); + bar @1 () -> (); + baz @2 (s: TestAllTypes); +} + +interface TestExtends extends(TestInterface) { + qux @0 (); + corge @1 TestAllTypes -> (); + grault @2 () -> TestAllTypes; +} + +interface TestExtends2 extends(TestExtends) {} + +interface TestPipeline { + getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); + testPointers @1 (cap :TestInterface, obj :AnyPointer, list :List(TestInterface)) -> (); + getAnyCap @2 (n: UInt32, inCap :Capability) -> (s: Text, outBox :AnyBox); + + struct Box { + cap @0 :TestInterface; + } + struct AnyBox { + cap @0 :Capability; + } +} + +interface TestCallOrder { + getCallSequence @0 (expected: UInt32) -> (n: UInt32); + # First call returns 0, next returns 1, ... + # + # The input `expected` is ignored but useful for disambiguating debug logs. +} + +interface TestTailCallee { + struct TailResult { + i @0 :UInt32; + t @1 :Text; + c @2 :TestCallOrder; + } + + foo @0 (i :Int32, t :Text) -> TailResult; +} + +interface TestTailCaller { + foo @0 (i :Int32, callee :TestTailCallee) -> TestTailCallee.TailResult; +} + +interface TestHandle {} + +interface TestMoreStuff extends(TestCallOrder) { + # Catch-all type that contains lots of testing methods. + + callFoo @0 (cap :TestInterface) -> (s: Text); + # Call `cap.foo()`, check the result, and return "bar". + + callFooWhenResolved @1 (cap :TestInterface) -> (s: Text); + # Like callFoo but waits for `cap` to resolve first. + + neverReturn @2 (cap :TestInterface) -> (capCopy :TestInterface); + # Doesn't return. You should cancel it. + + hold @3 (cap :TestInterface) -> (); + # Returns immediately but holds on to the capability. + + callHeld @4 () -> (s: Text); + # Calls the capability previously held using `hold` (and keeps holding it). + + getHeld @5 () -> (cap :TestInterface); + # Returns the capability previously held using `hold` (and keeps holding it). + + echo @6 (cap :TestCallOrder) -> (cap :TestCallOrder); + # Just returns the input cap. + + expectCancel @7 (cap :TestInterface) -> (); + # evalLater()-loops forever, holding `cap`. Must be canceled. + + methodWithDefaults @8 (a :Text, b :UInt32 = 123, c :Text = "foo") -> (d :Text, e :Text = "bar"); + + methodWithNullDefault @12 (a :Text, b :TestInterface = null); + + getHandle @9 () -> (handle :TestHandle); + # Get a new handle. Tests have an out-of-band way to check the current number of live handles, so + # this can be used to test garbage collection. + + getNull @10 () -> (nullCap :TestMoreStuff); + # Always returns a null capability. + + getEnormousString @11 () -> (str :Text); + # Attempts to return an 100MB string. Should always fail. +} + +interface TestMembrane { + makeThing @0 () -> (thing :Thing); + callPassThrough @1 (thing :Thing, tailCall :Bool) -> Result; + callIntercept @2 (thing :Thing, tailCall :Bool) -> Result; + loopback @3 (thing :Thing) -> (thing :Thing); + + waitForever @4 (); + + interface Thing { + passThrough @0 () -> Result; + intercept @1 () -> Result; + } + + struct Result { + text @0 :Text; + } +} + +struct TestContainMembrane { + cap @0 :TestMembrane.Thing; + list @1 :List(TestMembrane.Thing); +} + +struct TestTransferCap { + list @0 :List(Element); + struct Element { + text @0 :Text; + cap @1 :TestInterface; + } +} + +interface TestKeywordMethods { + delete @0 (); + class @1 (); + void @2 (); + return @3 (); +} + +interface TestAuthenticatedBootstrap(VatId) { + getCallerId @0 () -> (caller :VatId); +} + +struct TestSturdyRef { + hostId @0 :TestSturdyRefHostId; + objectId @1 :AnyPointer; +} + +struct TestSturdyRefHostId { + host @0 :Text; +} + +struct TestSturdyRefObjectId { + tag @0 :Tag; + enum Tag { + testInterface @0; + testExtends @1; + testPipeline @2; + testTailCallee @3; + testTailCaller @4; + testMoreStuff @5; + } +} + +struct TestProvisionId {} +struct TestRecipientId {} +struct TestThirdPartyCapId {} +struct TestJoinResult {} + +struct TestNameAnnotation $Cxx.name("RenamedStruct") { + union { + badFieldName @0 :Bool $Cxx.name("goodFieldName"); + bar @1 :Int8; + } + + enum BadlyNamedEnum $Cxx.name("RenamedEnum") { + foo @0; + bar @1; + baz @2 $Cxx.name("qux"); + } + + anotherBadFieldName @2 :BadlyNamedEnum $Cxx.name("anotherGoodFieldName"); + + struct NestedStruct $Cxx.name("RenamedNestedStruct") { + badNestedFieldName @0 :Bool $Cxx.name("goodNestedFieldName"); + anotherBadNestedFieldName @1 :NestedStruct $Cxx.name("anotherGoodNestedFieldName"); + + enum DeeplyNestedEnum $Cxx.name("RenamedDeeplyNestedEnum") { + quux @0; + corge @1; + grault @2 $Cxx.name("garply"); + } + } + + badlyNamedUnion :union $Cxx.name("renamedUnion") { + badlyNamedGroup :group $Cxx.name("renamedGroup") { + foo @3 :Void; + bar @4 :Void; + } + baz @5 :NestedStruct $Cxx.name("qux"); + } +} + +interface TestNameAnnotationInterface $Cxx.name("RenamedInterface") { + badlyNamedMethod @0 (badlyNamedParam :UInt8 $Cxx.name("renamedParam")) $Cxx.name("renamedMethod"); +} diff --git a/CapnpCompatTest/test.capnp.c++ b/CapnpCompatTest/test.capnp.c++ new file mode 100644 index 0000000..6a0808e --- /dev/null +++ b/CapnpCompatTest/test.capnp.c++ @@ -0,0 +1,20614 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: test.capnp + +#include "test.capnp.h" + +namespace capnp { +namespace schemas { +static const ::capnp::_::AlignedData<49> b_9c8e9318b29d9cd3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 11, 0, 0, 0, 2, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 162, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 110, 117, 109, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 32, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 89, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 65, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 57, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, } +}; +::capnp::word const* const bp_9c8e9318b29d9cd3 = b_9c8e9318b29d9cd3.words; +#if !CAPNP_LITE +static const uint16_t m_9c8e9318b29d9cd3[] = {1, 2, 5, 0, 7, 6, 4, 3}; +const ::capnp::_::RawSchema s_9c8e9318b29d9cd3 = { + 0x9c8e9318b29d9cd3, b_9c8e9318b29d9cd3.words, 49, nullptr, m_9c8e9318b29d9cd3, + 0, 8, nullptr, nullptr, nullptr, { &s_9c8e9318b29d9cd3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(TestEnum_9c8e9318b29d9cd3, 9c8e9318b29d9cd3); +static const ::capnp::_::AlignedData<629> b_a0a8f314b80b63fd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 11, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 20, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 108, 108, 84, 121, 112, 101, 115, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 136, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 3, 0, 0, 3, 0, 1, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 3, 0, 0, 3, 0, 1, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 3, 0, 0, 3, 0, 1, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 3, 0, 0, 3, 0, 1, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 3, 0, 0, 3, 0, 1, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 3, 0, 0, 3, 0, 1, 0, + 220, 3, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 3, 0, 0, 3, 0, 1, 0, + 228, 3, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 3, 0, 0, 3, 0, 1, 0, + 236, 3, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 3, 0, 0, 3, 0, 1, 0, + 244, 3, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 3, 0, 0, 3, 0, 1, 0, + 252, 3, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 3, 0, 0, 3, 0, 1, 0, + 4, 4, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 4, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 3, 0, 1, 0, + 12, 4, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 4, 0, 0, 3, 0, 1, 0, + 20, 4, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 4, 0, 0, 3, 0, 1, 0, + 28, 4, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 4, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 4, 0, 0, 3, 0, 1, 0, + 36, 4, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 4, 0, 0, 3, 0, 1, 0, + 44, 4, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 4, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 4, 0, 0, 3, 0, 1, 0, + 52, 4, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 4, 0, 0, 3, 0, 1, 0, + 76, 4, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 4, 0, 0, 3, 0, 1, 0, + 100, 4, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 4, 0, 0, 3, 0, 1, 0, + 124, 4, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 4, 0, 0, 3, 0, 1, 0, + 148, 4, 0, 0, 2, 0, 1, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 4, 0, 0, 3, 0, 1, 0, + 172, 4, 0, 0, 2, 0, 1, 0, + 22, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 4, 0, 0, 3, 0, 1, 0, + 196, 4, 0, 0, 2, 0, 1, 0, + 23, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 4, 0, 0, 3, 0, 1, 0, + 220, 4, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 4, 0, 0, 3, 0, 1, 0, + 244, 4, 0, 0, 2, 0, 1, 0, + 25, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 4, 0, 0, 3, 0, 1, 0, + 12, 5, 0, 0, 2, 0, 1, 0, + 26, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 5, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 5, 0, 0, 3, 0, 1, 0, + 36, 5, 0, 0, 2, 0, 1, 0, + 27, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 5, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 5, 0, 0, 3, 0, 1, 0, + 60, 5, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 57, 5, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 5, 0, 0, 3, 0, 1, 0, + 84, 5, 0, 0, 2, 0, 1, 0, + 29, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 5, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 5, 0, 0, 3, 0, 1, 0, + 108, 5, 0, 0, 2, 0, 1, 0, + 30, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 5, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 5, 0, 0, 3, 0, 1, 0, + 132, 5, 0, 0, 2, 0, 1, 0, + 31, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 5, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 5, 0, 0, 3, 0, 1, 0, + 156, 5, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 5, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 5, 0, 0, 3, 0, 1, 0, + 180, 5, 0, 0, 2, 0, 1, 0, + 33, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 5, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 5, 0, 0, 3, 0, 1, 0, + 204, 5, 0, 0, 2, 0, 1, 0, + 118, 111, 105, 100, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 70, 105, 101, 108, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a0a8f314b80b63fd = b_a0a8f314b80b63fd.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a0a8f314b80b63fd[] = { + &s_9c8e9318b29d9cd3, + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_a0a8f314b80b63fd[] = {1, 18, 13, 30, 15, 32, 10, 27, 11, 28, 3, 20, 4, 21, 5, 22, 2, 19, 16, 33, 14, 31, 12, 29, 7, 24, 8, 25, 9, 26, 6, 23, 0, 17}; +static const uint16_t i_a0a8f314b80b63fd[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}; +const ::capnp::_::RawSchema s_a0a8f314b80b63fd = { + 0xa0a8f314b80b63fd, b_a0a8f314b80b63fd.words, 629, d_a0a8f314b80b63fd, m_a0a8f314b80b63fd, + 2, 34, i_a0a8f314b80b63fd, nullptr, nullptr, { &s_a0a8f314b80b63fd, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<953> b_eb3f9ebe98c73cb6 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 182, 60, 199, 152, 190, 158, 63, 235, + 11, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 20, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 68, + 101, 102, 97, 117, 108, 116, 115, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 136, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 169, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 3, 0, 0, 3, 0, 1, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 177, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 3, 0, 0, 3, 0, 1, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 185, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 3, 0, 0, 3, 0, 1, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 193, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 3, 0, 0, 3, 0, 1, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 201, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 3, 0, 0, 3, 0, 1, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 209, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 3, 0, 0, 3, 0, 1, 0, + 220, 3, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 217, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 3, 0, 0, 3, 0, 1, 0, + 228, 3, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 225, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 3, 0, 0, 3, 0, 1, 0, + 236, 3, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 233, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 3, 0, 0, 3, 0, 1, 0, + 244, 3, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 241, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 3, 0, 0, 3, 0, 1, 0, + 252, 3, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 249, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 3, 0, 0, 3, 0, 1, 0, + 4, 4, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 4, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 3, 0, 1, 0, + 12, 4, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 9, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 4, 0, 0, 3, 0, 1, 0, + 20, 4, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 20, 4, 0, 0, 3, 0, 1, 0, + 32, 4, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 33, 4, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 4, 0, 0, 3, 0, 1, 0, + 44, 4, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 101, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 7, 0, 0, 3, 0, 1, 0, + 112, 7, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 7, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 7, 0, 0, 3, 0, 1, 0, + 120, 7, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 117, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 7, 0, 0, 3, 0, 1, 0, + 144, 7, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 141, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 7, 0, 0, 3, 0, 1, 0, + 168, 7, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 169, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 7, 0, 0, 3, 0, 1, 0, + 196, 7, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 197, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 196, 7, 0, 0, 3, 0, 1, 0, + 224, 7, 0, 0, 2, 0, 1, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 225, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 7, 0, 0, 3, 0, 1, 0, + 252, 7, 0, 0, 2, 0, 1, 0, + 22, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 253, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 7, 0, 0, 3, 0, 1, 0, + 24, 8, 0, 0, 2, 0, 1, 0, + 23, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 29, 8, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 8, 0, 0, 3, 0, 1, 0, + 56, 8, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 57, 8, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 8, 0, 0, 3, 0, 1, 0, + 84, 8, 0, 0, 2, 0, 1, 0, + 25, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 85, 8, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 8, 0, 0, 3, 0, 1, 0, + 112, 8, 0, 0, 2, 0, 1, 0, + 26, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 113, 8, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 8, 0, 0, 3, 0, 1, 0, + 140, 8, 0, 0, 2, 0, 1, 0, + 27, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 141, 8, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 8, 0, 0, 3, 0, 1, 0, + 168, 8, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 173, 8, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 172, 8, 0, 0, 3, 0, 1, 0, + 200, 8, 0, 0, 2, 0, 1, 0, + 29, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 213, 8, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 212, 8, 0, 0, 3, 0, 1, 0, + 240, 8, 0, 0, 2, 0, 1, 0, + 30, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 5, 9, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 9, 0, 0, 3, 0, 1, 0, + 32, 9, 0, 0, 2, 0, 1, 0, + 31, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 57, 9, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 9, 0, 0, 3, 0, 1, 0, + 84, 9, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 165, 10, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 164, 10, 0, 0, 3, 0, 1, 0, + 192, 10, 0, 0, 2, 0, 1, 0, + 33, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 10, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 10, 0, 0, 3, 0, 1, 0, + 220, 10, 0, 0, 2, 0, 1, 0, + 118, 111, 105, 100, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 133, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 199, 207, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 178, 158, 67, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 135, 32, 242, 121, 183, 143, 255, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 234, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 110, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 20, 106, 10, 206, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 210, 10, 31, 235, 140, 169, 84, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 80, 154, 68, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 187, 224, 192, 130, 139, 181, 201, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 70, 105, 101, 108, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 48, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 33, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 145, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 20, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 21, 0, 0, 0, + 199, 113, 196, 43, 171, 117, 107, 15, + 57, 142, 59, 212, 84, 138, 148, 240, + 117, 73, 110, 116, 56, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 222, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 53, 130, 156, 173, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 85, 161, 174, 198, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 199, 113, 172, 181, 175, 152, 50, 154, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 36, 0, 0, 0, + 0, 156, 173, 69, 0, 0, 128, 127, + 0, 0, 128, 255, 0, 0, 192, 127, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 192, 97, 190, 64, + 0, 0, 0, 0, 0, 0, 240, 127, + 0, 0, 0, 0, 0, 0, 240, 255, + 0, 0, 0, 0, 0, 0, 248, 127, + 116, 101, 120, 116, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 116, 104, 117, 100, 0, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 9, 0, 0, 0, 74, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 111, 111, 112, 115, 0, 0, 0, 0, + 101, 120, 104, 97, 117, 115, 116, 101, + 100, 0, 0, 0, 0, 0, 0, 0, + 114, 102, 99, 51, 48, 57, 50, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 119, 2, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_eb3f9ebe98c73cb6 = b_eb3f9ebe98c73cb6.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_eb3f9ebe98c73cb6[] = { + &s_9c8e9318b29d9cd3, + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_eb3f9ebe98c73cb6[] = {1, 18, 13, 30, 15, 32, 10, 27, 11, 28, 3, 20, 4, 21, 5, 22, 2, 19, 16, 33, 14, 31, 12, 29, 7, 24, 8, 25, 9, 26, 6, 23, 0, 17}; +static const uint16_t i_eb3f9ebe98c73cb6[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}; +const ::capnp::_::RawSchema s_eb3f9ebe98c73cb6 = { + 0xeb3f9ebe98c73cb6, b_eb3f9ebe98c73cb6.words, 953, d_eb3f9ebe98c73cb6, m_eb3f9ebe98c73cb6, + 2, 34, i_eb3f9ebe98c73cb6, nullptr, nullptr, { &s_eb3f9ebe98c73cb6, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_e3da5a2ccd28c0d8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 110, 121, 80, 111, 105, 110, 116, 101, + 114, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 1, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 97, 110, 121, 80, 111, 105, 110, 116, + 101, 114, 70, 105, 101, 108, 100, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e3da5a2ccd28c0d8 = b_e3da5a2ccd28c0d8.words; +#if !CAPNP_LITE +static const uint16_t m_e3da5a2ccd28c0d8[] = {0}; +static const uint16_t i_e3da5a2ccd28c0d8[] = {0}; +const ::capnp::_::RawSchema s_e3da5a2ccd28c0d8 = { + 0xe3da5a2ccd28c0d8, b_e3da5a2ccd28c0d8.words, 34, nullptr, m_e3da5a2ccd28c0d8, + 0, 1, i_e3da5a2ccd28c0d8, nullptr, nullptr, { &s_e3da5a2ccd28c0d8, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<66> b_f49850f63c2bfa59 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 89, 250, 43, 60, 246, 80, 152, 244, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 110, 121, 79, 116, 104, 101, 114, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 3, 0, 1, 0, + 88, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 0, 0, 0, 3, 0, 1, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 97, 110, 121, 83, 116, 114, 117, 99, + 116, 70, 105, 101, 108, 100, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 121, 76, 105, 115, 116, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 97, 98, 105, 108, 105, + 116, 121, 70, 105, 101, 108, 100, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f49850f63c2bfa59 = b_f49850f63c2bfa59.words; +#if !CAPNP_LITE +static const uint16_t m_f49850f63c2bfa59[] = {1, 0, 2}; +static const uint16_t i_f49850f63c2bfa59[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_f49850f63c2bfa59 = { + 0xf49850f63c2bfa59, b_f49850f63c2bfa59.words, 66, nullptr, m_f49850f63c2bfa59, + 0, 3, i_f49850f63c2bfa59, nullptr, nullptr, { &s_f49850f63c2bfa59, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<153> b_a9d5f8efe770022b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 43, 2, 112, 231, 239, 248, 213, 169, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 9, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 255, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 79, + 117, 116, 79, 102, 79, 114, 100, 101, + 114, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 36, 0, 0, 0, 3, 0, 4, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 3, 0, 1, 0, + 244, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 0, 0, 0, 3, 0, 1, 0, + 248, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 245, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 0, 0, 0, 3, 0, 1, 0, + 252, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 244, 0, 0, 0, 3, 0, 1, 0, + 0, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 0, 0, 0, 3, 0, 1, 0, + 4, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 0, 0, 0, 3, 0, 1, 0, + 8, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 1, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 3, 0, 1, 0, + 12, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 1, 0, 0, 3, 0, 1, 0, + 16, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 1, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 1, 0, 0, 3, 0, 1, 0, + 20, 1, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a9d5f8efe770022b = b_a9d5f8efe770022b.words; +#if !CAPNP_LITE +static const uint16_t m_a9d5f8efe770022b[] = {2, 8, 4, 3, 7, 1, 6, 0, 5}; +static const uint16_t i_a9d5f8efe770022b[] = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +const ::capnp::_::RawSchema s_a9d5f8efe770022b = { + 0xa9d5f8efe770022b, b_a9d5f8efe770022b.words, 153, nullptr, m_a9d5f8efe770022b, + 0, 9, i_a9d5f8efe770022b, nullptr, nullptr, { &s_a9d5f8efe770022b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<169> b_f47697362233ce52 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 11, 0, 0, 0, 1, 0, 8, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 167, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 48, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 24, 167, 183, 236, 46, 168, 118, 252, + 65, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 1, 0, 0, 0, + 178, 122, 220, 183, 153, 107, 10, 238, + 41, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 2, 0, 0, 0, + 212, 102, 13, 159, 65, 253, 197, 175, + 17, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 3, 0, 0, 0, + 83, 0, 243, 199, 46, 2, 251, 162, + 249, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 128, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 3, 0, 1, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 1, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 1, 0, + 236, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 131, 0, 0, 0, + 0, 0, 1, 0, 40, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 0, 0, 0, 3, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 132, 0, 0, 0, + 0, 0, 1, 0, 41, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 3, 0, 1, 0, + 244, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 133, 0, 0, 0, + 0, 0, 1, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 0, 0, 0, 3, 0, 1, 0, + 248, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 134, 0, 0, 0, + 0, 0, 1, 0, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 245, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 240, 0, 0, 0, 3, 0, 1, 0, + 252, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 135, 0, 0, 0, + 0, 0, 1, 0, 44, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 244, 0, 0, 0, 3, 0, 1, 0, + 0, 1, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 35, 0, 0, 0, + 0, 0, 1, 0, 49, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 0, 0, 0, 3, 0, 1, 0, + 4, 1, 0, 0, 2, 0, 1, 0, + 117, 110, 105, 111, 110, 48, 0, 0, + 117, 110, 105, 111, 110, 49, 0, 0, + 117, 110, 105, 111, 110, 50, 0, 0, + 117, 110, 105, 111, 110, 51, 0, 0, + 98, 105, 116, 48, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 50, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 51, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 52, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 53, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 54, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 55, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 121, 116, 101, 48, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f47697362233ce52 = b_f47697362233ce52.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_f47697362233ce52[] = { + &s_a2fb022ec7f30053, + &s_afc5fd419f0d66d4, + &s_ee0a6b99b7dc7ab2, + &s_fc76a82eecb7a718, +}; +static const uint16_t m_f47697362233ce52[] = {4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3}; +static const uint16_t i_f47697362233ce52[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; +const ::capnp::_::RawSchema s_f47697362233ce52 = { + 0xf47697362233ce52, b_f47697362233ce52.words, 169, d_f47697362233ce52, m_f47697362233ce52, + 4, 12, i_f47697362233ce52, nullptr, nullptr, { &s_f47697362233ce52, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<227> b_fc76a82eecb7a718 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 24, 167, 183, 236, 46, 168, 118, 252, + 21, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 14, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 23, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 46, 117, 110, 105, + 111, 110, 48, 0, 0, 0, 0, 0, + 56, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 3, 0, 1, 0, + 128, 1, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 64, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 1, 0, 0, 3, 0, 1, 0, + 132, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 8, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 1, 0, 0, 3, 0, 1, 0, + 136, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 252, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 1, 0, 0, 3, 0, 1, 0, + 140, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 251, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 137, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 1, 0, 0, 3, 0, 1, 0, + 144, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 250, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 1, 0, 0, 3, 0, 1, 0, + 148, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 249, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 1, 0, 0, 3, 0, 1, 0, + 152, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 248, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 1, 0, 0, 3, 0, 1, 0, + 156, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 247, 255, 64, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 1, 0, 0, 3, 0, 1, 0, + 160, 1, 0, 0, 2, 0, 1, 0, + 9, 0, 246, 255, 8, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 1, 0, 0, 3, 0, 1, 0, + 164, 1, 0, 0, 2, 0, 1, 0, + 10, 0, 245, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 161, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 156, 1, 0, 0, 3, 0, 1, 0, + 168, 1, 0, 0, 2, 0, 1, 0, + 11, 0, 244, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 165, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 160, 1, 0, 0, 3, 0, 1, 0, + 172, 1, 0, 0, 2, 0, 1, 0, + 12, 0, 243, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 164, 1, 0, 0, 3, 0, 1, 0, + 176, 1, 0, 0, 2, 0, 1, 0, + 13, 0, 242, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 173, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 1, 0, 0, 3, 0, 1, 0, + 180, 1, 0, 0, 2, 0, 1, 0, + 117, 48, 102, 48, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fc76a82eecb7a718 = b_fc76a82eecb7a718.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_fc76a82eecb7a718[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_fc76a82eecb7a718[] = {0, 1, 3, 4, 5, 2, 6, 7, 8, 10, 11, 12, 9, 13}; +static const uint16_t i_fc76a82eecb7a718[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; +const ::capnp::_::RawSchema s_fc76a82eecb7a718 = { + 0xfc76a82eecb7a718, b_fc76a82eecb7a718.words, 227, d_fc76a82eecb7a718, m_fc76a82eecb7a718, + 1, 14, i_fc76a82eecb7a718, nullptr, nullptr, { &s_fc76a82eecb7a718, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<317> b_ee0a6b99b7dc7ab2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 178, 122, 220, 183, 153, 107, 10, 238, + 21, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 20, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 103, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 46, 117, 110, 105, + 111, 110, 49, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 3, 0, 1, 0, + 40, 2, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 2, 0, 0, 3, 0, 1, 0, + 44, 2, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 2, 0, 0, 3, 0, 1, 0, + 48, 2, 0, 0, 2, 0, 1, 0, + 3, 0, 252, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 2, 0, 0, 3, 0, 1, 0, + 52, 2, 0, 0, 2, 0, 1, 0, + 4, 0, 251, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 2, 0, 0, 3, 0, 1, 0, + 56, 2, 0, 0, 2, 0, 1, 0, + 5, 0, 250, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 2, 0, 0, 3, 0, 1, 0, + 60, 2, 0, 0, 2, 0, 1, 0, + 6, 0, 249, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 57, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 52, 2, 0, 0, 3, 0, 1, 0, + 64, 2, 0, 0, 2, 0, 1, 0, + 7, 0, 248, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 2, 0, 0, 3, 0, 1, 0, + 68, 2, 0, 0, 2, 0, 1, 0, + 8, 0, 247, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 65, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 60, 2, 0, 0, 3, 0, 1, 0, + 72, 2, 0, 0, 2, 0, 1, 0, + 9, 0, 246, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 2, 0, 0, 3, 0, 1, 0, + 76, 2, 0, 0, 2, 0, 1, 0, + 10, 0, 245, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 2, 0, 0, 3, 0, 1, 0, + 80, 2, 0, 0, 2, 0, 1, 0, + 11, 0, 244, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 2, 0, 0, 3, 0, 1, 0, + 84, 2, 0, 0, 2, 0, 1, 0, + 12, 0, 243, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 2, 0, 0, 3, 0, 1, 0, + 88, 2, 0, 0, 2, 0, 1, 0, + 13, 0, 242, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 2, 0, 0, 3, 0, 1, 0, + 92, 2, 0, 0, 2, 0, 1, 0, + 14, 0, 241, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 89, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 2, 0, 0, 3, 0, 1, 0, + 96, 2, 0, 0, 2, 0, 1, 0, + 15, 0, 240, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 88, 2, 0, 0, 3, 0, 1, 0, + 100, 2, 0, 0, 2, 0, 1, 0, + 16, 0, 239, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 35, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 2, 0, 0, 3, 0, 1, 0, + 104, 2, 0, 0, 2, 0, 1, 0, + 17, 0, 238, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 36, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 2, 0, 0, 3, 0, 1, 0, + 108, 2, 0, 0, 2, 0, 1, 0, + 18, 0, 237, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 2, 0, 0, 3, 0, 1, 0, + 112, 2, 0, 0, 2, 0, 1, 0, + 19, 0, 236, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 38, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 2, 0, 0, 3, 0, 1, 0, + 116, 2, 0, 0, 2, 0, 1, 0, + 117, 49, 102, 48, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ee0a6b99b7dc7ab2 = b_ee0a6b99b7dc7ab2.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ee0a6b99b7dc7ab2[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_ee0a6b99b7dc7ab2[] = {0, 1, 5, 7, 9, 3, 11, 2, 6, 8, 10, 4, 12, 13, 14, 16, 17, 18, 15, 19}; +static const uint16_t i_ee0a6b99b7dc7ab2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}; +const ::capnp::_::RawSchema s_ee0a6b99b7dc7ab2 = { + 0xee0a6b99b7dc7ab2, b_ee0a6b99b7dc7ab2.words, 317, d_ee0a6b99b7dc7ab2, m_ee0a6b99b7dc7ab2, + 1, 20, i_ee0a6b99b7dc7ab2, nullptr, nullptr, { &s_ee0a6b99b7dc7ab2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<92> b_afc5fd419f0d66d4 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 212, 102, 13, 159, 65, 253, 197, 175, + 21, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 5, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 46, 117, 110, 105, + 111, 110, 50, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 4, 0, 255, 255, 0, 1, 0, 0, + 0, 0, 1, 0, 45, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 33, 0, 0, 0, + 0, 0, 1, 0, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 18, 0, 0, 0, + 0, 0, 1, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 252, 255, 10, 0, 0, 0, + 0, 0, 1, 0, 52, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 137, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 251, 255, 6, 0, 0, 0, + 0, 0, 1, 0, 54, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 117, 50, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_afc5fd419f0d66d4 = b_afc5fd419f0d66d4.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_afc5fd419f0d66d4[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_afc5fd419f0d66d4[] = {0, 2, 3, 4, 1}; +static const uint16_t i_afc5fd419f0d66d4[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_afc5fd419f0d66d4 = { + 0xafc5fd419f0d66d4, b_afc5fd419f0d66d4.words, 92, d_afc5fd419f0d66d4, m_afc5fd419f0d66d4, + 1, 5, i_afc5fd419f0d66d4, nullptr, nullptr, { &s_afc5fd419f0d66d4, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<92> b_a2fb022ec7f30053 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 83, 0, 243, 199, 46, 2, 251, 162, + 21, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 5, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 46, 117, 110, 105, + 111, 110, 51, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 4, 0, 255, 255, 1, 1, 0, 0, + 0, 0, 1, 0, 46, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 34, 0, 0, 0, + 0, 0, 1, 0, 48, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 19, 0, 0, 0, + 0, 0, 1, 0, 51, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 252, 255, 11, 0, 0, 0, + 0, 0, 1, 0, 53, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 137, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 251, 255, 7, 0, 0, 0, + 0, 0, 1, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 117, 51, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a2fb022ec7f30053 = b_a2fb022ec7f30053.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a2fb022ec7f30053[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_a2fb022ec7f30053[] = {0, 2, 3, 4, 1}; +static const uint16_t i_a2fb022ec7f30053[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_a2fb022ec7f30053 = { + 0xa2fb022ec7f30053, b_a2fb022ec7f30053.words, 92, d_a2fb022ec7f30053, m_a2fb022ec7f30053, + 1, 5, i_a2fb022ec7f30053, nullptr, nullptr, { &s_a2fb022ec7f30053, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<93> b_9e2e784c915329b6 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 11, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 2, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 110, 97, 109, 101, 100, 85, 110, + 105, 111, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 254, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 137, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 98, 101, 102, 111, 114, 101, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 105, 100, 100, 108, 101, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 102, 116, 101, 114, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9e2e784c915329b6 = b_9e2e784c915329b6.words; +#if !CAPNP_LITE +static const uint16_t m_9e2e784c915329b6[] = {4, 3, 0, 1, 2}; +static const uint16_t i_9e2e784c915329b6[] = {1, 3, 0, 2, 4}; +const ::capnp::_::RawSchema s_9e2e784c915329b6 = { + 0x9e2e784c915329b6, b_9e2e784c915329b6.words, 93, nullptr, m_9e2e784c915329b6, + 0, 5, i_9e2e784c915329b6, nullptr, nullptr, { &s_9e2e784c915329b6, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<26> b_89a9494f1b900f22 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 34, 15, 144, 27, 79, 73, 169, 137, + 11, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 73, 110, 85, 110, + 105, 111, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 0, 0, 0, } +}; +::capnp::word const* const bp_89a9494f1b900f22 = b_89a9494f1b900f22.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_89a9494f1b900f22[] = { + &s_d005f6c63707670c, +}; +static const uint16_t m_89a9494f1b900f22[] = {0}; +static const uint16_t i_89a9494f1b900f22[] = {0}; +const ::capnp::_::RawSchema s_89a9494f1b900f22 = { + 0x89a9494f1b900f22, b_89a9494f1b900f22.words, 26, d_89a9494f1b900f22, m_89a9494f1b900f22, + 1, 1, i_89a9494f1b900f22, nullptr, nullptr, { &s_89a9494f1b900f22, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<41> b_d005f6c63707670c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 28, 0, 0, 0, 1, 0, 2, 0, + 34, 15, 144, 27, 79, 73, 169, 137, + 0, 0, 7, 0, 1, 0, 2, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 73, 110, 85, 110, + 105, 111, 110, 46, 111, 117, 116, 101, + 114, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 219, 229, 248, 198, 17, 225, 156, 255, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 1, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 105, 110, 110, 101, 114, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d005f6c63707670c = b_d005f6c63707670c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d005f6c63707670c[] = { + &s_89a9494f1b900f22, + &s_ff9ce111c6f8e5db, +}; +static const uint16_t m_d005f6c63707670c[] = {1, 0}; +static const uint16_t i_d005f6c63707670c[] = {0, 1}; +const ::capnp::_::RawSchema s_d005f6c63707670c = { + 0xd005f6c63707670c, b_d005f6c63707670c.words, 41, d_d005f6c63707670c, m_d005f6c63707670c, + 2, 2, i_d005f6c63707670c, nullptr, nullptr, { &s_d005f6c63707670c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_ff9ce111c6f8e5db = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 219, 229, 248, 198, 17, 225, 156, 255, + 34, 0, 0, 0, 1, 0, 2, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 0, 0, 7, 0, 1, 0, 2, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 73, 110, 85, 110, + 105, 111, 110, 46, 111, 117, 116, 101, + 114, 46, 105, 110, 110, 101, 114, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ff9ce111c6f8e5db = b_ff9ce111c6f8e5db.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ff9ce111c6f8e5db[] = { + &s_d005f6c63707670c, +}; +static const uint16_t m_ff9ce111c6f8e5db[] = {1, 0}; +static const uint16_t i_ff9ce111c6f8e5db[] = {0, 1}; +const ::capnp::_::RawSchema s_ff9ce111c6f8e5db = { + 0xff9ce111c6f8e5db, b_ff9ce111c6f8e5db.words, 48, d_ff9ce111c6f8e5db, m_ff9ce111c6f8e5db, + 1, 2, i_ff9ce111c6f8e5db, nullptr, nullptr, { &s_ff9ce111c6f8e5db, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_dc841556134c3103 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 3, 49, 76, 19, 86, 21, 132, 220, + 11, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 114, 111, 117, 112, 115, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 111, 117, 112, 115, 0, 0, } +}; +::capnp::word const* const bp_dc841556134c3103 = b_dc841556134c3103.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_dc841556134c3103[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_dc841556134c3103[] = {0}; +static const uint16_t i_dc841556134c3103[] = {0}; +const ::capnp::_::RawSchema s_dc841556134c3103 = { + 0xdc841556134c3103, b_dc841556134c3103.words, 25, d_dc841556134c3103, m_dc841556134c3103, + 1, 1, i_dc841556134c3103, nullptr, nullptr, { &s_dc841556134c3103, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<41> b_e22ae74ff9113268 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 22, 0, 0, 0, 1, 0, 2, 0, + 3, 49, 76, 19, 86, 21, 132, 220, + 2, 0, 7, 0, 1, 0, 3, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 114, 111, 117, 112, 115, 46, 103, 114, + 111, 117, 112, 115, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 111, 25, 193, 192, 137, 186, 252, 245, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 179, 164, 102, 64, 48, 48, 250, 240, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 253, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 26, 9, 208, 192, 39, 183, + 21, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e22ae74ff9113268 = b_e22ae74ff9113268.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e22ae74ff9113268[] = { + &s_b727c0d0091a001d, + &s_dc841556134c3103, + &s_f0fa30304066a4b3, + &s_f5fcba89c0c1196f, +}; +static const uint16_t m_e22ae74ff9113268[] = {2, 1, 0}; +static const uint16_t i_e22ae74ff9113268[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_e22ae74ff9113268 = { + 0xe22ae74ff9113268, b_e22ae74ff9113268.words, 41, d_e22ae74ff9113268, m_e22ae74ff9113268, + 4, 3, i_e22ae74ff9113268, nullptr, nullptr, { &s_e22ae74ff9113268, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<63> b_f5fcba89c0c1196f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 111, 25, 193, 192, 137, 186, 252, 245, + 29, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 114, 111, 117, 112, 115, 46, 103, 114, + 111, 117, 112, 115, 46, 102, 111, 111, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f5fcba89c0c1196f = b_f5fcba89c0c1196f.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_f5fcba89c0c1196f[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_f5fcba89c0c1196f[] = {0, 2, 1}; +static const uint16_t i_f5fcba89c0c1196f[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_f5fcba89c0c1196f = { + 0xf5fcba89c0c1196f, b_f5fcba89c0c1196f.words, 63, d_f5fcba89c0c1196f, m_f5fcba89c0c1196f, + 1, 3, i_f5fcba89c0c1196f, nullptr, nullptr, { &s_f5fcba89c0c1196f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<63> b_f0fa30304066a4b3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 179, 164, 102, 64, 48, 48, 250, 240, + 29, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 114, 111, 117, 112, 115, 46, 103, 114, + 111, 117, 112, 115, 46, 98, 97, 122, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f0fa30304066a4b3 = b_f0fa30304066a4b3.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_f0fa30304066a4b3[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_f0fa30304066a4b3[] = {0, 2, 1}; +static const uint16_t i_f0fa30304066a4b3[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_f0fa30304066a4b3 = { + 0xf0fa30304066a4b3, b_f0fa30304066a4b3.words, 63, d_f0fa30304066a4b3, m_f0fa30304066a4b3, + 1, 3, i_f0fa30304066a4b3, nullptr, nullptr, { &s_f0fa30304066a4b3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<63> b_b727c0d0091a001d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 29, 0, 26, 9, 208, 192, 39, 183, + 29, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 114, 111, 117, 112, 115, 46, 103, 114, + 111, 117, 112, 115, 46, 98, 97, 114, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b727c0d0091a001d = b_b727c0d0091a001d.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_b727c0d0091a001d[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_b727c0d0091a001d[] = {0, 2, 1}; +static const uint16_t i_b727c0d0091a001d[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_b727c0d0091a001d = { + 0xb727c0d0091a001d, b_b727c0d0091a001d.words, 63, d_b727c0d0091a001d, m_b727c0d0091a001d, + 1, 3, i_b727c0d0091a001d, nullptr, nullptr, { &s_b727c0d0091a001d, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_f77ed6f7454eec40 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 11, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 6, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 108, 101, 97, 118, + 101, 100, 71, 114, 111, 117, 112, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 17, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 111, 117, 112, 49, 0, 0, + 103, 114, 111, 117, 112, 50, 0, 0, } +}; +::capnp::word const* const bp_f77ed6f7454eec40 = b_f77ed6f7454eec40.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_f77ed6f7454eec40[] = { + &s_c7485a3516c7d3c8, + &s_cc85a335569990e9, +}; +static const uint16_t m_f77ed6f7454eec40[] = {0, 1}; +static const uint16_t i_f77ed6f7454eec40[] = {0, 1}; +const ::capnp::_::RawSchema s_f77ed6f7454eec40 = { + 0xf77ed6f7454eec40, b_f77ed6f7454eec40.words, 35, d_f77ed6f7454eec40, m_f77ed6f7454eec40, + 2, 2, i_f77ed6f7454eec40, nullptr, nullptr, { &s_f77ed6f7454eec40, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<101> b_c7485a3516c7d3c8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 33, 0, 0, 0, 1, 0, 6, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 6, 0, 7, 0, 1, 0, 3, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 87, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 108, 101, 97, 118, + 101, 100, 71, 114, 111, 117, 112, 115, + 46, 103, 114, 111, 117, 112, 49, 0, + 24, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 1, 0, + 164, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 255, 255, 12, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 161, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 156, 0, 0, 0, 3, 0, 1, 0, + 168, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 58, 49, 74, 63, 65, 253, 10, 219, + 165, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 253, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 3, 0, 1, 0, + 152, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c7485a3516c7d3c8 = b_c7485a3516c7d3c8.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c7485a3516c7d3c8[] = { + &s_db0afd413f4a313a, + &s_f77ed6f7454eec40, +}; +static const uint16_t m_c7485a3516c7d3c8[] = {1, 3, 0, 5, 2, 4}; +static const uint16_t i_c7485a3516c7d3c8[] = {2, 3, 5, 0, 1, 4}; +const ::capnp::_::RawSchema s_c7485a3516c7d3c8 = { + 0xc7485a3516c7d3c8, b_c7485a3516c7d3c8.words, 101, d_c7485a3516c7d3c8, m_c7485a3516c7d3c8, + 2, 6, i_c7485a3516c7d3c8, nullptr, nullptr, { &s_c7485a3516c7d3c8, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<79> b_db0afd413f4a313a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 58, 49, 74, 63, 65, 253, 10, 219, + 40, 0, 0, 0, 1, 0, 6, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 6, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 108, 101, 97, 118, + 101, 100, 71, 114, 111, 117, 112, 115, + 46, 103, 114, 111, 117, 112, 49, 46, + 99, 111, 114, 103, 101, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 0, 0, 0, 3, 0, 1, 0, + 112, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 0, 0, 0, 3, 0, 1, 0, + 116, 0, 0, 0, 2, 0, 1, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_db0afd413f4a313a = b_db0afd413f4a313a.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_db0afd413f4a313a[] = { + &s_c7485a3516c7d3c8, +}; +static const uint16_t m_db0afd413f4a313a[] = {1, 0, 2, 3}; +static const uint16_t i_db0afd413f4a313a[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_db0afd413f4a313a = { + 0xdb0afd413f4a313a, b_db0afd413f4a313a.words, 79, d_db0afd413f4a313a, m_db0afd413f4a313a, + 1, 4, i_db0afd413f4a313a, nullptr, nullptr, { &s_db0afd413f4a313a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<101> b_cc85a335569990e9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 33, 0, 0, 0, 1, 0, 6, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 6, 0, 7, 0, 1, 0, 3, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 87, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 108, 101, 97, 118, + 101, 100, 71, 114, 111, 117, 112, 115, + 46, 103, 114, 111, 117, 112, 50, 0, + 24, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 1, 0, + 164, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 255, 255, 13, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 161, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 156, 0, 0, 0, 3, 0, 1, 0, + 168, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 55, 238, 39, 104, 54, 240, 23, 160, + 165, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 253, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 3, 0, 1, 0, + 152, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_cc85a335569990e9 = b_cc85a335569990e9.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_cc85a335569990e9[] = { + &s_a017f0366827ee37, + &s_f77ed6f7454eec40, +}; +static const uint16_t m_cc85a335569990e9[] = {1, 3, 0, 5, 2, 4}; +static const uint16_t i_cc85a335569990e9[] = {2, 3, 5, 0, 1, 4}; +const ::capnp::_::RawSchema s_cc85a335569990e9 = { + 0xcc85a335569990e9, b_cc85a335569990e9.words, 101, d_cc85a335569990e9, m_cc85a335569990e9, + 2, 6, i_cc85a335569990e9, nullptr, nullptr, { &s_cc85a335569990e9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<79> b_a017f0366827ee37 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 55, 238, 39, 104, 54, 240, 23, 160, + 40, 0, 0, 0, 1, 0, 6, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 6, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 108, 101, 97, 118, + 101, 100, 71, 114, 111, 117, 112, 115, + 46, 103, 114, 111, 117, 112, 50, 46, + 99, 111, 114, 103, 101, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 0, 0, 0, 3, 0, 1, 0, + 112, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 0, 0, 0, 3, 0, 1, 0, + 116, 0, 0, 0, 2, 0, 1, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a017f0366827ee37 = b_a017f0366827ee37.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a017f0366827ee37[] = { + &s_cc85a335569990e9, +}; +static const uint16_t m_a017f0366827ee37[] = {1, 0, 2, 3}; +static const uint16_t i_a017f0366827ee37[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_a017f0366827ee37 = { + 0xa017f0366827ee37, b_a017f0366827ee37.words, 79, d_a017f0366827ee37, m_a017f0366827ee37, + 1, 4, i_a017f0366827ee37, nullptr, nullptr, { &s_a017f0366827ee37, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<113> b_94f7e0b103b4b718 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 24, 183, 180, 3, 177, 224, 247, 148, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 110, 105, 111, 110, 68, 101, 102, 97, + 117, 108, 116, 115, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 145, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 0, 0, 0, 3, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 197, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 196, 0, 0, 0, 3, 0, 1, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 221, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 3, 0, 1, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 115, 49, 54, 115, 56, 115, 54, 52, + 115, 56, 83, 101, 116, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 2, 0, + 3, 0, 3, 0, 4, 0, 1, 0, + 65, 1, 0, 0, 0, 0, 0, 0, + 0, 123, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 55, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 135, 75, 107, 93, 84, 220, 43, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 48, 115, 112, 115, 49, 115, 51, + 50, 83, 101, 116, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 2, 0, + 7, 0, 11, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 78, 97, 188, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 117, 110, 110, 97, 109, 101, 100, 49, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 2, 0, + 123, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 110, 97, 109, 101, 100, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 2, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 65, 1, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_94f7e0b103b4b718 = b_94f7e0b103b4b718.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_94f7e0b103b4b718[] = { + &s_9e2e784c915329b6, + &s_f47697362233ce52, +}; +static const uint16_t m_94f7e0b103b4b718[] = {1, 0, 2, 3}; +static const uint16_t i_94f7e0b103b4b718[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_94f7e0b103b4b718 = { + 0x94f7e0b103b4b718, b_94f7e0b103b4b718.words, 113, d_94f7e0b103b4b718, m_94f7e0b103b4b718, + 2, 4, i_94f7e0b103b4b718, nullptr, nullptr, { &s_94f7e0b103b4b718, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<74> b_d9f2b5941a343bcd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 115, 116, 101, 100, 84, 121, 112, + 101, 115, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 9, 0, 0, 0, 90, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 9, 0, 0, 0, 106, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 69, 110, + 117, 109, 0, 0, 0, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 3, 0, 1, 0, + 88, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 0, 0, 0, 3, 0, 1, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 110, 101, 115, 116, 101, 100, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d9f2b5941a343bcd = b_d9f2b5941a343bcd.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d9f2b5941a343bcd[] = { + &s_82cd03a53b29d76b, + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_d9f2b5941a343bcd[] = {2, 0, 1}; +static const uint16_t i_d9f2b5941a343bcd[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_d9f2b5941a343bcd = { + 0xd9f2b5941a343bcd, b_d9f2b5941a343bcd.words, 74, d_d9f2b5941a343bcd, m_d9f2b5941a343bcd, + 3, 3, i_d9f2b5941a343bcd, nullptr, nullptr, { &s_d9f2b5941a343bcd, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<27> b_b651d2fba42056d4 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 27, 0, 0, 0, 2, 0, 0, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 115, 116, 101, 100, 84, 121, 112, + 101, 115, 46, 78, 101, 115, 116, 101, + 100, 69, 110, 117, 109, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b651d2fba42056d4 = b_b651d2fba42056d4.words; +#if !CAPNP_LITE +static const uint16_t m_b651d2fba42056d4[] = {1, 0}; +const ::capnp::_::RawSchema s_b651d2fba42056d4 = { + 0xb651d2fba42056d4, b_b651d2fba42056d4.words, 27, nullptr, m_b651d2fba42056d4, + 0, 2, nullptr, nullptr, nullptr, { &s_b651d2fba42056d4, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(NestedEnum_b651d2fba42056d4, b651d2fba42056d4); +static const ::capnp::_::AlignedData<55> b_82cd03a53b29d76b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 27, 0, 0, 0, 1, 0, 1, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 115, 116, 101, 100, 84, 121, 112, + 101, 115, 46, 78, 101, 115, 116, 101, + 100, 83, 116, 114, 117, 99, 116, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 1, 0, 0, 0, 90, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 69, 110, + 117, 109, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_82cd03a53b29d76b = b_82cd03a53b29d76b.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_82cd03a53b29d76b[] = { + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_82cd03a53b29d76b[] = {1, 0}; +static const uint16_t i_82cd03a53b29d76b[] = {0, 1}; +const ::capnp::_::RawSchema s_82cd03a53b29d76b = { + 0x82cd03a53b29d76b, b_82cd03a53b29d76b.words, 55, d_82cd03a53b29d76b, m_82cd03a53b29d76b, + 2, 2, i_82cd03a53b29d76b, nullptr, nullptr, { &s_82cd03a53b29d76b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_cfa0d546993a3df3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 40, 0, 0, 0, 2, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 1, 0, 0, + 45, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 79, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 115, 116, 101, 100, 84, 121, 112, + 101, 115, 46, 78, 101, 115, 116, 101, + 100, 83, 116, 114, 117, 99, 116, 46, + 78, 101, 115, 116, 101, 100, 69, 110, + 117, 109, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_cfa0d546993a3df3 = b_cfa0d546993a3df3.words; +#if !CAPNP_LITE +static const uint16_t m_cfa0d546993a3df3[] = {0, 2, 1}; +const ::capnp::_::RawSchema s_cfa0d546993a3df3 = { + 0xcfa0d546993a3df3, b_cfa0d546993a3df3.words, 33, nullptr, m_cfa0d546993a3df3, + 0, 3, nullptr, nullptr, nullptr, { &s_cfa0d546993a3df3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(NestedEnum_cfa0d546993a3df3, cfa0d546993a3df3); +static const ::capnp::_::AlignedData<49> b_e78aac389e77b065 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 101, 176, 119, 158, 56, 172, 138, 231, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 115, 105, 110, 103, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e78aac389e77b065 = b_e78aac389e77b065.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e78aac389e77b065[] = { + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_e78aac389e77b065[] = {0, 1}; +static const uint16_t i_e78aac389e77b065[] = {0, 1}; +const ::capnp::_::RawSchema s_e78aac389e77b065 = { + 0xe78aac389e77b065, b_e78aac389e77b065.words, 49, d_e78aac389e77b065, m_e78aac389e77b065, + 2, 2, i_e78aac389e77b065, nullptr, nullptr, { &s_e78aac389e77b065, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<274> b_e41885c94393277e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 10, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 0, 0, 0, 55, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 0, 0, 0, 0, + 56, 0, 0, 0, 1, 0, 1, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 105, 0, 0, 0, 66, 0, 0, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 101, 0, 0, 0, 66, 0, 0, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 97, 0, 0, 0, 66, 0, 0, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 93, 0, 0, 0, 74, 0, 0, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 93, 0, 0, 0, 74, 0, 0, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 93, 0, 0, 0, 74, 0, 0, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 93, 0, 0, 0, 66, 0, 0, 0, + 106, 177, 54, 163, 76, 35, 58, 148, + 89, 0, 0, 0, 74, 0, 0, 0, + 205, 148, 165, 116, 14, 188, 145, 137, + 89, 0, 0, 0, 74, 0, 0, 0, + 36, 122, 140, 82, 22, 116, 38, 237, + 89, 0, 0, 0, 74, 0, 0, 0, + 230, 88, 125, 3, 123, 131, 120, 153, + 89, 0, 0, 0, 82, 0, 0, 0, + 4, 121, 74, 245, 64, 169, 95, 237, + 89, 0, 0, 0, 82, 0, 0, 0, + 125, 124, 89, 242, 120, 55, 116, 188, + 89, 0, 0, 0, 82, 0, 0, 0, + 61, 1, 130, 1, 164, 100, 227, 194, + 89, 0, 0, 0, 74, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 48, 0, + 83, 116, 114, 117, 99, 116, 49, 0, + 83, 116, 114, 117, 99, 116, 56, 0, + 83, 116, 114, 117, 99, 116, 49, 54, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 51, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 54, 52, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 80, 0, + 83, 116, 114, 117, 99, 116, 48, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 49, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 56, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 49, 54, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 51, 50, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 54, 52, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 80, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 1, 0, 0, 3, 0, 1, 0, + 32, 1, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 1, 0, 0, 3, 0, 1, 0, + 52, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 1, 0, 0, 3, 0, 1, 0, + 72, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 1, 0, 0, 3, 0, 1, 0, + 92, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 89, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 1, 0, 0, 3, 0, 1, 0, + 112, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 1, 0, 0, 3, 0, 1, 0, + 132, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 1, 0, 0, 3, 0, 1, 0, + 152, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 1, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 1, 0, 0, 3, 0, 1, 0, + 192, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 1, 0, 0, 3, 0, 1, 0, + 232, 1, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 1, 0, 0, 3, 0, 1, 0, + 16, 2, 0, 0, 2, 0, 1, 0, + 108, 105, 115, 116, 48, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 49, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 56, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 49, 54, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 51, 50, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 54, 52, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 80, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 76, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 76, 105, 115, 116, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e41885c94393277e = b_e41885c94393277e.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e41885c94393277e[] = { + &s_8412c03b75b2cfee, + &s_a0a8f314b80b63fd, + &s_a6411a353090145b, + &s_a8abf7a82928986c, + &s_ad7beedc4ed30742, + &s_c6abf1b0329e6227, + &s_e0fe5870b141ad69, + &s_ef9a34f2ff7cc646, +}; +static const uint16_t m_e41885c94393277e[] = {7, 0, 1, 3, 4, 5, 2, 6, 9, 8}; +static const uint16_t i_e41885c94393277e[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; +const ::capnp::_::RawSchema s_e41885c94393277e = { + 0xe41885c94393277e, b_e41885c94393277e.words, 274, d_e41885c94393277e, m_e41885c94393277e, + 8, 10, i_e41885c94393277e, nullptr, nullptr, { &s_e41885c94393277e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_8412c03b75b2cfee = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 21, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 48, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8412c03b75b2cfee = b_8412c03b75b2cfee.words; +#if !CAPNP_LITE +static const uint16_t m_8412c03b75b2cfee[] = {0}; +static const uint16_t i_8412c03b75b2cfee[] = {0}; +const ::capnp::_::RawSchema s_8412c03b75b2cfee = { + 0x8412c03b75b2cfee, b_8412c03b75b2cfee.words, 33, nullptr, m_8412c03b75b2cfee, + 0, 1, i_8412c03b75b2cfee, nullptr, nullptr, { &s_8412c03b75b2cfee, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_e0fe5870b141ad69 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e0fe5870b141ad69 = b_e0fe5870b141ad69.words; +#if !CAPNP_LITE +static const uint16_t m_e0fe5870b141ad69[] = {0}; +static const uint16_t i_e0fe5870b141ad69[] = {0}; +const ::capnp::_::RawSchema s_e0fe5870b141ad69 = { + 0xe0fe5870b141ad69, b_e0fe5870b141ad69.words, 33, nullptr, m_e0fe5870b141ad69, + 0, 1, i_e0fe5870b141ad69, nullptr, nullptr, { &s_e0fe5870b141ad69, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_a6411a353090145b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 56, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a6411a353090145b = b_a6411a353090145b.words; +#if !CAPNP_LITE +static const uint16_t m_a6411a353090145b[] = {0}; +static const uint16_t i_a6411a353090145b[] = {0}; +const ::capnp::_::RawSchema s_a6411a353090145b = { + 0xa6411a353090145b, b_a6411a353090145b.words, 33, nullptr, m_a6411a353090145b, + 0, 1, i_a6411a353090145b, nullptr, nullptr, { &s_a6411a353090145b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_a8abf7a82928986c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 49, 54, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a8abf7a82928986c = b_a8abf7a82928986c.words; +#if !CAPNP_LITE +static const uint16_t m_a8abf7a82928986c[] = {0}; +static const uint16_t i_a8abf7a82928986c[] = {0}; +const ::capnp::_::RawSchema s_a8abf7a82928986c = { + 0xa8abf7a82928986c, b_a8abf7a82928986c.words, 33, nullptr, m_a8abf7a82928986c, + 0, 1, i_a8abf7a82928986c, nullptr, nullptr, { &s_a8abf7a82928986c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_ad7beedc4ed30742 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 51, 50, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ad7beedc4ed30742 = b_ad7beedc4ed30742.words; +#if !CAPNP_LITE +static const uint16_t m_ad7beedc4ed30742[] = {0}; +static const uint16_t i_ad7beedc4ed30742[] = {0}; +const ::capnp::_::RawSchema s_ad7beedc4ed30742 = { + 0xad7beedc4ed30742, b_ad7beedc4ed30742.words, 33, nullptr, m_ad7beedc4ed30742, + 0, 1, i_ad7beedc4ed30742, nullptr, nullptr, { &s_ad7beedc4ed30742, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_ef9a34f2ff7cc646 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 54, 52, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ef9a34f2ff7cc646 = b_ef9a34f2ff7cc646.words; +#if !CAPNP_LITE +static const uint16_t m_ef9a34f2ff7cc646[] = {0}; +static const uint16_t i_ef9a34f2ff7cc646[] = {0}; +const ::capnp::_::RawSchema s_ef9a34f2ff7cc646 = { + 0xef9a34f2ff7cc646, b_ef9a34f2ff7cc646.words, 33, nullptr, m_ef9a34f2ff7cc646, + 0, 1, i_ef9a34f2ff7cc646, nullptr, nullptr, { &s_ef9a34f2ff7cc646, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_c6abf1b0329e6227 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 21, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 80, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c6abf1b0329e6227 = b_c6abf1b0329e6227.words; +#if !CAPNP_LITE +static const uint16_t m_c6abf1b0329e6227[] = {0}; +static const uint16_t i_c6abf1b0329e6227[] = {0}; +const ::capnp::_::RawSchema s_c6abf1b0329e6227 = { + 0xc6abf1b0329e6227, b_c6abf1b0329e6227.words, 33, nullptr, m_c6abf1b0329e6227, + 0, 1, i_c6abf1b0329e6227, nullptr, nullptr, { &s_c6abf1b0329e6227, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_943a234ca336b16a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 106, 177, 54, 163, 76, 35, 58, 148, + 21, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 48, 99, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_943a234ca336b16a = b_943a234ca336b16a.words; +#if !CAPNP_LITE +static const uint16_t m_943a234ca336b16a[] = {0, 1}; +static const uint16_t i_943a234ca336b16a[] = {0, 1}; +const ::capnp::_::RawSchema s_943a234ca336b16a = { + 0x943a234ca336b16a, b_943a234ca336b16a.words, 48, nullptr, m_943a234ca336b16a, + 0, 2, i_943a234ca336b16a, nullptr, nullptr, { &s_943a234ca336b16a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_8991bc0e74a594cd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 205, 148, 165, 116, 14, 188, 145, 137, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 49, 99, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8991bc0e74a594cd = b_8991bc0e74a594cd.words; +#if !CAPNP_LITE +static const uint16_t m_8991bc0e74a594cd[] = {0, 1}; +static const uint16_t i_8991bc0e74a594cd[] = {0, 1}; +const ::capnp::_::RawSchema s_8991bc0e74a594cd = { + 0x8991bc0e74a594cd, b_8991bc0e74a594cd.words, 48, nullptr, m_8991bc0e74a594cd, + 0, 2, i_8991bc0e74a594cd, nullptr, nullptr, { &s_8991bc0e74a594cd, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_ed267416528c7a24 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 36, 122, 140, 82, 22, 116, 38, 237, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 56, 99, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ed267416528c7a24 = b_ed267416528c7a24.words; +#if !CAPNP_LITE +static const uint16_t m_ed267416528c7a24[] = {0, 1}; +static const uint16_t i_ed267416528c7a24[] = {0, 1}; +const ::capnp::_::RawSchema s_ed267416528c7a24 = { + 0xed267416528c7a24, b_ed267416528c7a24.words, 48, nullptr, m_ed267416528c7a24, + 0, 2, i_ed267416528c7a24, nullptr, nullptr, { &s_ed267416528c7a24, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_9978837b037d58e6 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 230, 88, 125, 3, 123, 131, 120, 153, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 49, 54, 99, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9978837b037d58e6 = b_9978837b037d58e6.words; +#if !CAPNP_LITE +static const uint16_t m_9978837b037d58e6[] = {0, 1}; +static const uint16_t i_9978837b037d58e6[] = {0, 1}; +const ::capnp::_::RawSchema s_9978837b037d58e6 = { + 0x9978837b037d58e6, b_9978837b037d58e6.words, 48, nullptr, m_9978837b037d58e6, + 0, 2, i_9978837b037d58e6, nullptr, nullptr, { &s_9978837b037d58e6, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_ed5fa940f54a7904 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 4, 121, 74, 245, 64, 169, 95, 237, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 51, 50, 99, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ed5fa940f54a7904 = b_ed5fa940f54a7904.words; +#if !CAPNP_LITE +static const uint16_t m_ed5fa940f54a7904[] = {0, 1}; +static const uint16_t i_ed5fa940f54a7904[] = {0, 1}; +const ::capnp::_::RawSchema s_ed5fa940f54a7904 = { + 0xed5fa940f54a7904, b_ed5fa940f54a7904.words, 48, nullptr, m_ed5fa940f54a7904, + 0, 2, i_ed5fa940f54a7904, nullptr, nullptr, { &s_ed5fa940f54a7904, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_bc743778f2597c7d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 125, 124, 89, 242, 120, 55, 116, 188, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 54, 52, 99, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_bc743778f2597c7d = b_bc743778f2597c7d.words; +#if !CAPNP_LITE +static const uint16_t m_bc743778f2597c7d[] = {0, 1}; +static const uint16_t i_bc743778f2597c7d[] = {0, 1}; +const ::capnp::_::RawSchema s_bc743778f2597c7d = { + 0xbc743778f2597c7d, b_bc743778f2597c7d.words, 48, nullptr, m_bc743778f2597c7d, + 0, 2, i_bc743778f2597c7d, nullptr, nullptr, { &s_bc743778f2597c7d, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_c2e364a40182013d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 61, 1, 130, 1, 164, 100, 227, 194, + 21, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 115, 46, 83, 116, 114, + 117, 99, 116, 80, 99, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c2e364a40182013d = b_c2e364a40182013d.words; +#if !CAPNP_LITE +static const uint16_t m_c2e364a40182013d[] = {0, 1}; +static const uint16_t i_c2e364a40182013d[] = {0, 1}; +const ::capnp::_::RawSchema s_c2e364a40182013d = { + 0xc2e364a40182013d, b_c2e364a40182013d.words, 48, nullptr, m_c2e364a40182013d, + 0, 2, i_c2e364a40182013d, nullptr, nullptr, { &s_c2e364a40182013d, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<65> b_92fc29a80f3ddd5c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 92, 221, 61, 15, 168, 41, 252, 146, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 70, + 105, 101, 108, 100, 90, 101, 114, 111, + 73, 115, 66, 105, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 3, 0, 1, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 98, 105, 116, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 101, 99, 111, 110, 100, 66, 105, + 116, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 104, 105, 114, 100, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_92fc29a80f3ddd5c = b_92fc29a80f3ddd5c.words; +#if !CAPNP_LITE +static const uint16_t m_92fc29a80f3ddd5c[] = {0, 1, 2}; +static const uint16_t i_92fc29a80f3ddd5c[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_92fc29a80f3ddd5c = { + 0x92fc29a80f3ddd5c, b_92fc29a80f3ddd5c.words, 65, nullptr, m_92fc29a80f3ddd5c, + 0, 3, i_92fc29a80f3ddd5c, nullptr, nullptr, { &s_92fc29a80f3ddd5c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<168> b_a851ad32cbc2ffea = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 234, 255, 194, 203, 50, 173, 81, 168, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 105, 115, 116, 68, 101, 102, 97, 117, + 108, 116, 115, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 108, 105, 115, 116, 115, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 37, 0, 0, 0, 39, 0, 0, 0, + 53, 0, 0, 0, 23, 0, 0, 0, + 61, 0, 0, 0, 23, 0, 0, 0, + 69, 0, 0, 0, 23, 0, 0, 0, + 77, 0, 0, 0, 23, 0, 0, 0, + 85, 0, 0, 0, 23, 0, 0, 0, + 101, 0, 0, 0, 30, 0, 0, 0, + 125, 0, 0, 0, 30, 0, 0, 0, + 173, 0, 0, 0, 22, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 0, 0, + 123, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 0, 0, + 57, 48, 0, 0, 0, 0, 0, 0, + 133, 26, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 0, 0, + 21, 205, 91, 7, 0, 0, 0, 0, + 210, 56, 251, 13, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 0, 0, + 192, 186, 138, 60, 213, 98, 4, 0, + 135, 75, 170, 237, 97, 85, 8, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 28, 0, 0, 0, + 13, 0, 0, 0, 20, 0, 0, 0, + 13, 0, 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 5, 0, 0, 0, + 242, 79, 188, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 22, 0, 0, 0, + 21, 0, 0, 0, 14, 0, 0, 0, + 25, 0, 0, 0, 22, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 50, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 5, 0, 0, 0, 167, 1, 0, 0, + 213, 0, 0, 0, 215, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 123, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 200, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 21, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a851ad32cbc2ffea = b_a851ad32cbc2ffea.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a851ad32cbc2ffea[] = { + &s_e41885c94393277e, +}; +static const uint16_t m_a851ad32cbc2ffea[] = {0}; +static const uint16_t i_a851ad32cbc2ffea[] = {0}; +const ::capnp::_::RawSchema s_a851ad32cbc2ffea = { + 0xa851ad32cbc2ffea, b_a851ad32cbc2ffea.words, 168, d_a851ad32cbc2ffea, m_a851ad32cbc2ffea, + 1, 1, i_a851ad32cbc2ffea, nullptr, nullptr, { &s_a851ad32cbc2ffea, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<81> b_a76e3c9bb7fd56d3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 11, 0, 0, 0, 1, 0, 3, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 97, 116, 101, 85, 110, 105, 111, 110, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 3, 0, 0, 0, + 121, 160, 26, 144, 162, 128, 114, 128, + 137, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 7, 0, 0, 0, + 58, 142, 233, 222, 132, 57, 151, 193, + 117, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 104, 101, 85, 110, 105, 111, 110, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 85, + 110, 105, 111, 110, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a76e3c9bb7fd56d3 = b_a76e3c9bb7fd56d3.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a76e3c9bb7fd56d3[] = { + &s_807280a2901aa079, + &s_c1973984dee98e3a, +}; +static const uint16_t m_a76e3c9bb7fd56d3[] = {4, 1, 2, 0, 3}; +static const uint16_t i_a76e3c9bb7fd56d3[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_a76e3c9bb7fd56d3 = { + 0xa76e3c9bb7fd56d3, b_a76e3c9bb7fd56d3.words, 81, d_a76e3c9bb7fd56d3, m_a76e3c9bb7fd56d3, + 2, 5, i_a76e3c9bb7fd56d3, nullptr, nullptr, { &s_a76e3c9bb7fd56d3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<67> b_807280a2901aa079 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 121, 160, 26, 144, 162, 128, 114, 128, + 25, 0, 0, 0, 1, 0, 3, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 3, 0, 7, 0, 1, 0, 3, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 97, 116, 101, 85, 110, 105, 111, 110, + 46, 116, 104, 101, 85, 110, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 88, 0, 0, 0, 3, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_807280a2901aa079 = b_807280a2901aa079.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_807280a2901aa079[] = { + &s_a76e3c9bb7fd56d3, +}; +static const uint16_t m_807280a2901aa079[] = {1, 2, 0}; +static const uint16_t i_807280a2901aa079[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_807280a2901aa079 = { + 0x807280a2901aa079, b_807280a2901aa079.words, 67, d_807280a2901aa079, m_807280a2901aa079, + 1, 3, i_807280a2901aa079, nullptr, nullptr, { &s_807280a2901aa079, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<67> b_c1973984dee98e3a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 58, 142, 233, 222, 132, 57, 151, 193, + 25, 0, 0, 0, 1, 0, 3, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 3, 0, 7, 0, 1, 0, 3, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 76, + 97, 116, 101, 85, 110, 105, 111, 110, + 46, 97, 110, 111, 116, 104, 101, 114, + 85, 110, 105, 111, 110, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 88, 0, 0, 0, 3, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c1973984dee98e3a = b_c1973984dee98e3a.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c1973984dee98e3a[] = { + &s_a76e3c9bb7fd56d3, +}; +static const uint16_t m_c1973984dee98e3a[] = {1, 2, 0}; +static const uint16_t i_c1973984dee98e3a[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_c1973984dee98e3a = { + 0xc1973984dee98e3a, b_c1973984dee98e3a.words, 67, d_c1973984dee98e3a, m_c1973984dee98e3a, + 1, 3, i_c1973984dee98e3a, nullptr, nullptr, { &s_c1973984dee98e3a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<63> b_95b30dd14e01dda8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 168, 221, 1, 78, 209, 13, 179, 149, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 79, + 108, 100, 86, 101, 114, 115, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 111, 108, 100, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 51, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 168, 221, 1, 78, 209, 13, 179, 149, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_95b30dd14e01dda8 = b_95b30dd14e01dda8.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_95b30dd14e01dda8[] = { + &s_95b30dd14e01dda8, +}; +static const uint16_t m_95b30dd14e01dda8[] = {0, 1, 2}; +static const uint16_t i_95b30dd14e01dda8[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_95b30dd14e01dda8 = { + 0x95b30dd14e01dda8, b_95b30dd14e01dda8.words, 63, d_95b30dd14e01dda8, m_95b30dd14e01dda8, + 1, 3, i_95b30dd14e01dda8, nullptr, nullptr, { &s_95b30dd14e01dda8, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<94> b_8ed75a7469f04ce3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 227, 76, 240, 105, 116, 90, 215, 142, + 11, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 119, 86, 101, 114, 115, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 137, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 111, 108, 100, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 51, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 227, 76, 240, 105, 116, 90, 215, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 119, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 219, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 119, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8ed75a7469f04ce3 = b_8ed75a7469f04ce3.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8ed75a7469f04ce3[] = { + &s_8ed75a7469f04ce3, +}; +static const uint16_t m_8ed75a7469f04ce3[] = {3, 4, 0, 1, 2}; +static const uint16_t i_8ed75a7469f04ce3[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_8ed75a7469f04ce3 = { + 0x8ed75a7469f04ce3, b_8ed75a7469f04ce3.words, 94, d_8ed75a7469f04ce3, m_8ed75a7469f04ce3, + 1, 5, i_8ed75a7469f04ce3, nullptr, nullptr, { &s_8ed75a7469f04ce3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_bd5fe16e5170c492 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 146, 196, 112, 81, 110, 225, 95, 189, + 11, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 79, + 108, 100, 85, 110, 105, 111, 110, 86, + 101, 114, 115, 105, 111, 110, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 97, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_bd5fe16e5170c492 = b_bd5fe16e5170c492.words; +#if !CAPNP_LITE +static const uint16_t m_bd5fe16e5170c492[] = {0, 1}; +static const uint16_t i_bd5fe16e5170c492[] = {0, 1}; +const ::capnp::_::RawSchema s_bd5fe16e5170c492 = { + 0xbd5fe16e5170c492, b_bd5fe16e5170c492.words, 48, nullptr, m_bd5fe16e5170c492, + 0, 2, i_bd5fe16e5170c492, nullptr, nullptr, { &s_bd5fe16e5170c492, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<41> b_c7e4c513a975492b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 43, 73, 117, 169, 19, 197, 228, 199, + 11, 0, 0, 0, 1, 0, 3, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 119, 85, 110, 105, 111, 110, 86, + 101, 114, 115, 105, 111, 110, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 132, 62, 81, 228, 29, 44, 35, 134, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 254, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 1, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 97, 0, 0, 0, 0, 0, 0, 0, + 98, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c7e4c513a975492b = b_c7e4c513a975492b.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c7e4c513a975492b[] = { + &s_86232c1de4513e84, +}; +static const uint16_t m_c7e4c513a975492b[] = {0, 1}; +static const uint16_t i_c7e4c513a975492b[] = {0, 1}; +const ::capnp::_::RawSchema s_c7e4c513a975492b = { + 0xc7e4c513a975492b, b_c7e4c513a975492b.words, 41, d_c7e4c513a975492b, m_c7e4c513a975492b, + 1, 2, i_c7e4c513a975492b, nullptr, nullptr, { &s_c7e4c513a975492b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_86232c1de4513e84 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 132, 62, 81, 228, 29, 44, 35, 134, + 31, 0, 0, 0, 1, 0, 3, 0, + 43, 73, 117, 169, 19, 197, 228, 199, + 0, 0, 7, 0, 1, 0, 2, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 101, 119, 85, 110, 105, 111, 110, 86, + 101, 114, 115, 105, 111, 110, 46, 97, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 97, 48, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 49, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_86232c1de4513e84 = b_86232c1de4513e84.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_86232c1de4513e84[] = { + &s_c7e4c513a975492b, +}; +static const uint16_t m_86232c1de4513e84[] = {0, 1}; +static const uint16_t i_86232c1de4513e84[] = {0, 1}; +const ::capnp::_::RawSchema s_86232c1de4513e84 = { + 0x86232c1de4513e84, b_86232c1de4513e84.words, 48, d_86232c1de4513e84, m_86232c1de4513e84, + 1, 2, i_86232c1de4513e84, nullptr, nullptr, { &s_86232c1de4513e84, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_faf781ef89a00e39 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 57, 14, 160, 137, 239, 129, 247, 250, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 114, 117, 99, 116, 85, 110, 105, + 111, 110, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 133, 16, 23, 63, 130, 201, 174, 157, + 1, 0, 0, 0, 90, 0, 0, 0, + 83, 111, 109, 101, 83, 116, 114, 117, + 99, 116, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 60, 90, 239, 123, 103, 220, 46, 153, + 13, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_faf781ef89a00e39 = b_faf781ef89a00e39.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_faf781ef89a00e39[] = { + &s_992edc677bef5a3c, +}; +static const uint16_t m_faf781ef89a00e39[] = {0}; +static const uint16_t i_faf781ef89a00e39[] = {0}; +const ::capnp::_::RawSchema s_faf781ef89a00e39 = { + 0xfaf781ef89a00e39, b_faf781ef89a00e39.words, 30, d_faf781ef89a00e39, m_faf781ef89a00e39, + 1, 1, i_faf781ef89a00e39, nullptr, nullptr, { &s_faf781ef89a00e39, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<51> b_9daec9823f171085 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 133, 16, 23, 63, 130, 201, 174, 157, + 27, 0, 0, 0, 1, 0, 0, 0, + 57, 14, 160, 137, 239, 129, 247, 250, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 114, 117, 99, 116, 85, 110, 105, + 111, 110, 46, 83, 111, 109, 101, 83, + 116, 114, 117, 99, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 115, 111, 109, 101, 84, 101, 120, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 111, 114, 101, 84, 101, 120, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9daec9823f171085 = b_9daec9823f171085.words; +#if !CAPNP_LITE +static const uint16_t m_9daec9823f171085[] = {1, 0}; +static const uint16_t i_9daec9823f171085[] = {0, 1}; +const ::capnp::_::RawSchema s_9daec9823f171085 = { + 0x9daec9823f171085, b_9daec9823f171085.words, 51, nullptr, m_9daec9823f171085, + 0, 2, i_9daec9823f171085, nullptr, nullptr, { &s_9daec9823f171085, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<47> b_992edc677bef5a3c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 60, 90, 239, 123, 103, 220, 46, 153, + 27, 0, 0, 0, 1, 0, 1, 0, + 57, 14, 160, 137, 239, 129, 247, 250, + 1, 0, 7, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 114, 117, 99, 116, 85, 110, 105, + 111, 110, 46, 117, 110, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 115, 116, 114, 117, 99, 116, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 133, 16, 23, 63, 130, 201, 174, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 98, 106, 101, 99, 116, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_992edc677bef5a3c = b_992edc677bef5a3c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_992edc677bef5a3c[] = { + &s_9daec9823f171085, + &s_e3da5a2ccd28c0d8, + &s_faf781ef89a00e39, +}; +static const uint16_t m_992edc677bef5a3c[] = {1, 0}; +static const uint16_t i_992edc677bef5a3c[] = {0, 1}; +const ::capnp::_::RawSchema s_992edc677bef5a3c = { + 0x992edc677bef5a3c, b_992edc677bef5a3c.words, 47, d_992edc677bef5a3c, m_992edc677bef5a3c, + 3, 2, i_992edc677bef5a3c, nullptr, nullptr, { &s_992edc677bef5a3c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<59> b_dec497819d097c3c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 60, 124, 9, 157, 129, 151, 196, 222, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 18, 1, 0, 0, + 37, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 114, 105, 110, 116, 73, 110, 108, 105, + 110, 101, 83, 116, 114, 117, 99, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 194, 218, 8, 55, 0, 54, 73, 142, + 1, 0, 0, 0, 106, 0, 0, 0, + 73, 110, 108, 105, 110, 101, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 115, 111, 109, 101, 84, 101, 120, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 194, 218, 8, 55, 0, 54, 73, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_dec497819d097c3c = b_dec497819d097c3c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_dec497819d097c3c[] = { + &s_8e4936003708dac2, +}; +static const uint16_t m_dec497819d097c3c[] = {0, 1}; +static const uint16_t i_dec497819d097c3c[] = {0, 1}; +const ::capnp::_::RawSchema s_dec497819d097c3c = { + 0xdec497819d097c3c, b_dec497819d097c3c.words, 59, d_dec497819d097c3c, m_dec497819d097c3c, + 1, 2, i_dec497819d097c3c, nullptr, nullptr, { &s_dec497819d097c3c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<52> b_8e4936003708dac2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 194, 218, 8, 55, 0, 54, 73, 142, + 34, 0, 0, 0, 1, 0, 1, 0, + 60, 124, 9, 157, 129, 151, 196, 222, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 114, 105, 110, 116, 73, 110, 108, 105, + 110, 101, 83, 116, 114, 117, 99, 116, + 115, 46, 73, 110, 108, 105, 110, 101, + 83, 116, 114, 117, 99, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8e4936003708dac2 = b_8e4936003708dac2.words; +#if !CAPNP_LITE +static const uint16_t m_8e4936003708dac2[] = {0, 1}; +static const uint16_t i_8e4936003708dac2[] = {0, 1}; +const ::capnp::_::RawSchema s_8e4936003708dac2 = { + 0x8e4936003708dac2, b_8e4936003708dac2.words, 52, nullptr, m_8e4936003708dac2, + 0, 2, i_8e4936003708dac2, nullptr, nullptr, { &s_8e4936003708dac2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<58> b_91afd4a864dbb030 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 48, 176, 219, 100, 168, 212, 175, 145, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 37, 0, 0, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 65, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 87, + 104, 111, 108, 101, 70, 108, 111, 97, + 116, 68, 101, 102, 97, 117, 108, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 235, 243, 144, 91, 46, 229, 79, 178, + 9, 0, 0, 0, 74, 0, 0, 0, + 94, 47, 123, 95, 85, 45, 145, 246, + 9, 0, 0, 0, 98, 0, 0, 0, + 99, 111, 110, 115, 116, 97, 110, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 103, 67, 111, 110, 115, 116, + 97, 110, 116, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 3, 0, 1, 0, + 56, 0, 0, 0, 2, 0, 1, 0, + 102, 105, 101, 108, 100, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 246, 66, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 103, 70, 105, 101, 108, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 202, 242, 201, 113, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_91afd4a864dbb030 = b_91afd4a864dbb030.words; +#if !CAPNP_LITE +static const uint16_t m_91afd4a864dbb030[] = {1, 0}; +static const uint16_t i_91afd4a864dbb030[] = {0, 1}; +const ::capnp::_::RawSchema s_91afd4a864dbb030 = { + 0x91afd4a864dbb030, b_91afd4a864dbb030.words, 58, nullptr, m_91afd4a864dbb030, + 0, 2, i_91afd4a864dbb030, nullptr, nullptr, { &s_91afd4a864dbb030, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<26> b_b24fe52e5b90f3eb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 235, 243, 144, 91, 46, 229, 79, 178, + 33, 0, 0, 0, 4, 0, 0, 0, + 48, 176, 219, 100, 168, 212, 175, 145, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 87, + 104, 111, 108, 101, 70, 108, 111, 97, + 116, 68, 101, 102, 97, 117, 108, 116, + 46, 99, 111, 110, 115, 116, 97, 110, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 228, 67, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b24fe52e5b90f3eb = b_b24fe52e5b90f3eb.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_b24fe52e5b90f3eb = { + 0xb24fe52e5b90f3eb, b_b24fe52e5b90f3eb.words, 26, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_b24fe52e5b90f3eb, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<26> b_f6912d555f7b2f5e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 94, 47, 123, 95, 85, 45, 145, 246, + 33, 0, 0, 0, 4, 0, 0, 0, + 48, 176, 219, 100, 168, 212, 175, 145, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 87, + 104, 111, 108, 101, 70, 108, 111, 97, + 116, 68, 101, 102, 97, 117, 108, 116, + 46, 98, 105, 103, 67, 111, 110, 115, + 116, 97, 110, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 202, 242, 73, 114, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f6912d555f7b2f5e = b_f6912d555f7b2f5e.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f6912d555f7b2f5e = { + 0xf6912d555f7b2f5e, b_f6912d555f7b2f5e.words, 26, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f6912d555f7b2f5e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<134> b_9d5b8cd8de9922eb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 87, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 213, 1, 0, 0, 23, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 0, + 20, 0, 0, 0, 1, 0, 1, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 33, 0, 0, 0, 50, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 29, 0, 0, 0, 58, 0, 0, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 25, 0, 0, 0, 82, 0, 0, 0, + 255, 13, 32, 233, 109, 113, 82, 137, + 25, 0, 0, 0, 34, 0, 0, 0, + 207, 166, 91, 180, 223, 110, 101, 142, + 21, 0, 0, 0, 90, 0, 0, 0, + 73, 110, 110, 101, 114, 0, 0, 0, + 73, 110, 110, 101, 114, 50, 0, 0, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 110, 0, 0, 0, 0, 0, + 85, 115, 101, 65, 108, 105, 97, 115, + 101, 115, 0, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 1, 0, + 212, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 78, 56, 243, 234, 155, 119, 106, 180, + 209, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 0, 0, 0, 3, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 118, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 118, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 103, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 70, 111, 111, 0, 0, 0, 0, 0, + 66, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9d5b8cd8de9922eb = b_9d5b8cd8de9922eb.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_9d5b8cd8de9922eb[] = { + &s_9d5b8cd8de9922eb, + &s_b46a779beaf3384e, + &s_f6a841117e19ac73, +}; +static const uint16_t m_9d5b8cd8de9922eb[] = {0, 4, 1, 3, 2}; +static const uint16_t i_9d5b8cd8de9922eb[] = {2, 3, 0, 1, 4}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_9d5b8cd8de9922eb[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::_capnpPrivate::brand() }, + { 16777220, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_9d5b8cd8de9922eb = { + 0x9d5b8cd8de9922eb, b_9d5b8cd8de9922eb.words, 134, d_9d5b8cd8de9922eb, m_9d5b8cd8de9922eb, + 3, 5, i_9d5b8cd8de9922eb, nullptr, nullptr, { &s_9d5b8cd8de9922eb, nullptr, bd_9d5b8cd8de9922eb, 0, sizeof(bd_9d5b8cd8de9922eb) / sizeof(bd_9d5b8cd8de9922eb[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_f6a841117e19ac73 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 24, 0, 0, 0, 1, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f6a841117e19ac73 = b_f6a841117e19ac73.words; +#if !CAPNP_LITE +static const uint16_t m_f6a841117e19ac73[] = {1, 0}; +static const uint16_t i_f6a841117e19ac73[] = {0, 1}; +const ::capnp::_::RawSchema s_f6a841117e19ac73 = { + 0xf6a841117e19ac73, b_f6a841117e19ac73.words, 48, nullptr, m_f6a841117e19ac73, + 0, 2, i_f6a841117e19ac73, nullptr, nullptr, { &s_f6a841117e19ac73, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<92> b_a9ab42b118d6d435 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 24, 0, 0, 0, 1, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 1, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 50, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 1, 0, 0, 0, 74, 0, 0, 0, + 68, 101, 101, 112, 78, 101, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 0, 0, 0, 3, 0, 1, 0, + 144, 0, 0, 0, 2, 0, 1, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 66, 111, 117, + 110, 100, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 85, 110, 98, + 111, 117, 110, 100, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 66, 97, 122, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a9ab42b118d6d435 = b_a9ab42b118d6d435.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a9ab42b118d6d435[] = { + &s_f6a841117e19ac73, +}; +static const uint16_t m_a9ab42b118d6d435[] = {0, 1, 2, 3}; +static const uint16_t i_a9ab42b118d6d435[] = {0, 1, 2, 3}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_a9ab42b118d6d435[] = { + { 16777218, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_a9ab42b118d6d435 = { + 0xa9ab42b118d6d435, b_a9ab42b118d6d435.words, 92, d_a9ab42b118d6d435, m_a9ab42b118d6d435, + 1, 4, i_a9ab42b118d6d435, nullptr, nullptr, { &s_a9ab42b118d6d435, nullptr, bd_a9ab42b118d6d435, 0, sizeof(bd_a9ab42b118d6d435) / sizeof(bd_a9ab42b118d6d435[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<87> b_b6a0829c762b06f3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 31, 0, 0, 0, 1, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 1, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 50, 46, 68, + 101, 101, 112, 78, 101, 115, 116, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 135, 66, 121, 201, 134, 237, 57, 136, + 1, 0, 0, 0, 146, 0, 0, 0, + 68, 101, 101, 112, 78, 101, 115, 116, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 0, 0, 0, 3, 0, 1, 0, + 112, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 0, 0, 0, 3, 0, 1, 0, + 116, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 81, 117, 120, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b6a0829c762b06f3 = b_b6a0829c762b06f3.words; +#if !CAPNP_LITE +static const uint16_t m_b6a0829c762b06f3[] = {1, 2, 0, 3}; +static const uint16_t i_b6a0829c762b06f3[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_b6a0829c762b06f3 = { + 0xb6a0829c762b06f3, b_b6a0829c762b06f3.words, 87, nullptr, m_b6a0829c762b06f3, + 0, 4, i_b6a0829c762b06f3, nullptr, nullptr, { &s_b6a0829c762b06f3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<64> b_8839ed86c9794287 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 135, 66, 121, 201, 134, 237, 57, 136, + 40, 0, 0, 0, 3, 0, 0, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 210, 1, 0, 0, + 49, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 71, 0, 0, 0, + 197, 0, 0, 0, 7, 0, 0, 0, + 197, 0, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 50, 46, 68, + 101, 101, 112, 78, 101, 115, 116, 46, + 68, 101, 101, 112, 78, 101, 115, 116, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 112, 67, 153, 199, 236, 78, 184, + 111, 79, 97, 84, 252, 240, 128, 224, + 17, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 1, 0, + 64, 0, 0, 0, 0, 0, 1, 0, + 117, 0, 0, 0, 7, 0, 0, 0, + 99, 97, 108, 108, 0, 0, 0, 0, + 1, 0, 0, 0, 103, 0, 0, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 135, 66, 121, 201, 134, 237, 57, 136, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 103, 0, 0, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 135, 66, 121, 201, 134, 237, 57, 136, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 243, 6, 43, 118, 156, 130, 160, 182, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 42, 0, 0, 0, + 81, 117, 117, 120, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8839ed86c9794287 = b_8839ed86c9794287.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8839ed86c9794287[] = { + &s_b84eecc799437049, + &s_e080f0fc54614f6f, +}; +static const uint16_t m_8839ed86c9794287[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_8839ed86c9794287[] = { + { 33554432, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::AnyPointer>::DeepNest< ::capnp::AnyPointer>::DeepNestInterface< ::capnp::AnyPointer>::CallParams::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::AnyPointer>::DeepNest< ::capnp::AnyPointer>::DeepNestInterface< ::capnp::AnyPointer>::CallResults::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_8839ed86c9794287 = { + 0x8839ed86c9794287, b_8839ed86c9794287.words, 64, d_8839ed86c9794287, m_8839ed86c9794287, + 2, 1, nullptr, nullptr, nullptr, { &s_8839ed86c9794287, nullptr, bd_8839ed86c9794287, 0, sizeof(bd_8839ed86c9794287) / sizeof(bd_8839ed86c9794287[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<21> b_b84eecc799437049 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 73, 112, 67, 153, 199, 236, 78, 184, + 58, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 50, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 50, 46, 68, + 101, 101, 112, 78, 101, 115, 116, 46, + 68, 101, 101, 112, 78, 101, 115, 116, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 46, 99, 97, 108, 108, 36, 80, + 97, 114, 97, 109, 115, 0, 0, 0, } +}; +::capnp::word const* const bp_b84eecc799437049 = b_b84eecc799437049.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_b84eecc799437049 = { + 0xb84eecc799437049, b_b84eecc799437049.words, 21, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_b84eecc799437049, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<21> b_e080f0fc54614f6f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 111, 79, 97, 84, 252, 240, 128, 224, + 58, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 58, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 110, 101, 114, 50, 46, 68, + 101, 101, 112, 78, 101, 115, 116, 46, + 68, 101, 101, 112, 78, 101, 115, 116, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 46, 99, 97, 108, 108, 36, 82, + 101, 115, 117, 108, 116, 115, 0, 0, } +}; +::capnp::word const* const bp_e080f0fc54614f6f = b_e080f0fc54614f6f.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_e080f0fc54614f6f = { + 0xe080f0fc54614f6f, b_e080f0fc54614f6f.words, 21, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_e080f0fc54614f6f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<56> b_c9e749e8dd54da5c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 24, 0, 0, 0, 3, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 18, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 71, 0, 0, 0, + 165, 0, 0, 0, 7, 0, 0, 0, + 165, 0, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 173, 129, 53, 227, 36, 98, 180, 165, + 17, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 1, 0, + 68, 0, 0, 0, 0, 0, 1, 0, + 97, 0, 0, 0, 7, 0, 0, 0, + 99, 97, 108, 108, 0, 0, 0, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 81, 117, 120, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c9e749e8dd54da5c = b_c9e749e8dd54da5c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c9e749e8dd54da5c[] = { + &s_a5b46224e33581ad, + &s_a9ab42b118d6d435, +}; +static const uint16_t m_c9e749e8dd54da5c[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_c9e749e8dd54da5c[] = { + { 33554432, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Interface< ::capnp::AnyPointer>::CallResults::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_c9e749e8dd54da5c = { + 0xc9e749e8dd54da5c, b_c9e749e8dd54da5c.words, 56, d_c9e749e8dd54da5c, m_c9e749e8dd54da5c, + 2, 1, nullptr, nullptr, nullptr, { &s_c9e749e8dd54da5c, nullptr, bd_c9e749e8dd54da5c, 0, sizeof(bd_c9e749e8dd54da5c) / sizeof(bd_c9e749e8dd54da5c[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<67> b_a5b46224e33581ad = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 173, 129, 53, 227, 36, 98, 180, 165, + 34, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 122, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 73, 110, 116, 101, 114, 102, 97, 99, + 101, 46, 99, 97, 108, 108, 36, 82, + 101, 115, 117, 108, 116, 115, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 124, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 101, 110, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a5b46224e33581ad = b_a5b46224e33581ad.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a5b46224e33581ad[] = { + &s_9d5b8cd8de9922eb, +}; +static const uint16_t m_a5b46224e33581ad[] = {1, 0}; +static const uint16_t i_a5b46224e33581ad[] = {0, 1}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_a5b46224e33581ad[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_a5b46224e33581ad = { + 0xa5b46224e33581ad, b_a5b46224e33581ad.words, 67, d_a5b46224e33581ad, m_a5b46224e33581ad, + 1, 2, i_a5b46224e33581ad, nullptr, nullptr, { &s_a5b46224e33581ad, nullptr, bd_a5b46224e33581ad, 0, sizeof(bd_a5b46224e33581ad) / sizeof(bd_a5b46224e33581ad[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<21> b_8952716de9200dff = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 255, 13, 32, 233, 109, 113, 82, 137, + 24, 0, 0, 0, 5, 0, 16, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 97, 110, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8952716de9200dff = b_8952716de9200dff.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8952716de9200dff = { + 0x8952716de9200dff, b_8952716de9200dff.words, 21, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8952716de9200dff, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<151> b_8e656edfb45ba6cf = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 207, 166, 91, 180, 223, 110, 101, 142, + 24, 0, 0, 0, 1, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 6, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 87, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 85, 115, 101, 65, 108, 105, 97, 115, + 101, 115, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 24, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 1, 0, + 184, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 0, 0, 0, 3, 0, 1, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 0, 0, 0, 3, 0, 1, 0, + 20, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 1, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 1, 0, 0, 3, 0, 1, 0, + 88, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 1, 0, 0, 3, 0, 1, 0, + 92, 1, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 50, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 50, 66, 105, + 110, 100, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 50, 84, 101, + 120, 116, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 118, 70, 111, 111, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8e656edfb45ba6cf = b_8e656edfb45ba6cf.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8e656edfb45ba6cf[] = { + &s_a9ab42b118d6d435, + &s_f6a841117e19ac73, +}; +static const uint16_t m_8e656edfb45ba6cf[] = {0, 1, 2, 3, 4, 5}; +static const uint16_t i_8e656edfb45ba6cf[] = {0, 1, 2, 3, 4, 5}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_8e656edfb45ba6cf[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::_capnpPrivate::brand() }, + { 16777218, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::AnyPointer>::_capnpPrivate::brand() }, + { 16777219, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 16777220, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_8e656edfb45ba6cf = { + 0x8e656edfb45ba6cf, b_8e656edfb45ba6cf.words, 151, d_8e656edfb45ba6cf, m_8e656edfb45ba6cf, + 2, 6, i_8e656edfb45ba6cf, nullptr, nullptr, { &s_8e656edfb45ba6cf, nullptr, bd_8e656edfb45ba6cf, 0, sizeof(bd_8e656edfb45ba6cf) / sizeof(bd_8e656edfb45ba6cf[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<32> b_b46a779beaf3384e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 78, 56, 243, 234, 155, 119, 106, 180, + 24, 0, 0, 0, 1, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 3, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 46, + 117, 103, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 117, 103, 102, 111, 111, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b46a779beaf3384e = b_b46a779beaf3384e.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_b46a779beaf3384e[] = { + &s_9d5b8cd8de9922eb, +}; +static const uint16_t m_b46a779beaf3384e[] = {0}; +static const uint16_t i_b46a779beaf3384e[] = {0}; +const ::capnp::_::RawSchema s_b46a779beaf3384e = { + 0xb46a779beaf3384e, b_b46a779beaf3384e.words, 32, d_b46a779beaf3384e, m_b46a779beaf3384e, + 1, 1, i_b46a779beaf3384e, nullptr, nullptr, { &s_b46a779beaf3384e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<56> b_a9b2b1f52dde845d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 23, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 87, + 114, 97, 112, 112, 101, 114, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 118, 97, 108, 117, 101, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 70, 111, 111, 0, 0, 0, 0, 0, + 66, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a9b2b1f52dde845d = b_a9b2b1f52dde845d.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a9b2b1f52dde845d[] = { + &s_9d5b8cd8de9922eb, +}; +static const uint16_t m_a9b2b1f52dde845d[] = {0}; +static const uint16_t i_a9b2b1f52dde845d[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_a9b2b1f52dde845d[] = { + { 16777216, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_a9b2b1f52dde845d = { + 0xa9b2b1f52dde845d, b_a9b2b1f52dde845d.words, 56, d_a9b2b1f52dde845d, m_a9b2b1f52dde845d, + 1, 1, i_a9b2b1f52dde845d, nullptr, nullptr, { &s_a9b2b1f52dde845d, nullptr, bd_a9b2b1f52dde845d, 0, sizeof(bd_a9b2b1f52dde845d) / sizeof(bd_a9b2b1f52dde845d[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<51> b_f28f83667a557a04 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 4, 122, 85, 122, 102, 131, 143, 242, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 2, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 87, + 114, 97, 112, 112, 101, 114, 50, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 118, 97, 108, 117, 101, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f28f83667a557a04 = b_f28f83667a557a04.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_f28f83667a557a04[] = { + &s_a9b2b1f52dde845d, +}; +static const uint16_t m_f28f83667a557a04[] = {0}; +static const uint16_t i_f28f83667a557a04[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_f28f83667a557a04[] = { + { 16777216, ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_f28f83667a557a04 = { + 0xf28f83667a557a04, b_f28f83667a557a04.words, 51, d_f28f83667a557a04, m_f28f83667a557a04, + 1, 1, i_f28f83667a557a04, nullptr, nullptr, { &s_f28f83667a557a04, nullptr, bd_f28f83667a557a04, 0, sizeof(bd_f28f83667a557a04) / sizeof(bd_f28f83667a557a04[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<52> b_8b9717a3f8d85a9a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 154, 90, 216, 248, 163, 23, 151, 139, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 71, 0, 0, 0, + 161, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 109, 112, 108, 105, 99, 105, 116, 77, + 101, 116, 104, 111, 100, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 134, 196, 189, 84, 175, 140, 63, 248, + 235, 34, 153, 222, 216, 140, 91, 157, + 17, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 77, 0, 0, 0, 23, 0, 0, 0, + 99, 97, 108, 108, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 84, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_8b9717a3f8d85a9a = b_8b9717a3f8d85a9a.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8b9717a3f8d85a9a[] = { + &s_9d5b8cd8de9922eb, + &s_f83f8caf54bdc486, +}; +static const uint16_t m_8b9717a3f8d85a9a[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_8b9717a3f8d85a9a[] = { + { 50331648, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_8b9717a3f8d85a9a = { + 0x8b9717a3f8d85a9a, b_8b9717a3f8d85a9a.words, 52, d_8b9717a3f8d85a9a, m_8b9717a3f8d85a9a, + 2, 1, nullptr, nullptr, nullptr, { &s_8b9717a3f8d85a9a, nullptr, bd_8b9717a3f8d85a9a, 0, sizeof(bd_8b9717a3f8d85a9a) / sizeof(bd_8b9717a3f8d85a9a[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<54> b_f83f8caf54bdc486 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 134, 196, 189, 84, 175, 140, 63, 248, + 36, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 130, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 0, 0, 0, 23, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 109, 112, 108, 105, 99, 105, 116, 77, + 101, 116, 104, 111, 100, 80, 97, 114, + 97, 109, 115, 46, 99, 97, 108, 108, + 36, 80, 97, 114, 97, 109, 115, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 134, 196, 189, 84, 175, 140, 63, 248, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 134, 196, 189, 84, 175, 140, 63, 248, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 84, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f83f8caf54bdc486 = b_f83f8caf54bdc486.words; +#if !CAPNP_LITE +static const uint16_t m_f83f8caf54bdc486[] = {1, 0}; +static const uint16_t i_f83f8caf54bdc486[] = {0, 1}; +const ::capnp::_::RawSchema s_f83f8caf54bdc486 = { + 0xf83f8caf54bdc486, b_f83f8caf54bdc486.words, 54, nullptr, m_f83f8caf54bdc486, + 0, 2, i_f83f8caf54bdc486, nullptr, nullptr, { &s_f83f8caf54bdc486, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<61> b_df9ccdeb81a704c9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 201, 4, 167, 129, 235, 205, 156, 223, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 71, 0, 0, 0, + 185, 0, 0, 0, 7, 0, 0, 0, + 185, 0, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 109, 112, 108, 105, 99, 105, 116, 77, + 101, 116, 104, 111, 100, 80, 97, 114, + 97, 109, 115, 73, 110, 71, 101, 110, + 101, 114, 105, 99, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 30, 215, 8, 200, 37, 142, 171, 154, + 235, 34, 153, 222, 216, 140, 91, 157, + 17, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 1, 0, + 28, 0, 0, 0, 0, 0, 1, 0, + 97, 0, 0, 0, 23, 0, 0, 0, + 99, 97, 108, 108, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 201, 4, 167, 129, 235, 205, 156, 223, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 84, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 86, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_df9ccdeb81a704c9 = b_df9ccdeb81a704c9.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_df9ccdeb81a704c9[] = { + &s_9aab8e25c808d71e, + &s_9d5b8cd8de9922eb, +}; +static const uint16_t m_df9ccdeb81a704c9[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_df9ccdeb81a704c9[] = { + { 33554432, ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric< ::capnp::AnyPointer>::CallParams<>::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_df9ccdeb81a704c9 = { + 0xdf9ccdeb81a704c9, b_df9ccdeb81a704c9.words, 61, d_df9ccdeb81a704c9, m_df9ccdeb81a704c9, + 2, 1, nullptr, nullptr, nullptr, { &s_df9ccdeb81a704c9, nullptr, bd_df9ccdeb81a704c9, 0, sizeof(bd_df9ccdeb81a704c9) / sizeof(bd_df9ccdeb81a704c9[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<56> b_9aab8e25c808d71e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 30, 215, 8, 200, 37, 142, 171, 154, + 45, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 202, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 0, 0, 0, 23, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 109, 112, 108, 105, 99, 105, 116, 77, + 101, 116, 104, 111, 100, 80, 97, 114, + 97, 109, 115, 73, 110, 71, 101, 110, + 101, 114, 105, 99, 46, 99, 97, 108, + 108, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 30, 215, 8, 200, 37, 142, 171, 154, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 30, 215, 8, 200, 37, 142, 171, 154, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 5, 0, 0, 0, 18, 0, 0, 0, + 84, 0, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9aab8e25c808d71e = b_9aab8e25c808d71e.words; +#if !CAPNP_LITE +static const uint16_t m_9aab8e25c808d71e[] = {1, 0}; +static const uint16_t i_9aab8e25c808d71e[] = {0, 1}; +const ::capnp::_::RawSchema s_9aab8e25c808d71e = { + 0x9aab8e25c808d71e, b_9aab8e25c808d71e.words, 56, nullptr, m_9aab8e25c808d71e, + 0, 2, i_9aab8e25c808d71e, nullptr, nullptr, { &s_9aab8e25c808d71e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<53> b_a54870440e919063 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 99, 144, 145, 14, 68, 112, 72, 165, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 234, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 0, 0, 0, 23, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 71, + 101, 110, 101, 114, 105, 99, 115, 85, + 110, 105, 111, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 99, 144, 145, 14, 68, 112, 72, 165, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 99, 144, 145, 14, 68, 112, 72, 165, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 1, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 70, 111, 111, 0, 0, 0, 0, 0, + 66, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a54870440e919063 = b_a54870440e919063.words; +#if !CAPNP_LITE +static const uint16_t m_a54870440e919063[] = {1, 0}; +static const uint16_t i_a54870440e919063[] = {0, 1}; +const ::capnp::_::RawSchema s_a54870440e919063 = { + 0xa54870440e919063, b_a54870440e919063.words, 53, nullptr, m_a54870440e919063, + 0, 2, i_a54870440e919063, nullptr, nullptr, { &s_a54870440e919063, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<1205> b_9427b2a71030338f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 143, 51, 48, 16, 167, 178, 39, 148, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 20, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 33, 0, 0, 0, 31, 0, 0, 0, + 133, 0, 0, 0, 103, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 85, + 115, 101, 71, 101, 110, 101, 114, 105, + 99, 115, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 255, 13, 32, 233, 109, 113, 82, 137, + 4, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 3, 0, 1, 0, + 112, 2, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 2, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 2, 0, 0, 3, 0, 1, 0, + 188, 2, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 2, 0, 0, 3, 0, 1, 0, + 48, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 3, 0, 0, 3, 0, 1, 0, + 56, 3, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 3, 0, 0, 138, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 56, 3, 0, 0, 3, 0, 1, 0, + 116, 3, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 113, 3, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 3, 0, 0, 3, 0, 1, 0, + 192, 3, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 193, 4, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 4, 0, 0, 3, 0, 1, 0, + 20, 5, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 133, 5, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 5, 0, 0, 3, 0, 1, 0, + 144, 5, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 6, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 80, 6, 0, 0, 3, 0, 1, 0, + 164, 6, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 161, 6, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 160, 6, 0, 0, 3, 0, 1, 0, + 244, 6, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 129, 7, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 7, 0, 0, 3, 0, 1, 0, + 140, 7, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 29, 8, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 8, 0, 0, 3, 0, 1, 0, + 40, 8, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 141, 8, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 8, 0, 0, 3, 0, 1, 0, + 224, 8, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 77, 9, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 9, 0, 0, 3, 0, 1, 0, + 160, 9, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 29, 10, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 10, 0, 0, 3, 0, 1, 0, + 168, 10, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 41, 11, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 11, 0, 0, 3, 0, 1, 0, + 164, 11, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 37, 12, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 12, 0, 0, 3, 0, 1, 0, + 48, 12, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 49, 12, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 12, 0, 0, 3, 0, 1, 0, + 148, 12, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 15, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 15, 0, 0, 3, 0, 1, 0, + 96, 15, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 15, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 15, 0, 0, 3, 0, 1, 0, + 232, 15, 0, 0, 2, 0, 1, 0, + 98, 97, 115, 105, 99, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 50, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 39, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 115, 112, 101, 99, 105, 102, + 105, 101, 100, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 115, 112, 101, 99, 105, 102, + 105, 101, 100, 73, 110, 110, 101, 114, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 23, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 102, 97, 117, 108, 116, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 108, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 65, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 102, 97, 117, 108, 116, 73, + 110, 110, 101, 114, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 105, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 100, 101, 102, 97, 117, 108, 116, 85, + 115, 101, 114, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 143, 51, 48, 16, 167, 178, 39, 148, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 20, 0, + 76, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 119, 114, 97, 112, 112, 101, 114, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 102, 97, 117, 108, 116, 87, + 114, 97, 112, 112, 101, 114, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 93, 132, 222, 45, 245, 177, 178, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 65, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 101, 102, 97, 117, 108, 116, 87, + 114, 97, 112, 112, 101, 114, 50, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 4, 122, 85, 122, 102, 131, 143, 242, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 65, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 70, 111, 111, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 73, 110, 110, + 101, 114, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 115, 172, 25, 126, 17, 65, 168, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 73, 110, 110, + 101, 114, 50, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 73, 110, 110, + 101, 114, 50, 66, 105, 110, 100, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 39, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 20, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 34, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 73, 110, 110, + 101, 114, 50, 84, 101, 120, 116, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 53, 212, 214, 24, 177, 66, 171, 169, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 39, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 216, 192, 40, 205, 44, 90, 218, 227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 108, 105, 97, 115, 82, 101, 118, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 42, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 117, 115, 101, 65, 108, 105, 97, 115, + 101, 115, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 207, 166, 91, 180, 223, 110, 101, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, + 20, 0, 0, 0, 6, 0, 20, 0, + 120, 0, 0, 0, 0, 0, 2, 0, + 228, 0, 0, 0, 0, 0, 4, 0, + 96, 1, 0, 0, 0, 0, 4, 0, + 224, 1, 0, 0, 0, 0, 4, 0, + 97, 2, 0, 0, 28, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 34, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 101, 110, 101, 114, 105, 99, 67, + 97, 112, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 55, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 92, 218, 84, 221, 232, 73, 231, 201, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 23, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 39, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9427b2a71030338f = b_9427b2a71030338f.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_9427b2a71030338f[] = { + &s_8e656edfb45ba6cf, + &s_9427b2a71030338f, + &s_9d5b8cd8de9922eb, + &s_a0a8f314b80b63fd, + &s_a9ab42b118d6d435, + &s_a9b2b1f52dde845d, + &s_c9e749e8dd54da5c, + &s_f28f83667a557a04, + &s_f6a841117e19ac73, +}; +static const uint16_t m_9427b2a71030338f[] = {11, 12, 13, 14, 15, 16, 0, 18, 5, 6, 7, 9, 10, 19, 1, 2, 3, 4, 17, 8}; +static const uint16_t i_9427b2a71030338f[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_9427b2a71030338f[] = { + { 16777216, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::_capnpPrivate::brand() }, + { 16777217, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::_capnpPrivate::brand() }, + { 16777218, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 16777220, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 16777221, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::_capnpPrivate::brand() }, + { 16777222, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::_capnpPrivate::brand() }, + { 16777224, ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::_capnpPrivate::brand() }, + { 16777225, ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::_capnpPrivate::brand() }, + { 16777228, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::_capnpPrivate::brand() }, + { 16777229, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::_capnpPrivate::brand() }, + { 16777230, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::_capnpPrivate::brand() }, + { 16777231, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 16777233, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::_capnpPrivate::brand() }, + { 16777234, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::_capnpPrivate::brand() }, + { 16777235, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_9427b2a71030338f = { + 0x9427b2a71030338f, b_9427b2a71030338f.words, 1205, d_9427b2a71030338f, m_9427b2a71030338f, + 9, 20, i_9427b2a71030338f, nullptr, nullptr, { &s_9427b2a71030338f, nullptr, bd_9427b2a71030338f, 0, sizeof(bd_9427b2a71030338f) / sizeof(bd_9427b2a71030338f[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_c5598844441096dc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 220, 150, 16, 68, 68, 136, 89, 197, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 109, 112, 116, 121, 83, 116, 114, 117, + 99, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_c5598844441096dc = b_c5598844441096dc.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c5598844441096dc = { + 0xc5598844441096dc, b_c5598844441096dc.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c5598844441096dc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<147> b_abed745cd8c92095 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 1, 0, 1, 0, + 135, 113, 32, 5, 152, 64, 87, 214, + 249, 0, 0, 0, 82, 0, 0, 0, + 101, 17, 132, 189, 14, 177, 229, 187, + 249, 0, 0, 0, 82, 0, 0, 0, + 134, 237, 173, 160, 96, 135, 191, 228, + 249, 0, 0, 0, 82, 0, 0, 0, + 171, 140, 225, 103, 210, 254, 71, 151, + 249, 0, 0, 0, 90, 0, 0, 0, + 43, 216, 158, 174, 64, 76, 121, 144, + 249, 0, 0, 0, 90, 0, 0, 0, + 107, 243, 255, 157, 144, 76, 131, 193, + 249, 0, 0, 0, 90, 0, 0, 0, + 114, 8, 206, 27, 204, 10, 158, 139, + 249, 0, 0, 0, 90, 0, 0, 0, + 82, 210, 79, 171, 46, 36, 44, 163, + 249, 0, 0, 0, 98, 0, 0, 0, + 213, 57, 70, 193, 47, 71, 197, 185, + 249, 0, 0, 0, 98, 0, 0, 0, + 187, 188, 29, 186, 118, 134, 231, 170, + 249, 0, 0, 0, 98, 0, 0, 0, + 204, 36, 44, 148, 248, 97, 86, 162, + 249, 0, 0, 0, 106, 0, 0, 0, + 72, 92, 178, 177, 186, 148, 33, 219, + 249, 0, 0, 0, 106, 0, 0, 0, + 38, 200, 52, 204, 190, 232, 70, 243, + 249, 0, 0, 0, 82, 0, 0, 0, + 253, 120, 91, 197, 103, 252, 164, 170, + 249, 0, 0, 0, 82, 0, 0, 0, + 122, 21, 241, 75, 65, 212, 55, 237, + 249, 0, 0, 0, 98, 0, 0, 0, + 250, 135, 54, 11, 235, 96, 161, 246, + 249, 0, 0, 0, 82, 0, 0, 0, + 252, 240, 124, 101, 46, 28, 32, 227, + 249, 0, 0, 0, 114, 0, 0, 0, + 220, 140, 16, 78, 200, 16, 24, 206, + 249, 0, 0, 0, 114, 0, 0, 0, + 226, 62, 183, 149, 88, 191, 88, 255, + 249, 0, 0, 0, 114, 0, 0, 0, + 9, 138, 132, 21, 154, 68, 69, 161, + 249, 0, 0, 0, 122, 0, 0, 0, + 13, 191, 180, 182, 67, 167, 103, 165, + 249, 0, 0, 0, 122, 0, 0, 0, + 33, 80, 148, 245, 138, 235, 135, 217, + 249, 0, 0, 0, 122, 0, 0, 0, + 5, 168, 255, 178, 126, 248, 85, 158, + 249, 0, 0, 0, 122, 0, 0, 0, + 76, 127, 83, 215, 71, 17, 77, 254, + 249, 0, 0, 0, 130, 0, 0, 0, + 211, 117, 19, 84, 212, 24, 2, 144, + 249, 0, 0, 0, 130, 0, 0, 0, + 215, 108, 242, 134, 164, 215, 109, 210, + 249, 0, 0, 0, 130, 0, 0, 0, + 101, 160, 128, 133, 19, 117, 184, 254, + 249, 0, 0, 0, 138, 0, 0, 0, + 18, 178, 186, 172, 20, 165, 21, 168, + 253, 0, 0, 0, 138, 0, 0, 0, + 3, 134, 131, 124, 83, 219, 86, 236, + 1, 1, 0, 0, 114, 0, 0, 0, + 88, 20, 50, 182, 93, 120, 104, 196, + 1, 1, 0, 0, 114, 0, 0, 0, + 237, 186, 251, 212, 211, 148, 249, 209, + 1, 1, 0, 0, 130, 0, 0, 0, + 25, 80, 253, 71, 215, 96, 8, 195, + 1, 1, 0, 0, 114, 0, 0, 0, + 118, 111, 105, 100, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 56, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 49, 54, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 51, 50, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 54, 52, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 116, 101, 120, 116, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 117, 105, 110, 116, 56, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 117, 105, 110, 116, 49, 54, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 117, 105, 110, 116, 51, 50, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 117, 105, 110, 116, 54, 52, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, } +}; +::capnp::word const* const bp_abed745cd8c92095 = b_abed745cd8c92095.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_abed745cd8c92095 = { + 0xabed745cd8c92095, b_abed745cd8c92095.words, 147, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_abed745cd8c92095, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_d657409805207187 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 135, 113, 32, 5, 152, 64, 87, 214, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 118, 111, 105, 100, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d657409805207187 = b_d657409805207187.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d657409805207187 = { + 0xd657409805207187, b_d657409805207187.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d657409805207187, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_bbe5b10ebd841165 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 101, 17, 132, 189, 14, 177, 229, 187, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 98, 111, 111, 108, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_bbe5b10ebd841165 = b_bbe5b10ebd841165.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_bbe5b10ebd841165 = { + 0xbbe5b10ebd841165, b_bbe5b10ebd841165.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_bbe5b10ebd841165, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_e4bf8760a0aded86 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 134, 237, 173, 160, 96, 135, 191, 228, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 56, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 133, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e4bf8760a0aded86 = b_e4bf8760a0aded86.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_e4bf8760a0aded86 = { + 0xe4bf8760a0aded86, b_e4bf8760a0aded86.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_e4bf8760a0aded86, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_9747fed267e18cab = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 171, 140, 225, 103, 210, 254, 71, 151, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 49, 54, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 199, 207, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9747fed267e18cab = b_9747fed267e18cab.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9747fed267e18cab = { + 0x9747fed267e18cab, b_9747fed267e18cab.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9747fed267e18cab, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_90794c40ae9ed82b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 43, 216, 158, 174, 64, 76, 121, 144, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 51, 50, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 178, 158, 67, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_90794c40ae9ed82b = b_90794c40ae9ed82b.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_90794c40ae9ed82b = { + 0x90794c40ae9ed82b, b_90794c40ae9ed82b.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_90794c40ae9ed82b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_c1834c909dfff36b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 107, 243, 255, 157, 144, 76, 131, 193, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 54, 52, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 135, 32, 242, 121, 183, 143, 255, 255, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c1834c909dfff36b = b_c1834c909dfff36b.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c1834c909dfff36b = { + 0xc1834c909dfff36b, b_c1834c909dfff36b.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c1834c909dfff36b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_8b9e0acc1bce0872 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 114, 8, 206, 27, 204, 10, 158, 139, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 56, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 234, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8b9e0acc1bce0872 = b_8b9e0acc1bce0872.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8b9e0acc1bce0872 = { + 0x8b9e0acc1bce0872, b_8b9e0acc1bce0872.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8b9e0acc1bce0872, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_a32c242eab4fd252 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 82, 210, 79, 171, 46, 36, 44, 163, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 49, 54, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 110, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a32c242eab4fd252 = b_a32c242eab4fd252.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a32c242eab4fd252 = { + 0xa32c242eab4fd252, b_a32c242eab4fd252.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a32c242eab4fd252, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_b9c5472fc14639d5 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 213, 57, 70, 193, 47, 71, 197, 185, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 51, 50, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 20, 106, 10, 206, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b9c5472fc14639d5 = b_b9c5472fc14639d5.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_b9c5472fc14639d5 = { + 0xb9c5472fc14639d5, b_b9c5472fc14639d5.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_b9c5472fc14639d5, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_aae78676ba1dbcbb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 187, 188, 29, 186, 118, 134, 231, 170, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 54, 52, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 210, 10, 31, 235, 140, 169, 84, 171, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_aae78676ba1dbcbb = b_aae78676ba1dbcbb.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_aae78676ba1dbcbb = { + 0xaae78676ba1dbcbb, b_aae78676ba1dbcbb.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_aae78676ba1dbcbb, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_a25661f8942c24cc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 204, 36, 44, 148, 248, 97, 86, 162, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 102, 108, 111, 97, 116, 51, 50, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 80, 154, 68, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a25661f8942c24cc = b_a25661f8942c24cc.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a25661f8942c24cc = { + 0xa25661f8942c24cc, b_a25661f8942c24cc.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a25661f8942c24cc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_db2194bab1b25c48 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 72, 92, 178, 177, 186, 148, 33, 219, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 102, 108, 111, 97, 116, 54, 52, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 187, 224, 192, 130, 139, 181, 201, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_db2194bab1b25c48 = b_db2194bab1b25c48.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_db2194bab1b25c48 = { + 0xdb2194bab1b25c48, b_db2194bab1b25c48.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_db2194bab1b25c48, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<26> b_f346e8becc34c826 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 38, 200, 52, 204, 190, 232, 70, 243, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 116, 101, 120, 116, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f346e8becc34c826 = b_f346e8becc34c826.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f346e8becc34c826 = { + 0xf346e8becc34c826, b_f346e8becc34c826.words, 26, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f346e8becc34c826, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<26> b_aaa4fc67c55b78fd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 253, 120, 91, 197, 103, 252, 164, 170, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 100, 97, 116, 97, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_aaa4fc67c55b78fd = b_aaa4fc67c55b78fd.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_aaa4fc67c55b78fd = { + 0xaaa4fc67c55b78fd, b_aaa4fc67c55b78fd.words, 26, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_aaa4fc67c55b78fd, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<232> b_ed37d4414bf1157a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 122, 21, 241, 75, 65, 212, 55, 237, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 115, 116, 114, 117, 99, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, } +}; +::capnp::word const* const bp_ed37d4414bf1157a = b_ed37d4414bf1157a.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ed37d4414bf1157a = { + 0xed37d4414bf1157a, b_ed37d4414bf1157a.words, 232, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ed37d4414bf1157a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_f6a160eb0b3687fa = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 250, 135, 54, 11, 235, 96, 161, 246, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 101, 110, 117, 109, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f6a160eb0b3687fa = b_f6a160eb0b3687fa.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f6a160eb0b3687fa = { + 0xf6a160eb0b3687fa, b_f6a160eb0b3687fa.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f6a160eb0b3687fa, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<29> b_e3201c2e657cf0fc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 252, 240, 124, 101, 46, 28, 32, 227, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 118, 111, 105, 100, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 48, 0, 0, 0, } +}; +::capnp::word const* const bp_e3201c2e657cf0fc = b_e3201c2e657cf0fc.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_e3201c2e657cf0fc = { + 0xe3201c2e657cf0fc, b_e3201c2e657cf0fc.words, 29, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_e3201c2e657cf0fc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_ce1810c84e108cdc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 220, 140, 16, 78, 200, 16, 24, 206, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 98, 111, 111, 108, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 33, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ce1810c84e108cdc = b_ce1810c84e108cdc.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ce1810c84e108cdc = { + 0xce1810c84e108cdc, b_ce1810c84e108cdc.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ce1810c84e108cdc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_ff58bf5895b73ee2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 226, 62, 183, 149, 88, 191, 88, 255, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 56, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 145, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ff58bf5895b73ee2 = b_ff58bf5895b73ee2.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ff58bf5895b73ee2 = { + 0xff58bf5895b73ee2, b_ff58bf5895b73ee2.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ff58bf5895b73ee2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_a145449a15848a09 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 9, 138, 132, 21, 154, 68, 69, 161, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 49, 54, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a145449a15848a09 = b_a145449a15848a09.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a145449a15848a09 = { + 0xa145449a15848a09, b_a145449a15848a09.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a145449a15848a09, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_a567a743b6b4bf0d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 13, 191, 180, 182, 67, 167, 103, 165, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 51, 50, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 20, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, } +}; +::capnp::word const* const bp_a567a743b6b4bf0d = b_a567a743b6b4bf0d.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a567a743b6b4bf0d = { + 0xa567a743b6b4bf0d, b_a567a743b6b4bf0d.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a567a743b6b4bf0d, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<31> b_d987eb8af5945021 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 33, 80, 148, 245, 138, 235, 135, 217, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 105, 110, 116, 54, 52, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 21, 0, 0, 0, + 199, 113, 196, 43, 171, 117, 107, 15, + 57, 142, 59, 212, 84, 138, 148, 240, } +}; +::capnp::word const* const bp_d987eb8af5945021 = b_d987eb8af5945021.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d987eb8af5945021 = { + 0xd987eb8af5945021, b_d987eb8af5945021.words, 31, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d987eb8af5945021, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_9e55f87eb2ffa805 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 5, 168, 255, 178, 126, 248, 85, 158, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 56, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 222, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9e55f87eb2ffa805 = b_9e55f87eb2ffa805.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9e55f87eb2ffa805 = { + 0x9e55f87eb2ffa805, b_9e55f87eb2ffa805.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9e55f87eb2ffa805, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<31> b_fe4d1147d7537f4c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 76, 127, 83, 215, 71, 17, 77, 254, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 49, 54, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 53, 130, 156, 173, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fe4d1147d7537f4c = b_fe4d1147d7537f4c.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_fe4d1147d7537f4c = { + 0xfe4d1147d7537f4c, b_fe4d1147d7537f4c.words, 31, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_fe4d1147d7537f4c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<31> b_900218d4541375d3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 211, 117, 19, 84, 212, 24, 2, 144, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 51, 50, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 85, 161, 174, 198, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_900218d4541375d3 = b_900218d4541375d3.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_900218d4541375d3 = { + 0x900218d4541375d3, b_900218d4541375d3.words, 31, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_900218d4541375d3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<31> b_d26dd7a486f26cd7 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 215, 108, 242, 134, 164, 215, 109, 210, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 117, 105, 110, 116, 54, 52, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 199, 113, 172, 181, 175, 152, 50, 154, } +}; +::capnp::word const* const bp_d26dd7a486f26cd7 = b_d26dd7a486f26cd7.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d26dd7a486f26cd7 = { + 0xd26dd7a486f26cd7, b_d26dd7a486f26cd7.words, 31, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d26dd7a486f26cd7, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<32> b_feb875138580a065 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 101, 160, 128, 133, 19, 117, 184, 254, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 102, 108, 111, 97, 116, 51, 50, + 76, 105, 115, 116, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 36, 0, 0, 0, + 0, 156, 173, 69, 0, 0, 128, 127, + 0, 0, 128, 255, 0, 0, 192, 127, } +}; +::capnp::word const* const bp_feb875138580a065 = b_feb875138580a065.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_feb875138580a065 = { + 0xfeb875138580a065, b_feb875138580a065.words, 32, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_feb875138580a065, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_a815a514acbab212 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 18, 178, 186, 172, 20, 165, 21, 168, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 102, 108, 111, 97, 116, 54, 52, + 76, 105, 115, 116, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 192, 97, 190, 64, + 0, 0, 0, 0, 0, 0, 240, 127, + 0, 0, 0, 0, 0, 0, 240, 255, + 0, 0, 0, 0, 0, 0, 248, 127, } +}; +::capnp::word const* const bp_a815a514acbab212 = b_a815a514acbab212.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a815a514acbab212 = { + 0xa815a514acbab212, b_a815a514acbab212.words, 34, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a815a514acbab212, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_ec56db537c838603 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 3, 134, 131, 124, 83, 219, 86, 236, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 116, 101, 120, 116, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 116, 104, 117, 100, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ec56db537c838603 = b_ec56db537c838603.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ec56db537c838603 = { + 0xec56db537c838603, b_ec56db537c838603.words, 35, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ec56db537c838603, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<36> b_c468785db6321458 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 88, 20, 50, 182, 93, 120, 104, 196, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 100, 97, 116, 97, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 9, 0, 0, 0, 74, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 111, 111, 112, 115, 0, 0, 0, 0, + 101, 120, 104, 97, 117, 115, 116, 101, + 100, 0, 0, 0, 0, 0, 0, 0, + 114, 102, 99, 51, 48, 57, 50, 0, } +}; +::capnp::word const* const bp_c468785db6321458 = b_c468785db6321458.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c468785db6321458 = { + 0xc468785db6321458, b_c468785db6321458.words, 36, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c468785db6321458, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<115> b_d1f994d3d4fbbaed = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 237, 186, 251, 212, 211, 148, 249, 209, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 115, 116, 114, 117, 99, 116, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 119, 2, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d1f994d3d4fbbaed = b_d1f994d3d4fbbaed.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d1f994d3d4fbbaed = { + 0xd1f994d3d4fbbaed, b_d1f994d3d4fbbaed.words, 115, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d1f994d3d4fbbaed, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_c30860d747fd5019 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 25, 80, 253, 71, 215, 96, 8, 195, + 25, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 60, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 115, 116, 97, 110, 116, 115, + 46, 101, 110, 117, 109, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c30860d747fd5019 = b_c30860d747fd5019.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c30860d747fd5019 = { + 0xc30860d747fd5019, b_c30860d747fd5019.words, 30, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c30860d747fd5019, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<23> b_ca4028a84b8fc2ed = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 237, 194, 143, 75, 168, 40, 64, 202, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 103, 108, 111, 98, 97, + 108, 73, 110, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 57, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ca4028a84b8fc2ed = b_ca4028a84b8fc2ed.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ca4028a84b8fc2ed = { + 0xca4028a84b8fc2ed, b_ca4028a84b8fc2ed.words, 23, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ca4028a84b8fc2ed, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<24> b_d81b65e268fb3f34 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 52, 63, 251, 104, 226, 101, 27, 216, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 103, 108, 111, 98, 97, + 108, 84, 101, 120, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, 0, 0, + 102, 111, 111, 98, 97, 114, 0, 0, } +}; +::capnp::word const* const bp_d81b65e268fb3f34 = b_d81b65e268fb3f34.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d81b65e268fb3f34 = { + 0xd81b65e268fb3f34, b_d81b65e268fb3f34.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d81b65e268fb3f34, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_bd579b448bfbcc7b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 123, 204, 251, 139, 68, 155, 87, 189, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 103, 108, 111, 98, 97, + 108, 83, 116, 114, 117, 99, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 49, 212, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_bd579b448bfbcc7b = b_bd579b448bfbcc7b.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_bd579b448bfbcc7b = { + 0xbd579b448bfbcc7b, b_bd579b448bfbcc7b.words, 49, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_bd579b448bfbcc7b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<28> b_a00141d482942422 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 34, 36, 148, 130, 212, 65, 1, 160, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 3, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 103, 108, 111, 98, 97, + 108, 80, 114, 105, 110, 116, 97, 98, + 108, 101, 83, 116, 114, 117, 99, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 60, 124, 9, 157, 129, 151, 196, 222, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a00141d482942422 = b_a00141d482942422.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a00141d482942422 = { + 0xa00141d482942422, b_a00141d482942422.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a00141d482942422, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<344> b_a4764c3483341eeb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 235, 30, 52, 131, 52, 76, 118, 164, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 3, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 100, 101, 114, 105, 118, + 101, 100, 67, 111, 110, 115, 116, 97, + 110, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 3, 0, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 3, 0, 0, 119, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a4764c3483341eeb = b_a4764c3483341eeb.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a4764c3483341eeb = { + 0xa4764c3483341eeb, b_a4764c3483341eeb.words, 344, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a4764c3483341eeb, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<107> b_b70341f0dafa28ef = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 239, 40, 250, 218, 240, 65, 3, 183, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 3, 0, 1, 0, + 112, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 103, 101, 110, 101, 114, + 105, 99, 67, 111, 110, 115, 116, 97, + 110, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 235, 34, 153, 222, 216, 140, 91, 157, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 39, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 108, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 65, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b70341f0dafa28ef = b_b70341f0dafa28ef.words; +#if !CAPNP_LITE +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_b70341f0dafa28ef[] = { + { 83886080, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_b70341f0dafa28ef = { + 0xb70341f0dafa28ef, b_b70341f0dafa28ef.words, 107, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_b70341f0dafa28ef, nullptr, bd_b70341f0dafa28ef, 0, sizeof(bd_b70341f0dafa28ef) / sizeof(bd_b70341f0dafa28ef[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<127> b_d7c0fea759d6a0cf = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 207, 160, 214, 89, 167, 254, 192, 215, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 101, 109, 98, 101, 100, + 100, 101, 100, 68, 97, 116, 97, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 250, 25, 0, 0, + 48, 95, 1, 80, 6, 20, 255, 1, + 133, 199, 207, 178, 158, 67, 255, 3, + 135, 32, 242, 121, 183, 143, 255, 255, + 234, 0, 110, 178, 20, 106, 10, 206, + 210, 10, 31, 235, 140, 169, 84, 171, + 30, 80, 154, 68, 5, 254, 187, 224, + 192, 130, 139, 181, 201, 17, 77, 34, + 17, 77, 26, 81, 76, 6, 20, 19, + 133, 3, 48, 19, 129, 3, 33, 19, + 129, 3, 18, 19, 129, 3, 19, 19, + 129, 3, 20, 19, 129, 3, 21, 19, + 133, 3, 18, 19, 133, 3, 19, 19, + 133, 3, 12, 19, 133, 3, 13, 19, + 133, 3, 36, 19, 137, 3, 37, 19, + 149, 3, 30, 19, 169, 3, 30, 51, + 193, 3, 119, 2, 19, 17, 5, 19, + 0, 0, 7, 102, 111, 111, 7, 98, + 97, 114, 255, 1, 244, 128, 13, 14, + 16, 76, 251, 0, 63, 78, 115, 232, + 56, 166, 51, 253, 90, 210, 4, 20, + 136, 98, 3, 255, 210, 10, 111, 18, + 33, 25, 204, 4, 0, 31, 95, 112, + 9, 175, 2, 224, 144, 117, 64, 17, + 77, 34, 17, 77, 26, 81, 76, 6, + 20, 19, 37, 1, 24, 19, 33, 1, + 41, 19, 33, 1, 34, 19, 33, 1, + 35, 19, 33, 1, 36, 19, 37, 1, + 37, 19, 49, 1, 34, 19, 49, 1, + 35, 19, 49, 1, 36, 19, 53, 1, + 37, 19, 65, 1, 52, 19, 73, 1, + 53, 19, 93, 1, 30, 19, 113, 1, + 30, 51, 133, 1, 119, 2, 19, 213, + 2, 27, 0, 0, 7, 98, 97, 122, + 7, 113, 117, 120, 0, 5, 17, 77, + 58, 0, 0, 81, 72, 6, 20, 0, + 16, 63, 110, 101, 115, 116, 101, 100, + 0, 5, 17, 77, 114, 0, 18, 255, + 114, 101, 97, 108, 108, 121, 32, 110, + 0, 31, 101, 115, 116, 101, 100, 1, + 26, 15, 12, 222, 128, 127, 239, 210, + 4, 210, 233, 128, 255, 127, 247, 78, + 97, 188, 64, 211, 160, 250, 248, 128, + 255, 255, 255, 127, 63, 121, 223, 13, + 134, 72, 112, 255, 46, 117, 19, 253, + 138, 150, 253, 255, 0, 128, 128, 255, + 255, 255, 255, 255, 255, 255, 255, 127, + 0, 11, 12, 34, 255, 207, 210, 4, + 46, 22, 255, 255, 247, 78, 97, 188, + 192, 44, 95, 5, 240, 255, 255, 255, + 255, 63, 121, 223, 13, 134, 72, 112, + 127, 210, 138, 236, 2, 117, 105, 2, + 0, 0, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 0, 240, 56, 180, 150, + 73, 255, 194, 189, 240, 124, 194, 189, + 240, 252, 1, 234, 28, 8, 2, 234, + 28, 8, 130, 0, 0, 255, 64, 222, + 119, 131, 33, 18, 220, 66, 4, 41, + 144, 35, 202, 229, 200, 118, 127, 41, + 144, 35, 202, 229, 200, 118, 255, 145, + 247, 80, 55, 158, 120, 102, 0, 145, + 247, 80, 55, 158, 120, 102, 128, 17, + 9, 42, 17, 9, 50, 17, 9, 58, + 15, 113, 117, 117, 120, 31, 99, 111, + 114, 103, 101, 63, 103, 114, 97, 117, + 108, 116, 17, 9, 50, 17, 9, 42, + 17, 9, 34, 63, 103, 97, 114, 112, + 108, 121, 31, 119, 97, 108, 100, 111, + 15, 102, 114, 101, 100, 81, 12, 6, + 20, 0, 5, 19, 29, 1, 122, 0, + 24, 17, 189, 122, 0, 24, 17, 93, + 122, 0, 18, 255, 120, 32, 115, 116, + 114, 117, 99, 116, 0, 63, 108, 105, + 115, 116, 32, 49, 255, 120, 32, 115, + 116, 114, 117, 99, 116, 0, 63, 108, + 105, 115, 116, 32, 50, 255, 120, 32, + 115, 116, 114, 117, 99, 116, 0, 63, + 108, 105, 115, 116, 32, 51, 21, 3, + 1, 6, 1, 9, 3, 111, 145, 15, + 103, 43, 153, 212, 255, 199, 107, 159, + 6, 57, 148, 96, 249, 2, 199, 113, + 196, 43, 171, 117, 107, 15, 57, 142, + 59, 212, 84, 138, 148, 240, 3, 111, + 222, 15, 53, 130, 156, 173, 15, 85, + 161, 174, 198, 255, 199, 113, 172, 181, + 175, 152, 50, 154, 0, 206, 156, 173, + 69, 128, 127, 204, 128, 255, 192, 127, + 240, 192, 97, 190, 64, 192, 240, 127, + 192, 240, 255, 192, 248, 127, 17, 9, + 50, 17, 9, 50, 17, 9, 42, 31, + 112, 108, 117, 103, 104, 31, 120, 121, + 122, 122, 121, 15, 116, 104, 117, 100, + 17, 9, 34, 17, 9, 74, 17, 13, + 58, 15, 111, 111, 112, 115, 255, 101, + 120, 104, 97, 117, 115, 116, 101, 0, + 1, 100, 127, 114, 102, 99, 51, 48, + 57, 50, 81, 12, 6, 20, 0, 5, + 19, 29, 1, 106, 0, 24, 17, 189, + 106, 0, 24, 17, 93, 106, 0, 18, + 255, 115, 116, 114, 117, 99, 116, 108, + 105, 0, 15, 115, 116, 32, 49, 255, + 115, 116, 114, 117, 99, 116, 108, 105, + 0, 15, 115, 116, 32, 50, 255, 115, + 116, 114, 117, 99, 116, 108, 105, 0, + 15, 115, 116, 32, 51, 4, 7, 0, } +}; +::capnp::word const* const bp_d7c0fea759d6a0cf = b_d7c0fea759d6a0cf.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d7c0fea759d6a0cf = { + 0xd7c0fea759d6a0cf, b_d7c0fea759d6a0cf.words, 127, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d7c0fea759d6a0cf, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<553> b_8e59556fb309253f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 63, 37, 9, 179, 111, 85, 89, 142, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 101, 109, 98, 101, 100, + 100, 101, 100, 84, 101, 120, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 98, 132, 0, 0, + 40, 118, 111, 105, 100, 70, 105, 101, + 108, 100, 32, 61, 32, 118, 111, 105, + 100, 44, 32, 98, 111, 111, 108, 70, + 105, 101, 108, 100, 32, 61, 32, 116, + 114, 117, 101, 44, 32, 105, 110, 116, + 56, 70, 105, 101, 108, 100, 32, 61, + 32, 45, 49, 50, 51, 44, 32, 105, + 110, 116, 49, 54, 70, 105, 101, 108, + 100, 32, 61, 32, 45, 49, 50, 51, + 52, 53, 44, 32, 105, 110, 116, 51, + 50, 70, 105, 101, 108, 100, 32, 61, + 32, 45, 49, 50, 51, 52, 53, 54, + 55, 56, 44, 32, 105, 110, 116, 54, + 52, 70, 105, 101, 108, 100, 32, 61, + 32, 45, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 48, 49, 50, 51, 52, + 53, 44, 32, 117, 73, 110, 116, 56, + 70, 105, 101, 108, 100, 32, 61, 32, + 50, 51, 52, 44, 32, 117, 73, 110, + 116, 49, 54, 70, 105, 101, 108, 100, + 32, 61, 32, 52, 53, 54, 55, 56, + 44, 32, 117, 73, 110, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 51, 52, 53, 54, 55, 56, 57, 48, + 49, 50, 44, 32, 117, 73, 110, 116, + 54, 52, 70, 105, 101, 108, 100, 32, + 61, 32, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 48, 44, 32, + 102, 108, 111, 97, 116, 51, 50, 70, + 105, 101, 108, 100, 32, 61, 32, 49, + 50, 51, 52, 46, 53, 44, 32, 102, + 108, 111, 97, 116, 54, 52, 70, 105, + 101, 108, 100, 32, 61, 32, 45, 49, + 46, 50, 51, 101, 52, 55, 44, 32, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 32, 61, 32, 34, 102, 111, 111, + 34, 44, 32, 100, 97, 116, 97, 70, + 105, 101, 108, 100, 32, 61, 32, 34, + 98, 97, 114, 34, 44, 32, 115, 116, + 114, 117, 99, 116, 70, 105, 101, 108, + 100, 32, 61, 32, 40, 118, 111, 105, + 100, 70, 105, 101, 108, 100, 32, 61, + 32, 118, 111, 105, 100, 44, 32, 98, + 111, 111, 108, 70, 105, 101, 108, 100, + 32, 61, 32, 116, 114, 117, 101, 44, + 32, 105, 110, 116, 56, 70, 105, 101, + 108, 100, 32, 61, 32, 45, 49, 50, + 44, 32, 105, 110, 116, 49, 54, 70, + 105, 101, 108, 100, 32, 61, 32, 51, + 52, 53, 54, 44, 32, 105, 110, 116, + 51, 50, 70, 105, 101, 108, 100, 32, + 61, 32, 45, 55, 56, 57, 48, 49, + 50, 51, 52, 44, 32, 105, 110, 116, + 54, 52, 70, 105, 101, 108, 100, 32, + 61, 32, 53, 54, 55, 56, 57, 48, + 49, 50, 51, 52, 53, 54, 55, 56, + 44, 32, 117, 73, 110, 116, 56, 70, + 105, 101, 108, 100, 32, 61, 32, 57, + 48, 44, 32, 117, 73, 110, 116, 49, + 54, 70, 105, 101, 108, 100, 32, 61, + 32, 49, 50, 51, 52, 44, 32, 117, + 73, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 53, 54, 55, + 56, 57, 48, 49, 50, 44, 32, 117, + 73, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 32, 61, 32, 51, 52, 53, + 54, 55, 56, 57, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 48, 44, + 32, 102, 108, 111, 97, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 45, 49, 46, 50, 53, 101, 45, 49, + 48, 44, 32, 102, 108, 111, 97, 116, + 54, 52, 70, 105, 101, 108, 100, 32, + 61, 32, 51, 52, 53, 44, 32, 116, + 101, 120, 116, 70, 105, 101, 108, 100, + 32, 61, 32, 34, 98, 97, 122, 34, + 44, 32, 100, 97, 116, 97, 70, 105, + 101, 108, 100, 32, 61, 32, 34, 113, + 117, 120, 34, 44, 32, 115, 116, 114, + 117, 99, 116, 70, 105, 101, 108, 100, + 32, 61, 32, 40, 118, 111, 105, 100, + 70, 105, 101, 108, 100, 32, 61, 32, + 118, 111, 105, 100, 44, 32, 98, 111, + 111, 108, 70, 105, 101, 108, 100, 32, + 61, 32, 102, 97, 108, 115, 101, 44, + 32, 105, 110, 116, 56, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 117, 73, 110, 116, 51, 50, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 117, 73, 110, 116, 54, 52, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 102, 108, 111, 97, 116, + 51, 50, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 102, 108, 111, + 97, 116, 54, 52, 70, 105, 101, 108, + 100, 32, 61, 32, 48, 44, 32, 116, + 101, 120, 116, 70, 105, 101, 108, 100, + 32, 61, 32, 34, 110, 101, 115, 116, + 101, 100, 34, 44, 32, 115, 116, 114, + 117, 99, 116, 70, 105, 101, 108, 100, + 32, 61, 32, 40, 118, 111, 105, 100, + 70, 105, 101, 108, 100, 32, 61, 32, + 118, 111, 105, 100, 44, 32, 98, 111, + 111, 108, 70, 105, 101, 108, 100, 32, + 61, 32, 102, 97, 108, 115, 101, 44, + 32, 105, 110, 116, 56, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 117, 73, 110, 116, 51, 50, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 117, 73, 110, 116, 54, 52, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 102, 108, 111, 97, 116, + 51, 50, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 102, 108, 111, + 97, 116, 54, 52, 70, 105, 101, 108, + 100, 32, 61, 32, 48, 44, 32, 116, + 101, 120, 116, 70, 105, 101, 108, 100, + 32, 61, 32, 34, 114, 101, 97, 108, + 108, 121, 32, 110, 101, 115, 116, 101, + 100, 34, 44, 32, 101, 110, 117, 109, + 70, 105, 101, 108, 100, 32, 61, 32, + 102, 111, 111, 44, 32, 105, 110, 116, + 101, 114, 102, 97, 99, 101, 70, 105, + 101, 108, 100, 32, 61, 32, 118, 111, + 105, 100, 41, 44, 32, 101, 110, 117, + 109, 70, 105, 101, 108, 100, 32, 61, + 32, 102, 111, 111, 44, 32, 105, 110, + 116, 101, 114, 102, 97, 99, 101, 70, + 105, 101, 108, 100, 32, 61, 32, 118, + 111, 105, 100, 41, 44, 32, 101, 110, + 117, 109, 70, 105, 101, 108, 100, 32, + 61, 32, 98, 97, 122, 44, 32, 105, + 110, 116, 101, 114, 102, 97, 99, 101, + 70, 105, 101, 108, 100, 32, 61, 32, + 118, 111, 105, 100, 44, 32, 118, 111, + 105, 100, 76, 105, 115, 116, 32, 61, + 32, 91, 118, 111, 105, 100, 44, 32, + 118, 111, 105, 100, 44, 32, 118, 111, + 105, 100, 93, 44, 32, 98, 111, 111, + 108, 76, 105, 115, 116, 32, 61, 32, + 91, 102, 97, 108, 115, 101, 44, 32, + 116, 114, 117, 101, 44, 32, 102, 97, + 108, 115, 101, 44, 32, 116, 114, 117, + 101, 44, 32, 116, 114, 117, 101, 93, + 44, 32, 105, 110, 116, 56, 76, 105, + 115, 116, 32, 61, 32, 91, 49, 50, + 44, 32, 45, 51, 52, 44, 32, 45, + 49, 50, 56, 44, 32, 49, 50, 55, + 93, 44, 32, 105, 110, 116, 49, 54, + 76, 105, 115, 116, 32, 61, 32, 91, + 49, 50, 51, 52, 44, 32, 45, 53, + 54, 55, 56, 44, 32, 45, 51, 50, + 55, 54, 56, 44, 32, 51, 50, 55, + 54, 55, 93, 44, 32, 105, 110, 116, + 51, 50, 76, 105, 115, 116, 32, 61, + 32, 91, 49, 50, 51, 52, 53, 54, + 55, 56, 44, 32, 45, 57, 48, 49, + 50, 51, 52, 53, 54, 44, 32, 45, + 50, 49, 52, 55, 52, 56, 51, 54, + 52, 56, 44, 32, 50, 49, 52, 55, + 52, 56, 51, 54, 52, 55, 93, 44, + 32, 105, 110, 116, 54, 52, 76, 105, + 115, 116, 32, 61, 32, 91, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 48, + 49, 50, 51, 52, 53, 44, 32, 45, + 54, 55, 56, 57, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 48, 44, + 32, 45, 57, 50, 50, 51, 51, 55, + 50, 48, 51, 54, 56, 53, 52, 55, + 55, 53, 56, 48, 56, 44, 32, 57, + 50, 50, 51, 51, 55, 50, 48, 51, + 54, 56, 53, 52, 55, 55, 53, 56, + 48, 55, 93, 44, 32, 117, 73, 110, + 116, 56, 76, 105, 115, 116, 32, 61, + 32, 91, 49, 50, 44, 32, 51, 52, + 44, 32, 48, 44, 32, 50, 53, 53, + 93, 44, 32, 117, 73, 110, 116, 49, + 54, 76, 105, 115, 116, 32, 61, 32, + 91, 49, 50, 51, 52, 44, 32, 53, + 54, 55, 56, 44, 32, 48, 44, 32, + 54, 53, 53, 51, 53, 93, 44, 32, + 117, 73, 110, 116, 51, 50, 76, 105, + 115, 116, 32, 61, 32, 91, 49, 50, + 51, 52, 53, 54, 55, 56, 44, 32, + 57, 48, 49, 50, 51, 52, 53, 54, + 44, 32, 48, 44, 32, 52, 50, 57, + 52, 57, 54, 55, 50, 57, 53, 93, + 44, 32, 117, 73, 110, 116, 54, 52, + 76, 105, 115, 116, 32, 61, 32, 91, + 49, 50, 51, 52, 53, 54, 55, 56, + 57, 48, 49, 50, 51, 52, 53, 44, + 32, 54, 55, 56, 57, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 48, + 44, 32, 48, 44, 32, 49, 56, 52, + 52, 54, 55, 52, 52, 48, 55, 51, + 55, 48, 57, 53, 53, 49, 54, 49, + 53, 93, 44, 32, 102, 108, 111, 97, + 116, 51, 50, 76, 105, 115, 116, 32, + 61, 32, 91, 48, 44, 32, 49, 50, + 51, 52, 53, 54, 55, 44, 32, 49, + 101, 51, 55, 44, 32, 45, 49, 101, + 51, 55, 44, 32, 49, 101, 45, 51, + 55, 44, 32, 45, 49, 101, 45, 51, + 55, 93, 44, 32, 102, 108, 111, 97, + 116, 54, 52, 76, 105, 115, 116, 32, + 61, 32, 91, 48, 44, 32, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 48, + 49, 50, 51, 52, 53, 44, 32, 49, + 101, 51, 48, 54, 44, 32, 45, 49, + 101, 51, 48, 54, 44, 32, 49, 101, + 45, 51, 48, 54, 44, 32, 45, 49, + 101, 45, 51, 48, 54, 93, 44, 32, + 116, 101, 120, 116, 76, 105, 115, 116, + 32, 61, 32, 91, 34, 113, 117, 117, + 120, 34, 44, 32, 34, 99, 111, 114, + 103, 101, 34, 44, 32, 34, 103, 114, + 97, 117, 108, 116, 34, 93, 44, 32, + 100, 97, 116, 97, 76, 105, 115, 116, + 32, 61, 32, 91, 34, 103, 97, 114, + 112, 108, 121, 34, 44, 32, 34, 119, + 97, 108, 100, 111, 34, 44, 32, 34, + 102, 114, 101, 100, 34, 93, 44, 32, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 32, 61, 32, 91, 40, 118, + 111, 105, 100, 70, 105, 101, 108, 100, + 32, 61, 32, 118, 111, 105, 100, 44, + 32, 98, 111, 111, 108, 70, 105, 101, + 108, 100, 32, 61, 32, 102, 97, 108, + 115, 101, 44, 32, 105, 110, 116, 56, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 49, 54, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 54, 52, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 56, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 49, + 54, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 117, 73, 110, 116, + 51, 50, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 117, 73, 110, + 116, 54, 52, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 102, 108, + 111, 97, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 116, 101, 120, 116, 70, 105, + 101, 108, 100, 32, 61, 32, 34, 120, + 32, 115, 116, 114, 117, 99, 116, 108, + 105, 115, 116, 32, 49, 34, 44, 32, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 32, 61, 32, 102, 111, 111, 44, + 32, 105, 110, 116, 101, 114, 102, 97, + 99, 101, 70, 105, 101, 108, 100, 32, + 61, 32, 118, 111, 105, 100, 41, 44, + 32, 40, 118, 111, 105, 100, 70, 105, + 101, 108, 100, 32, 61, 32, 118, 111, + 105, 100, 44, 32, 98, 111, 111, 108, + 70, 105, 101, 108, 100, 32, 61, 32, + 102, 97, 108, 115, 101, 44, 32, 105, + 110, 116, 56, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 105, 110, + 116, 49, 54, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 105, 110, + 116, 51, 50, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 105, 110, + 116, 54, 52, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 117, 73, + 110, 116, 56, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 117, 73, + 110, 116, 49, 54, 70, 105, 101, 108, + 100, 32, 61, 32, 48, 44, 32, 117, + 73, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 117, 73, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 102, 108, 111, 97, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 102, 108, 111, 97, 116, + 54, 52, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 116, 101, 120, + 116, 70, 105, 101, 108, 100, 32, 61, + 32, 34, 120, 32, 115, 116, 114, 117, + 99, 116, 108, 105, 115, 116, 32, 50, + 34, 44, 32, 101, 110, 117, 109, 70, + 105, 101, 108, 100, 32, 61, 32, 102, + 111, 111, 44, 32, 105, 110, 116, 101, + 114, 102, 97, 99, 101, 70, 105, 101, + 108, 100, 32, 61, 32, 118, 111, 105, + 100, 41, 44, 32, 40, 118, 111, 105, + 100, 70, 105, 101, 108, 100, 32, 61, + 32, 118, 111, 105, 100, 44, 32, 98, + 111, 111, 108, 70, 105, 101, 108, 100, + 32, 61, 32, 102, 97, 108, 115, 101, + 44, 32, 105, 110, 116, 56, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 105, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 105, 110, 116, 51, 50, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 105, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 117, 73, 110, 116, 56, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 117, 73, 110, 116, 49, 54, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 117, 73, 110, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 54, + 52, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 102, 108, 111, 97, + 116, 51, 50, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 102, 108, + 111, 97, 116, 54, 52, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 32, 61, 32, 34, 120, 32, 115, + 116, 114, 117, 99, 116, 108, 105, 115, + 116, 32, 51, 34, 44, 32, 101, 110, + 117, 109, 70, 105, 101, 108, 100, 32, + 61, 32, 102, 111, 111, 44, 32, 105, + 110, 116, 101, 114, 102, 97, 99, 101, + 70, 105, 101, 108, 100, 32, 61, 32, + 118, 111, 105, 100, 41, 93, 44, 32, + 101, 110, 117, 109, 76, 105, 115, 116, + 32, 61, 32, 91, 113, 117, 120, 44, + 32, 98, 97, 114, 44, 32, 103, 114, + 97, 117, 108, 116, 93, 41, 44, 32, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 32, 61, 32, 99, 111, 114, 103, + 101, 44, 32, 105, 110, 116, 101, 114, + 102, 97, 99, 101, 70, 105, 101, 108, + 100, 32, 61, 32, 118, 111, 105, 100, + 44, 32, 118, 111, 105, 100, 76, 105, + 115, 116, 32, 61, 32, 91, 118, 111, + 105, 100, 44, 32, 118, 111, 105, 100, + 44, 32, 118, 111, 105, 100, 44, 32, + 118, 111, 105, 100, 44, 32, 118, 111, + 105, 100, 44, 32, 118, 111, 105, 100, + 93, 44, 32, 98, 111, 111, 108, 76, + 105, 115, 116, 32, 61, 32, 91, 116, + 114, 117, 101, 44, 32, 102, 97, 108, + 115, 101, 44, 32, 102, 97, 108, 115, + 101, 44, 32, 116, 114, 117, 101, 93, + 44, 32, 105, 110, 116, 56, 76, 105, + 115, 116, 32, 61, 32, 91, 49, 49, + 49, 44, 32, 45, 49, 49, 49, 93, + 44, 32, 105, 110, 116, 49, 54, 76, + 105, 115, 116, 32, 61, 32, 91, 49, + 49, 49, 49, 49, 44, 32, 45, 49, + 49, 49, 49, 49, 93, 44, 32, 105, + 110, 116, 51, 50, 76, 105, 115, 116, + 32, 61, 32, 91, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 44, 32, 45, + 49, 49, 49, 49, 49, 49, 49, 49, + 49, 93, 44, 32, 105, 110, 116, 54, + 52, 76, 105, 115, 116, 32, 61, 32, + 91, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 44, 32, 45, 49, + 49, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 93, 44, 32, 117, 73, 110, + 116, 56, 76, 105, 115, 116, 32, 61, + 32, 91, 49, 49, 49, 44, 32, 50, + 50, 50, 93, 44, 32, 117, 73, 110, + 116, 49, 54, 76, 105, 115, 116, 32, + 61, 32, 91, 51, 51, 51, 51, 51, + 44, 32, 52, 52, 52, 52, 52, 93, + 44, 32, 117, 73, 110, 116, 51, 50, + 76, 105, 115, 116, 32, 61, 32, 91, + 51, 51, 51, 51, 51, 51, 51, 51, + 51, 51, 93, 44, 32, 117, 73, 110, + 116, 54, 52, 76, 105, 115, 116, 32, + 61, 32, 91, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 49, 49, 93, + 44, 32, 102, 108, 111, 97, 116, 51, + 50, 76, 105, 115, 116, 32, 61, 32, + 91, 53, 53, 53, 53, 46, 53, 44, + 32, 105, 110, 102, 44, 32, 45, 105, + 110, 102, 44, 32, 110, 97, 110, 93, + 44, 32, 102, 108, 111, 97, 116, 54, + 52, 76, 105, 115, 116, 32, 61, 32, + 91, 55, 55, 55, 55, 46, 55, 53, + 44, 32, 105, 110, 102, 44, 32, 45, + 105, 110, 102, 44, 32, 110, 97, 110, + 93, 44, 32, 116, 101, 120, 116, 76, + 105, 115, 116, 32, 61, 32, 91, 34, + 112, 108, 117, 103, 104, 34, 44, 32, + 34, 120, 121, 122, 122, 121, 34, 44, + 32, 34, 116, 104, 117, 100, 34, 93, + 44, 32, 100, 97, 116, 97, 76, 105, + 115, 116, 32, 61, 32, 91, 34, 111, + 111, 112, 115, 34, 44, 32, 34, 101, + 120, 104, 97, 117, 115, 116, 101, 100, + 34, 44, 32, 34, 114, 102, 99, 51, + 48, 57, 50, 34, 93, 44, 32, 115, + 116, 114, 117, 99, 116, 76, 105, 115, + 116, 32, 61, 32, 91, 40, 118, 111, + 105, 100, 70, 105, 101, 108, 100, 32, + 61, 32, 118, 111, 105, 100, 44, 32, + 98, 111, 111, 108, 70, 105, 101, 108, + 100, 32, 61, 32, 102, 97, 108, 115, + 101, 44, 32, 105, 110, 116, 56, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 105, 110, 116, 49, 54, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 105, 110, 116, 51, 50, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 105, 110, 116, 54, 52, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 117, 73, 110, 116, 56, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 117, 73, 110, 116, 49, 54, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 51, + 50, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 117, 73, 110, 116, + 54, 52, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 102, 108, 111, + 97, 116, 51, 50, 70, 105, 101, 108, + 100, 32, 61, 32, 48, 44, 32, 102, + 108, 111, 97, 116, 54, 52, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 116, 101, 120, 116, 70, 105, 101, + 108, 100, 32, 61, 32, 34, 115, 116, + 114, 117, 99, 116, 108, 105, 115, 116, + 32, 49, 34, 44, 32, 101, 110, 117, + 109, 70, 105, 101, 108, 100, 32, 61, + 32, 102, 111, 111, 44, 32, 105, 110, + 116, 101, 114, 102, 97, 99, 101, 70, + 105, 101, 108, 100, 32, 61, 32, 118, + 111, 105, 100, 41, 44, 32, 40, 118, + 111, 105, 100, 70, 105, 101, 108, 100, + 32, 61, 32, 118, 111, 105, 100, 44, + 32, 98, 111, 111, 108, 70, 105, 101, + 108, 100, 32, 61, 32, 102, 97, 108, + 115, 101, 44, 32, 105, 110, 116, 56, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 49, 54, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 51, 50, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 105, 110, 116, 54, 52, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 56, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 117, 73, 110, 116, 49, + 54, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 117, 73, 110, 116, + 51, 50, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 117, 73, 110, + 116, 54, 52, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 102, 108, + 111, 97, 116, 51, 50, 70, 105, 101, + 108, 100, 32, 61, 32, 48, 44, 32, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 32, 61, 32, 48, + 44, 32, 116, 101, 120, 116, 70, 105, + 101, 108, 100, 32, 61, 32, 34, 115, + 116, 114, 117, 99, 116, 108, 105, 115, + 116, 32, 50, 34, 44, 32, 101, 110, + 117, 109, 70, 105, 101, 108, 100, 32, + 61, 32, 102, 111, 111, 44, 32, 105, + 110, 116, 101, 114, 102, 97, 99, 101, + 70, 105, 101, 108, 100, 32, 61, 32, + 118, 111, 105, 100, 41, 44, 32, 40, + 118, 111, 105, 100, 70, 105, 101, 108, + 100, 32, 61, 32, 118, 111, 105, 100, + 44, 32, 98, 111, 111, 108, 70, 105, + 101, 108, 100, 32, 61, 32, 102, 97, + 108, 115, 101, 44, 32, 105, 110, 116, + 56, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 105, 110, 116, 49, + 54, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 105, 110, 116, 51, + 50, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 105, 110, 116, 54, + 52, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 117, 73, 110, 116, + 56, 70, 105, 101, 108, 100, 32, 61, + 32, 48, 44, 32, 117, 73, 110, 116, + 49, 54, 70, 105, 101, 108, 100, 32, + 61, 32, 48, 44, 32, 117, 73, 110, + 116, 51, 50, 70, 105, 101, 108, 100, + 32, 61, 32, 48, 44, 32, 117, 73, + 110, 116, 54, 52, 70, 105, 101, 108, + 100, 32, 61, 32, 48, 44, 32, 102, + 108, 111, 97, 116, 51, 50, 70, 105, + 101, 108, 100, 32, 61, 32, 48, 44, + 32, 102, 108, 111, 97, 116, 54, 52, + 70, 105, 101, 108, 100, 32, 61, 32, + 48, 44, 32, 116, 101, 120, 116, 70, + 105, 101, 108, 100, 32, 61, 32, 34, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 34, 44, 32, 101, + 110, 117, 109, 70, 105, 101, 108, 100, + 32, 61, 32, 102, 111, 111, 44, 32, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 70, 105, 101, 108, 100, 32, 61, + 32, 118, 111, 105, 100, 41, 93, 44, + 32, 101, 110, 117, 109, 76, 105, 115, + 116, 32, 61, 32, 91, 102, 111, 111, + 44, 32, 103, 97, 114, 112, 108, 121, + 93, 41, 10, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8e59556fb309253f = b_8e59556fb309253f.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8e59556fb309253f = { + 0x8e59556fb309253f, b_8e59556fb309253f.words, 553, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8e59556fb309253f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<374> b_dec09c6791841ebb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 187, 30, 132, 145, 103, 156, 192, 222, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 3, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 101, 109, 98, 101, 100, + 100, 101, 100, 83, 116, 114, 117, 99, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 1, 133, 199, 207, 178, 158, 67, 255, + 135, 32, 242, 121, 183, 143, 255, 255, + 234, 0, 110, 178, 20, 106, 10, 206, + 210, 10, 31, 235, 140, 169, 84, 171, + 0, 80, 154, 68, 5, 0, 0, 0, + 0, 187, 224, 192, 130, 139, 181, 201, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 133, 3, 0, 0, 48, 0, 0, 0, + 129, 3, 0, 0, 33, 0, 0, 0, + 129, 3, 0, 0, 18, 0, 0, 0, + 129, 3, 0, 0, 19, 0, 0, 0, + 129, 3, 0, 0, 20, 0, 0, 0, + 129, 3, 0, 0, 21, 0, 0, 0, + 133, 3, 0, 0, 18, 0, 0, 0, + 133, 3, 0, 0, 19, 0, 0, 0, + 133, 3, 0, 0, 12, 0, 0, 0, + 133, 3, 0, 0, 13, 0, 0, 0, + 133, 3, 0, 0, 36, 0, 0, 0, + 137, 3, 0, 0, 37, 0, 0, 0, + 149, 3, 0, 0, 30, 0, 0, 0, + 169, 3, 0, 0, 30, 0, 0, 0, + 193, 3, 0, 0, 119, 2, 0, 0, + 17, 5, 0, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 111, 145, 0, 0, 0, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, + 199, 113, 196, 43, 171, 117, 107, 15, + 57, 142, 59, 212, 84, 138, 148, 240, + 111, 222, 0, 0, 0, 0, 0, 0, + 53, 130, 156, 173, 0, 0, 0, 0, + 85, 161, 174, 198, 0, 0, 0, 0, + 199, 113, 172, 181, 175, 152, 50, 154, + 0, 156, 173, 69, 0, 0, 128, 127, + 0, 0, 128, 255, 0, 0, 192, 127, + 0, 0, 0, 0, 192, 97, 190, 64, + 0, 0, 0, 0, 0, 0, 240, 127, + 0, 0, 0, 0, 0, 0, 240, 255, + 0, 0, 0, 0, 0, 0, 248, 127, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 116, 104, 117, 100, 0, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 9, 0, 0, 0, 74, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 111, 111, 112, 115, 0, 0, 0, 0, + 101, 120, 104, 97, 117, 115, 116, 101, + 100, 0, 0, 0, 0, 0, 0, 0, + 114, 102, 99, 51, 48, 57, 50, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_dec09c6791841ebb = b_dec09c6791841ebb.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_dec09c6791841ebb = { + 0xdec09c6791841ebb, b_dec09c6791841ebb.words, 374, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_dec09c6791841ebb, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<25> b_fb7ed666617fb649 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 73, 182, 127, 97, 102, 214, 126, 251, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 110, 111, 110, 65, 115, + 99, 105, 105, 84, 101, 120, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 90, 0, 0, 0, + 226, 153, 171, 32, 195, 169, 32, 226, + 156, 147, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fb7ed666617fb649 = b_fb7ed666617fb649.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_fb7ed666617fb649 = { + 0xfb7ed666617fb649, b_fb7ed666617fb649.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_fb7ed666617fb649, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<84> b_ddc280dbee9c99b3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 179, 153, 156, 238, 219, 128, 194, 221, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 110, 121, 80, 111, 105, 110, 116, 101, + 114, 67, 111, 110, 115, 116, 97, 110, + 116, 115, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 3, 0, 1, 0, + 108, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 0, 0, 0, 3, 0, 1, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 0, 0, 0, 3, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 3, 0, 1, 0, + 136, 0, 0, 0, 2, 0, 1, 0, + 97, 110, 121, 75, 105, 110, 100, 65, + 115, 83, 116, 114, 117, 99, 116, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 121, 83, 116, 114, 117, 99, + 116, 65, 115, 83, 116, 114, 117, 99, + 116, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 121, 75, 105, 110, 100, 65, + 115, 76, 105, 115, 116, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 121, 76, 105, 115, 116, 65, + 115, 76, 105, 115, 116, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ddc280dbee9c99b3 = b_ddc280dbee9c99b3.words; +#if !CAPNP_LITE +static const uint16_t m_ddc280dbee9c99b3[] = {2, 0, 3, 1}; +static const uint16_t i_ddc280dbee9c99b3[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_ddc280dbee9c99b3 = { + 0xddc280dbee9c99b3, b_ddc280dbee9c99b3.words, 84, nullptr, m_ddc280dbee9c99b3, + 0, 4, i_ddc280dbee9c99b3, nullptr, nullptr, { &s_ddc280dbee9c99b3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<444> b_8139f596ebaf6185 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 133, 97, 175, 235, 150, 245, 57, 129, + 11, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 3, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 97, 110, 121, 80, 111, + 105, 110, 116, 101, 114, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 179, 153, 156, 238, 219, 128, 194, 221, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 68, 3, 0, 0, 6, 0, 20, 0, + 125, 6, 0, 0, 20, 0, 0, 0, + 125, 6, 0, 0, 20, 0, 0, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, + 199, 107, 159, 6, 57, 148, 96, 249, } +}; +::capnp::word const* const bp_8139f596ebaf6185 = b_8139f596ebaf6185.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8139f596ebaf6185 = { + 0x8139f596ebaf6185, b_8139f596ebaf6185.words, 444, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8139f596ebaf6185, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_88eb12a0e0af92b2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 199, 0, 0, 0, + 149, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 179, 89, 213, 192, 237, 116, 184, + 164, 75, 113, 171, 221, 202, 79, 176, + 81, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 104, 37, 180, 87, 51, 137, 68, 208, + 47, 213, 71, 66, 223, 65, 241, 155, + 57, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 188, 207, 145, 42, 187, 138, 172, 217, + 45, 91, 55, 47, 79, 209, 153, 155, + 33, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_88eb12a0e0af92b2 = b_88eb12a0e0af92b2.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_88eb12a0e0af92b2[] = { + &s_9b99d14f2f375b2d, + &s_9bf141df4247d52f, + &s_b04fcaddab714ba4, + &s_b874edc0d559b391, + &s_d044893357b42568, + &s_d9ac8abb2a91cfbc, +}; +static const uint16_t m_88eb12a0e0af92b2[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_88eb12a0e0af92b2 = { + 0x88eb12a0e0af92b2, b_88eb12a0e0af92b2.words, 49, d_88eb12a0e0af92b2, m_88eb12a0e0af92b2, + 6, 3, nullptr, nullptr, nullptr, { &s_88eb12a0e0af92b2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_b874edc0d559b391 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 145, 179, 89, 213, 192, 237, 116, 184, + 25, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 102, 111, 111, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 32, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 105, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b874edc0d559b391 = b_b874edc0d559b391.words; +#if !CAPNP_LITE +static const uint16_t m_b874edc0d559b391[] = {0, 1}; +static const uint16_t i_b874edc0d559b391[] = {0, 1}; +const ::capnp::_::RawSchema s_b874edc0d559b391 = { + 0xb874edc0d559b391, b_b874edc0d559b391.words, 48, nullptr, m_b874edc0d559b391, + 0, 2, i_b874edc0d559b391, nullptr, nullptr, { &s_b874edc0d559b391, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_b04fcaddab714ba4 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 164, 75, 113, 171, 221, 202, 79, 176, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 102, 111, 111, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 120, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b04fcaddab714ba4 = b_b04fcaddab714ba4.words; +#if !CAPNP_LITE +static const uint16_t m_b04fcaddab714ba4[] = {0}; +static const uint16_t i_b04fcaddab714ba4[] = {0}; +const ::capnp::_::RawSchema s_b04fcaddab714ba4 = { + 0xb04fcaddab714ba4, b_b04fcaddab714ba4.words, 33, nullptr, m_b04fcaddab714ba4, + 0, 1, i_b04fcaddab714ba4, nullptr, nullptr, { &s_b04fcaddab714ba4, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_d044893357b42568 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 104, 37, 180, 87, 51, 137, 68, 208, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 98, 97, 114, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d044893357b42568 = b_d044893357b42568.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d044893357b42568 = { + 0xd044893357b42568, b_d044893357b42568.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d044893357b42568, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_9bf141df4247d52f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 47, 213, 71, 66, 223, 65, 241, 155, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 98, 97, 114, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9bf141df4247d52f = b_9bf141df4247d52f.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9bf141df4247d52f = { + 0x9bf141df4247d52f, b_9bf141df4247d52f.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9bf141df4247d52f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_d9ac8abb2a91cfbc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 188, 207, 145, 42, 187, 138, 172, 217, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 98, 97, 122, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d9ac8abb2a91cfbc = b_d9ac8abb2a91cfbc.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d9ac8abb2a91cfbc[] = { + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_d9ac8abb2a91cfbc[] = {0}; +static const uint16_t i_d9ac8abb2a91cfbc[] = {0}; +const ::capnp::_::RawSchema s_d9ac8abb2a91cfbc = { + 0xd9ac8abb2a91cfbc, b_d9ac8abb2a91cfbc.words, 33, d_d9ac8abb2a91cfbc, m_d9ac8abb2a91cfbc, + 1, 1, i_d9ac8abb2a91cfbc, nullptr, nullptr, { &s_d9ac8abb2a91cfbc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_9b99d14f2f375b2d = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 45, 91, 55, 47, 79, 209, 153, 155, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 46, 98, 97, 122, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9b99d14f2f375b2d = b_9b99d14f2f375b2d.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9b99d14f2f375b2d = { + 0x9b99d14f2f375b2d, b_9b99d14f2f375b2d.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9b99d14f2f375b2d, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<50> b_e4e9bac98670b748 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 72, 183, 112, 134, 201, 186, 233, 228, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 186, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 199, 0, 0, 0, + 145, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 23, 63, 54, 113, 84, 188, 164, 131, + 221, 83, 39, 62, 26, 61, 75, 142, + 81, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 217, 186, 231, 167, 50, 117, 246, 172, + 57, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 246, 138, 234, 81, 232, 52, 184, 243, + 253, 99, 11, 184, 20, 243, 168, 160, + 33, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e4e9bac98670b748 = b_e4e9bac98670b748.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e4e9bac98670b748[] = { + &s_83a4bc5471363f17, + &s_88eb12a0e0af92b2, + &s_8e4b3d1a3e2753dd, + &s_a0a8f314b80b63fd, + &s_acf67532a7e7bad9, + &s_f3b834e851ea8af6, +}; +static const uint16_t m_e4e9bac98670b748[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_e4e9bac98670b748 = { + 0xe4e9bac98670b748, b_e4e9bac98670b748.words, 50, d_e4e9bac98670b748, m_e4e9bac98670b748, + 6, 3, nullptr, nullptr, nullptr, { &s_e4e9bac98670b748, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_83a4bc5471363f17 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 23, 63, 54, 113, 84, 188, 164, 131, + 23, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 46, 113, + 117, 120, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_83a4bc5471363f17 = b_83a4bc5471363f17.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_83a4bc5471363f17 = { + 0x83a4bc5471363f17, b_83a4bc5471363f17.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_83a4bc5471363f17, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_8e4b3d1a3e2753dd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 221, 83, 39, 62, 26, 61, 75, 142, + 23, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 46, 113, + 117, 120, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8e4b3d1a3e2753dd = b_8e4b3d1a3e2753dd.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8e4b3d1a3e2753dd = { + 0x8e4b3d1a3e2753dd, b_8e4b3d1a3e2753dd.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8e4b3d1a3e2753dd, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_acf67532a7e7bad9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 217, 186, 231, 167, 50, 117, 246, 172, + 23, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 46, 99, + 111, 114, 103, 101, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_acf67532a7e7bad9 = b_acf67532a7e7bad9.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_acf67532a7e7bad9 = { + 0xacf67532a7e7bad9, b_acf67532a7e7bad9.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_acf67532a7e7bad9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_f3b834e851ea8af6 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 246, 138, 234, 81, 232, 52, 184, 243, + 23, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 46, 103, + 114, 97, 117, 108, 116, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f3b834e851ea8af6 = b_f3b834e851ea8af6.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f3b834e851ea8af6 = { + 0xf3b834e851ea8af6, b_f3b834e851ea8af6.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f3b834e851ea8af6, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<20> b_98d7e0ef61488783 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 131, 135, 72, 97, 239, 224, 215, 152, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 25, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 69, + 120, 116, 101, 110, 100, 115, 50, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 3, 0, 5, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 72, 183, 112, 134, 201, 186, 233, 228, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_98d7e0ef61488783 = b_98d7e0ef61488783.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_98d7e0ef61488783[] = { + &s_e4e9bac98670b748, +}; +const ::capnp::_::RawSchema s_98d7e0ef61488783 = { + 0x98d7e0ef61488783, b_98d7e0ef61488783.words, 20, d_98d7e0ef61488783, nullptr, + 1, 0, nullptr, nullptr, nullptr, { &s_98d7e0ef61488783, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<56> b_a5a404caa61d4cd0 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 208, 76, 29, 166, 202, 4, 164, 165, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 199, 0, 0, 0, + 177, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 9, 0, 0, 0, 34, 0, 0, 0, + 203, 138, 44, 29, 90, 173, 66, 148, + 5, 0, 0, 0, 58, 0, 0, 0, + 66, 111, 120, 0, 0, 0, 0, 0, + 65, 110, 121, 66, 111, 120, 0, 0, + 12, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 52, 112, 37, 150, 80, 223, 232, 199, + 223, 143, 162, 11, 158, 42, 68, 178, + 81, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 159, 129, 55, 207, 99, 238, 4, 166, + 214, 112, 96, 108, 117, 84, 218, 142, + 57, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 78, 61, 9, 171, 83, 107, 227, 248, + 121, 239, 38, 76, 201, 180, 68, 191, + 37, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 103, 101, 116, 67, 97, 112, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 116, 101, 115, 116, 80, 111, 105, 110, + 116, 101, 114, 115, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 101, 116, 65, 110, 121, 67, 97, + 112, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_a5a404caa61d4cd0 = b_a5a404caa61d4cd0.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a5a404caa61d4cd0[] = { + &s_8eda54756c6070d6, + &s_a604ee63cf37819f, + &s_b2442a9e0ba28fdf, + &s_bf44b4c94c26ef79, + &s_c7e8df5096257034, + &s_f8e36b53ab093d4e, +}; +static const uint16_t m_a5a404caa61d4cd0[] = {2, 0, 1}; +const ::capnp::_::RawSchema s_a5a404caa61d4cd0 = { + 0xa5a404caa61d4cd0, b_a5a404caa61d4cd0.words, 56, d_a5a404caa61d4cd0, m_a5a404caa61d4cd0, + 6, 3, nullptr, nullptr, nullptr, { &s_a5a404caa61d4cd0, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_b0b29e51db0e26b1 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 24, 0, 0, 0, 1, 0, 0, 0, + 208, 76, 29, 166, 202, 4, 164, 165, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 66, 111, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b0b29e51db0e26b1 = b_b0b29e51db0e26b1.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_b0b29e51db0e26b1[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_b0b29e51db0e26b1[] = {0}; +static const uint16_t i_b0b29e51db0e26b1[] = {0}; +const ::capnp::_::RawSchema s_b0b29e51db0e26b1 = { + 0xb0b29e51db0e26b1, b_b0b29e51db0e26b1.words, 33, d_b0b29e51db0e26b1, m_b0b29e51db0e26b1, + 1, 1, i_b0b29e51db0e26b1, nullptr, nullptr, { &s_b0b29e51db0e26b1, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_9442ad5a1d2c8acb = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 203, 138, 44, 29, 90, 173, 66, 148, + 24, 0, 0, 0, 1, 0, 0, 0, + 208, 76, 29, 166, 202, 4, 164, 165, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 65, 110, 121, 66, 111, 120, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9442ad5a1d2c8acb = b_9442ad5a1d2c8acb.words; +#if !CAPNP_LITE +static const uint16_t m_9442ad5a1d2c8acb[] = {0}; +static const uint16_t i_9442ad5a1d2c8acb[] = {0}; +const ::capnp::_::RawSchema s_9442ad5a1d2c8acb = { + 0x9442ad5a1d2c8acb, b_9442ad5a1d2c8acb.words, 33, nullptr, m_9442ad5a1d2c8acb, + 0, 1, i_9442ad5a1d2c8acb, nullptr, nullptr, { &s_9442ad5a1d2c8acb, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_c7e8df5096257034 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 52, 112, 37, 150, 80, 223, 232, 199, + 24, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 103, 101, 116, 67, 97, 112, 36, 80, + 97, 114, 97, 109, 115, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 110, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 67, 97, 112, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c7e8df5096257034 = b_c7e8df5096257034.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c7e8df5096257034[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_c7e8df5096257034[] = {1, 0}; +static const uint16_t i_c7e8df5096257034[] = {0, 1}; +const ::capnp::_::RawSchema s_c7e8df5096257034 = { + 0xc7e8df5096257034, b_c7e8df5096257034.words, 48, d_c7e8df5096257034, m_c7e8df5096257034, + 1, 2, i_c7e8df5096257034, nullptr, nullptr, { &s_c7e8df5096257034, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_b2442a9e0ba28fdf = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 223, 143, 162, 11, 158, 42, 68, 178, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 103, 101, 116, 67, 97, 112, 36, 82, + 101, 115, 117, 108, 116, 115, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 66, 111, 120, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b2442a9e0ba28fdf = b_b2442a9e0ba28fdf.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_b2442a9e0ba28fdf[] = { + &s_b0b29e51db0e26b1, +}; +static const uint16_t m_b2442a9e0ba28fdf[] = {1, 0}; +static const uint16_t i_b2442a9e0ba28fdf[] = {0, 1}; +const ::capnp::_::RawSchema s_b2442a9e0ba28fdf = { + 0xb2442a9e0ba28fdf, b_b2442a9e0ba28fdf.words, 48, d_b2442a9e0ba28fdf, m_b2442a9e0ba28fdf, + 1, 2, i_b2442a9e0ba28fdf, nullptr, nullptr, { &s_b2442a9e0ba28fdf, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<68> b_a604ee63cf37819f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 159, 129, 55, 207, 99, 238, 4, 166, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 116, 101, 115, 116, 80, 111, 105, 110, + 116, 101, 114, 115, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 98, 106, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a604ee63cf37819f = b_a604ee63cf37819f.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a604ee63cf37819f[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_a604ee63cf37819f[] = {0, 2, 1}; +static const uint16_t i_a604ee63cf37819f[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_a604ee63cf37819f = { + 0xa604ee63cf37819f, b_a604ee63cf37819f.words, 68, d_a604ee63cf37819f, m_a604ee63cf37819f, + 1, 3, i_a604ee63cf37819f, nullptr, nullptr, { &s_a604ee63cf37819f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_8eda54756c6070d6 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 214, 112, 96, 108, 117, 84, 218, 142, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 116, 101, 115, 116, 80, 111, 105, 110, + 116, 101, 114, 115, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8eda54756c6070d6 = b_8eda54756c6070d6.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8eda54756c6070d6 = { + 0x8eda54756c6070d6, b_8eda54756c6070d6.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8eda54756c6070d6, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_f8e36b53ab093d4e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 78, 61, 9, 171, 83, 107, 227, 248, + 24, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 103, 101, 116, 65, 110, 121, 67, 97, + 112, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 110, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 67, 97, 112, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f8e36b53ab093d4e = b_f8e36b53ab093d4e.words; +#if !CAPNP_LITE +static const uint16_t m_f8e36b53ab093d4e[] = {1, 0}; +static const uint16_t i_f8e36b53ab093d4e[] = {0, 1}; +const ::capnp::_::RawSchema s_f8e36b53ab093d4e = { + 0xf8e36b53ab093d4e, b_f8e36b53ab093d4e.words, 49, nullptr, m_f8e36b53ab093d4e, + 0, 2, i_f8e36b53ab093d4e, nullptr, nullptr, { &s_f8e36b53ab093d4e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_bf44b4c94c26ef79 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 121, 239, 38, 76, 201, 180, 68, 191, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 105, 112, 101, 108, 105, 110, 101, 46, + 103, 101, 116, 65, 110, 121, 67, 97, + 112, 36, 82, 101, 115, 117, 108, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 66, 111, 120, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 203, 138, 44, 29, 90, 173, 66, 148, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_bf44b4c94c26ef79 = b_bf44b4c94c26ef79.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_bf44b4c94c26ef79[] = { + &s_9442ad5a1d2c8acb, +}; +static const uint16_t m_bf44b4c94c26ef79[] = {1, 0}; +static const uint16_t i_bf44b4c94c26ef79[] = {0, 1}; +const ::capnp::_::RawSchema s_bf44b4c94c26ef79 = { + 0xbf44b4c94c26ef79, b_bf44b4c94c26ef79.words, 49, d_bf44b4c94c26ef79, m_bf44b4c94c26ef79, + 1, 2, i_bf44b4c94c26ef79, nullptr, nullptr, { &s_bf44b4c94c26ef79, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<30> b_a0e77035bdff0051 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 81, 0, 255, 189, 53, 112, 231, 160, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 71, 0, 0, 0, + 73, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 97, 108, 108, 79, 114, 100, 101, 114, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 116, 235, 108, 213, 140, 30, 143, + 183, 234, 16, 56, 191, 182, 219, 222, + 17, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 7, 0, 0, 0, + 103, 101, 116, 67, 97, 108, 108, 83, + 101, 113, 117, 101, 110, 99, 101, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_a0e77035bdff0051 = b_a0e77035bdff0051.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a0e77035bdff0051[] = { + &s_8f1e8cd56ceb74dc, + &s_dedbb6bf3810eab7, +}; +static const uint16_t m_a0e77035bdff0051[] = {0}; +const ::capnp::_::RawSchema s_a0e77035bdff0051 = { + 0xa0e77035bdff0051, b_a0e77035bdff0051.words, 30, d_a0e77035bdff0051, m_a0e77035bdff0051, + 2, 1, nullptr, nullptr, nullptr, { &s_a0e77035bdff0051, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_8f1e8cd56ceb74dc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 220, 116, 235, 108, 213, 140, 30, 143, + 25, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 130, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 97, 108, 108, 79, 114, 100, 101, 114, + 46, 103, 101, 116, 67, 97, 108, 108, + 83, 101, 113, 117, 101, 110, 99, 101, + 36, 80, 97, 114, 97, 109, 115, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 1, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 101, 120, 112, 101, 99, 116, 101, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8f1e8cd56ceb74dc = b_8f1e8cd56ceb74dc.words; +#if !CAPNP_LITE +static const uint16_t m_8f1e8cd56ceb74dc[] = {0}; +static const uint16_t i_8f1e8cd56ceb74dc[] = {0}; +const ::capnp::_::RawSchema s_8f1e8cd56ceb74dc = { + 0x8f1e8cd56ceb74dc, b_8f1e8cd56ceb74dc.words, 35, nullptr, m_8f1e8cd56ceb74dc, + 0, 1, i_8f1e8cd56ceb74dc, nullptr, nullptr, { &s_8f1e8cd56ceb74dc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_dedbb6bf3810eab7 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 183, 234, 16, 56, 191, 182, 219, 222, + 25, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 138, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 97, 108, 108, 79, 114, 100, 101, 114, + 46, 103, 101, 116, 67, 97, 108, 108, + 83, 101, 113, 117, 101, 110, 99, 101, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 110, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_dedbb6bf3810eab7 = b_dedbb6bf3810eab7.words; +#if !CAPNP_LITE +static const uint16_t m_dedbb6bf3810eab7[] = {0}; +static const uint16_t i_dedbb6bf3810eab7[] = {0}; +const ::capnp::_::RawSchema s_dedbb6bf3810eab7 = { + 0xdedbb6bf3810eab7, b_dedbb6bf3810eab7.words, 35, nullptr, m_dedbb6bf3810eab7, + 0, 1, i_dedbb6bf3810eab7, nullptr, nullptr, { &s_dedbb6bf3810eab7, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_ddd699207eb8e23b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 59, 226, 184, 126, 32, 153, 214, 221, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 71, 0, 0, 0, + 85, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 97, 105, 108, 67, 97, 108, 108, 101, + 101, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 25, 61, 213, 159, 90, 46, 237, 169, + 1, 0, 0, 0, 90, 0, 0, 0, + 84, 97, 105, 108, 82, 101, 115, 117, + 108, 116, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 87, 73, 97, 37, 195, 239, 225, 197, + 25, 61, 213, 159, 90, 46, 237, 169, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 7, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_ddd699207eb8e23b = b_ddd699207eb8e23b.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ddd699207eb8e23b[] = { + &s_a9ed2e5a9fd53d19, + &s_c5e1efc325614957, +}; +static const uint16_t m_ddd699207eb8e23b[] = {0}; +const ::capnp::_::RawSchema s_ddd699207eb8e23b = { + 0xddd699207eb8e23b, b_ddd699207eb8e23b.words, 33, d_ddd699207eb8e23b, m_ddd699207eb8e23b, + 2, 1, nullptr, nullptr, nullptr, { &s_ddd699207eb8e23b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<64> b_a9ed2e5a9fd53d19 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 25, 61, 213, 159, 90, 46, 237, 169, + 26, 0, 0, 0, 1, 0, 1, 0, + 59, 226, 184, 126, 32, 153, 214, 221, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 97, 105, 108, 67, 97, 108, 108, 101, + 101, 46, 84, 97, 105, 108, 82, 101, + 115, 117, 108, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 105, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 255, 189, 53, 112, 231, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a9ed2e5a9fd53d19 = b_a9ed2e5a9fd53d19.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a9ed2e5a9fd53d19[] = { + &s_a0e77035bdff0051, +}; +static const uint16_t m_a9ed2e5a9fd53d19[] = {2, 0, 1}; +static const uint16_t i_a9ed2e5a9fd53d19[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_a9ed2e5a9fd53d19 = { + 0xa9ed2e5a9fd53d19, b_a9ed2e5a9fd53d19.words, 64, d_a9ed2e5a9fd53d19, m_a9ed2e5a9fd53d19, + 1, 3, i_a9ed2e5a9fd53d19, nullptr, nullptr, { &s_a9ed2e5a9fd53d19, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_c5e1efc325614957 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 87, 73, 97, 37, 195, 239, 225, 197, + 26, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 97, 105, 108, 67, 97, 108, 108, 101, + 101, 46, 102, 111, 111, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 105, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c5e1efc325614957 = b_c5e1efc325614957.words; +#if !CAPNP_LITE +static const uint16_t m_c5e1efc325614957[] = {0, 1}; +static const uint16_t i_c5e1efc325614957[] = {0, 1}; +const ::capnp::_::RawSchema s_c5e1efc325614957 = { + 0xc5e1efc325614957, b_c5e1efc325614957.words, 48, nullptr, m_c5e1efc325614957, + 0, 2, i_c5e1efc325614957, nullptr, nullptr, { &s_c5e1efc325614957, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<29> b_870bf40110ce3035 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 53, 48, 206, 16, 1, 244, 11, 135, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 71, 0, 0, 0, + 69, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 97, 105, 108, 67, 97, 108, 108, 101, + 114, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 197, 138, 220, 21, 149, 39, 122, 176, + 25, 61, 213, 159, 90, 46, 237, 169, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 7, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_870bf40110ce3035 = b_870bf40110ce3035.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_870bf40110ce3035[] = { + &s_a9ed2e5a9fd53d19, + &s_b07a279515dc8ac5, +}; +static const uint16_t m_870bf40110ce3035[] = {0}; +const ::capnp::_::RawSchema s_870bf40110ce3035 = { + 0x870bf40110ce3035, b_870bf40110ce3035.words, 29, d_870bf40110ce3035, m_870bf40110ce3035, + 2, 1, nullptr, nullptr, nullptr, { &s_870bf40110ce3035, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_b07a279515dc8ac5 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 197, 138, 220, 21, 149, 39, 122, 176, + 26, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 97, 105, 108, 67, 97, 108, 108, 101, + 114, 46, 102, 111, 111, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 105, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 108, 108, 101, 101, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 59, 226, 184, 126, 32, 153, 214, 221, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b07a279515dc8ac5 = b_b07a279515dc8ac5.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_b07a279515dc8ac5[] = { + &s_ddd699207eb8e23b, +}; +static const uint16_t m_b07a279515dc8ac5[] = {1, 0}; +static const uint16_t i_b07a279515dc8ac5[] = {0, 1}; +const ::capnp::_::RawSchema s_b07a279515dc8ac5 = { + 0xb07a279515dc8ac5, b_b07a279515dc8ac5.words, 48, d_b07a279515dc8ac5, m_b07a279515dc8ac5, + 1, 2, i_b07a279515dc8ac5, nullptr, nullptr, { &s_b07a279515dc8ac5, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_a38e5efe41e53a15 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 21, 58, 229, 65, 254, 94, 142, 163, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 25, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 72, + 97, 110, 100, 108, 101, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_a38e5efe41e53a15 = b_a38e5efe41e53a15.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a38e5efe41e53a15 = { + 0xa38e5efe41e53a15, b_a38e5efe41e53a15.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a38e5efe41e53a15, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<163> b_ddc70bf9784133cf = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 207, 51, 65, 120, 249, 11, 199, 221, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 71, 3, 0, 0, + 85, 2, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 52, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 246, 96, 218, 24, 164, 27, 147, + 208, 205, 206, 236, 11, 151, 40, 154, + 145, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 1, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 120, 99, 190, 46, 12, 112, 188, 250, + 144, 47, 130, 170, 233, 225, 76, 165, + 121, 1, 0, 0, 162, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 1, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 43, 24, 149, 92, 70, 96, 254, 148, + 220, 197, 153, 105, 250, 229, 244, 222, + 105, 1, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 1, 0, 0, 7, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 88, 142, 157, 118, 187, 143, 124, 254, + 201, 3, 208, 116, 19, 251, 57, 248, + 85, 1, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 1, 0, 0, 7, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 190, 131, 223, 30, 239, 229, 197, 248, + 120, 117, 172, 96, 241, 53, 153, 229, + 61, 1, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 1, 0, 0, 7, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 227, 23, 227, 252, 37, 192, 255, 254, + 206, 103, 175, 133, 97, 20, 78, 239, + 41, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 7, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 185, 51, 229, 226, 247, 38, 117, 192, + 146, 91, 61, 89, 54, 69, 34, 166, + 17, 1, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 1, 0, 0, 7, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 177, 222, 62, 127, 216, 50, 204, 161, + 110, 145, 192, 88, 23, 186, 62, 138, + 249, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 241, 0, 0, 0, 7, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 241, 251, 80, 250, 37, 10, 22, 153, + 86, 108, 90, 132, 111, 6, 126, 156, + 229, 0, 0, 0, 154, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 7, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 161, 146, 160, 1, 163, 36, 208, 234, + 232, 31, 10, 66, 117, 13, 73, 195, + 213, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 0, 7, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 242, 97, 93, 23, 14, 63, 73, 216, + 113, 54, 2, 241, 142, 93, 149, 230, + 193, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 0, 0, 0, 7, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 122, 208, 93, 245, 54, 244, 93, 128, + 176, 37, 57, 220, 18, 117, 14, 134, + 169, 0, 0, 0, 146, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 165, 0, 0, 0, 7, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 79, 231, 14, 235, 154, 137, 146, 251, + 247, 92, 48, 71, 130, 52, 103, 132, + 153, 0, 0, 0, 178, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 0, 0, 0, 7, 0, 0, 0, + 99, 97, 108, 108, 70, 111, 111, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 97, 108, 108, 70, 111, 111, 87, + 104, 101, 110, 82, 101, 115, 111, 108, + 118, 101, 100, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 110, 101, 118, 101, 114, 82, 101, 116, + 117, 114, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 104, 111, 108, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 97, 108, 108, 72, 101, 108, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 101, 116, 72, 101, 108, 100, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 101, 99, 104, 111, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 101, 120, 112, 101, 99, 116, 67, 97, + 110, 99, 101, 108, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 109, 101, 116, 104, 111, 100, 87, 105, + 116, 104, 68, 101, 102, 97, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 101, 116, 72, 97, 110, 100, 108, + 101, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 101, 116, 78, 117, 108, 108, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 103, 101, 116, 69, 110, 111, 114, 109, + 111, 117, 115, 83, 116, 114, 105, 110, + 103, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 109, 101, 116, 104, 111, 100, 87, 105, + 116, 104, 78, 117, 108, 108, 68, 101, + 102, 97, 117, 108, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 81, 0, 255, 189, 53, 112, 231, 160, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ddc70bf9784133cf = b_ddc70bf9784133cf.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ddc70bf9784133cf[] = { + &s_805df436f55dd07a, + &s_8467348247305cf7, + &s_860e7512dc3925b0, + &s_8a3eba1758c0916e, + &s_931ba418da60f6e4, + &s_94fe60465c95182b, + &s_99160a25fa50fbf1, + &s_9a28970beccecdd0, + &s_9c7e066f845a6c56, + &s_a0e77035bdff0051, + &s_a1cc32d87f3edeb1, + &s_a54ce1e9aa822f90, + &s_a6224536593d5b92, + &s_c07526f7e2e533b9, + &s_c3490d75420a1fe8, + &s_d8493f0e175d61f2, + &s_def4e5fa6999c5dc, + &s_e59935f160ac7578, + &s_e6955d8ef1023671, + &s_ead024a301a092a1, + &s_ef4e146185af67ce, + &s_f839fb1374d003c9, + &s_f8c5e5ef1edf83be, + &s_fabc700c2ebe6378, + &s_fb92899aeb0ee74f, + &s_fe7c8fbb769d8e58, + &s_feffc025fce317e3, +}; +static const uint16_t m_ddc70bf9784133cf[] = {0, 1, 4, 6, 7, 11, 9, 5, 10, 3, 8, 12, 2}; +const ::capnp::_::RawSchema s_ddc70bf9784133cf = { + 0xddc70bf9784133cf, b_ddc70bf9784133cf.words, 163, d_ddc70bf9784133cf, m_ddc70bf9784133cf, + 27, 13, nullptr, nullptr, nullptr, { &s_ddc70bf9784133cf, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_931ba418da60f6e4 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 228, 246, 96, 218, 24, 164, 27, 147, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 70, 111, 111, + 36, 80, 97, 114, 97, 109, 115, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_931ba418da60f6e4 = b_931ba418da60f6e4.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_931ba418da60f6e4[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_931ba418da60f6e4[] = {0}; +static const uint16_t i_931ba418da60f6e4[] = {0}; +const ::capnp::_::RawSchema s_931ba418da60f6e4 = { + 0x931ba418da60f6e4, b_931ba418da60f6e4.words, 33, d_931ba418da60f6e4, m_931ba418da60f6e4, + 1, 1, i_931ba418da60f6e4, nullptr, nullptr, { &s_931ba418da60f6e4, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_9a28970beccecdd0 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 208, 205, 206, 236, 11, 151, 40, 154, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 70, 111, 111, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9a28970beccecdd0 = b_9a28970beccecdd0.words; +#if !CAPNP_LITE +static const uint16_t m_9a28970beccecdd0[] = {0}; +static const uint16_t i_9a28970beccecdd0[] = {0}; +const ::capnp::_::RawSchema s_9a28970beccecdd0 = { + 0x9a28970beccecdd0, b_9a28970beccecdd0.words, 34, nullptr, m_9a28970beccecdd0, + 0, 1, i_9a28970beccecdd0, nullptr, nullptr, { &s_9a28970beccecdd0, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_fabc700c2ebe6378 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 120, 99, 190, 46, 12, 112, 188, 250, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 162, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 70, 111, 111, + 87, 104, 101, 110, 82, 101, 115, 111, + 108, 118, 101, 100, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fabc700c2ebe6378 = b_fabc700c2ebe6378.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_fabc700c2ebe6378[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_fabc700c2ebe6378[] = {0}; +static const uint16_t i_fabc700c2ebe6378[] = {0}; +const ::capnp::_::RawSchema s_fabc700c2ebe6378 = { + 0xfabc700c2ebe6378, b_fabc700c2ebe6378.words, 35, d_fabc700c2ebe6378, m_fabc700c2ebe6378, + 1, 1, i_fabc700c2ebe6378, nullptr, nullptr, { &s_fabc700c2ebe6378, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_a54ce1e9aa822f90 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 144, 47, 130, 170, 233, 225, 76, 165, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 170, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 70, 111, 111, + 87, 104, 101, 110, 82, 101, 115, 111, + 108, 118, 101, 100, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a54ce1e9aa822f90 = b_a54ce1e9aa822f90.words; +#if !CAPNP_LITE +static const uint16_t m_a54ce1e9aa822f90[] = {0}; +static const uint16_t i_a54ce1e9aa822f90[] = {0}; +const ::capnp::_::RawSchema s_a54ce1e9aa822f90 = { + 0xa54ce1e9aa822f90, b_a54ce1e9aa822f90.words, 35, nullptr, m_a54ce1e9aa822f90, + 0, 1, i_a54ce1e9aa822f90, nullptr, nullptr, { &s_a54ce1e9aa822f90, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_94fe60465c95182b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 43, 24, 149, 92, 70, 96, 254, 148, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 110, 101, 118, 101, 114, 82, 101, + 116, 117, 114, 110, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_94fe60465c95182b = b_94fe60465c95182b.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_94fe60465c95182b[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_94fe60465c95182b[] = {0}; +static const uint16_t i_94fe60465c95182b[] = {0}; +const ::capnp::_::RawSchema s_94fe60465c95182b = { + 0x94fe60465c95182b, b_94fe60465c95182b.words, 34, d_94fe60465c95182b, m_94fe60465c95182b, + 1, 1, i_94fe60465c95182b, nullptr, nullptr, { &s_94fe60465c95182b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_def4e5fa6999c5dc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 220, 197, 153, 105, 250, 229, 244, 222, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 110, 101, 118, 101, 114, 82, 101, + 116, 117, 114, 110, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 67, 111, 112, 121, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_def4e5fa6999c5dc = b_def4e5fa6999c5dc.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_def4e5fa6999c5dc[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_def4e5fa6999c5dc[] = {0}; +static const uint16_t i_def4e5fa6999c5dc[] = {0}; +const ::capnp::_::RawSchema s_def4e5fa6999c5dc = { + 0xdef4e5fa6999c5dc, b_def4e5fa6999c5dc.words, 34, d_def4e5fa6999c5dc, m_def4e5fa6999c5dc, + 1, 1, i_def4e5fa6999c5dc, nullptr, nullptr, { &s_def4e5fa6999c5dc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_fe7c8fbb769d8e58 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 88, 142, 157, 118, 187, 143, 124, 254, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 104, 111, 108, 100, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fe7c8fbb769d8e58 = b_fe7c8fbb769d8e58.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_fe7c8fbb769d8e58[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_fe7c8fbb769d8e58[] = {0}; +static const uint16_t i_fe7c8fbb769d8e58[] = {0}; +const ::capnp::_::RawSchema s_fe7c8fbb769d8e58 = { + 0xfe7c8fbb769d8e58, b_fe7c8fbb769d8e58.words, 33, d_fe7c8fbb769d8e58, m_fe7c8fbb769d8e58, + 1, 1, i_fe7c8fbb769d8e58, nullptr, nullptr, { &s_fe7c8fbb769d8e58, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_f839fb1374d003c9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 201, 3, 208, 116, 19, 251, 57, 248, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 104, 111, 108, 100, 36, 82, 101, + 115, 117, 108, 116, 115, 0, 0, 0, } +}; +::capnp::word const* const bp_f839fb1374d003c9 = b_f839fb1374d003c9.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f839fb1374d003c9 = { + 0xf839fb1374d003c9, b_f839fb1374d003c9.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f839fb1374d003c9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_f8c5e5ef1edf83be = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 190, 131, 223, 30, 239, 229, 197, 248, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 72, 101, 108, + 100, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f8c5e5ef1edf83be = b_f8c5e5ef1edf83be.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f8c5e5ef1edf83be = { + 0xf8c5e5ef1edf83be, b_f8c5e5ef1edf83be.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f8c5e5ef1edf83be, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_e59935f160ac7578 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 120, 117, 172, 96, 241, 53, 153, 229, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 99, 97, 108, 108, 72, 101, 108, + 100, 36, 82, 101, 115, 117, 108, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e59935f160ac7578 = b_e59935f160ac7578.words; +#if !CAPNP_LITE +static const uint16_t m_e59935f160ac7578[] = {0}; +static const uint16_t i_e59935f160ac7578[] = {0}; +const ::capnp::_::RawSchema s_e59935f160ac7578 = { + 0xe59935f160ac7578, b_e59935f160ac7578.words, 34, nullptr, m_e59935f160ac7578, + 0, 1, i_e59935f160ac7578, nullptr, nullptr, { &s_e59935f160ac7578, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_feffc025fce317e3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 227, 23, 227, 252, 37, 192, 255, 254, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 72, 101, 108, 100, + 36, 80, 97, 114, 97, 109, 115, 0, } +}; +::capnp::word const* const bp_feffc025fce317e3 = b_feffc025fce317e3.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_feffc025fce317e3 = { + 0xfeffc025fce317e3, b_feffc025fce317e3.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_feffc025fce317e3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_ef4e146185af67ce = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 206, 103, 175, 133, 97, 20, 78, 239, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 72, 101, 108, 100, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ef4e146185af67ce = b_ef4e146185af67ce.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ef4e146185af67ce[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_ef4e146185af67ce[] = {0}; +static const uint16_t i_ef4e146185af67ce[] = {0}; +const ::capnp::_::RawSchema s_ef4e146185af67ce = { + 0xef4e146185af67ce, b_ef4e146185af67ce.words, 34, d_ef4e146185af67ce, m_ef4e146185af67ce, + 1, 1, i_ef4e146185af67ce, nullptr, nullptr, { &s_ef4e146185af67ce, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_c07526f7e2e533b9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 185, 51, 229, 226, 247, 38, 117, 192, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 101, 99, 104, 111, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 255, 189, 53, 112, 231, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c07526f7e2e533b9 = b_c07526f7e2e533b9.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c07526f7e2e533b9[] = { + &s_a0e77035bdff0051, +}; +static const uint16_t m_c07526f7e2e533b9[] = {0}; +static const uint16_t i_c07526f7e2e533b9[] = {0}; +const ::capnp::_::RawSchema s_c07526f7e2e533b9 = { + 0xc07526f7e2e533b9, b_c07526f7e2e533b9.words, 33, d_c07526f7e2e533b9, m_c07526f7e2e533b9, + 1, 1, i_c07526f7e2e533b9, nullptr, nullptr, { &s_c07526f7e2e533b9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_a6224536593d5b92 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 146, 91, 61, 89, 54, 69, 34, 166, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 101, 99, 104, 111, 36, 82, 101, + 115, 117, 108, 116, 115, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 255, 189, 53, 112, 231, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a6224536593d5b92 = b_a6224536593d5b92.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a6224536593d5b92[] = { + &s_a0e77035bdff0051, +}; +static const uint16_t m_a6224536593d5b92[] = {0}; +static const uint16_t i_a6224536593d5b92[] = {0}; +const ::capnp::_::RawSchema s_a6224536593d5b92 = { + 0xa6224536593d5b92, b_a6224536593d5b92.words, 33, d_a6224536593d5b92, m_a6224536593d5b92, + 1, 1, i_a6224536593d5b92, nullptr, nullptr, { &s_a6224536593d5b92, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_a1cc32d87f3edeb1 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 177, 222, 62, 127, 216, 50, 204, 161, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 101, 120, 112, 101, 99, 116, 67, + 97, 110, 99, 101, 108, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a1cc32d87f3edeb1 = b_a1cc32d87f3edeb1.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_a1cc32d87f3edeb1[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_a1cc32d87f3edeb1[] = {0}; +static const uint16_t i_a1cc32d87f3edeb1[] = {0}; +const ::capnp::_::RawSchema s_a1cc32d87f3edeb1 = { + 0xa1cc32d87f3edeb1, b_a1cc32d87f3edeb1.words, 34, d_a1cc32d87f3edeb1, m_a1cc32d87f3edeb1, + 1, 1, i_a1cc32d87f3edeb1, nullptr, nullptr, { &s_a1cc32d87f3edeb1, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_8a3eba1758c0916e = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 110, 145, 192, 88, 23, 186, 62, 138, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 101, 120, 112, 101, 99, 116, 67, + 97, 110, 99, 101, 108, 36, 82, 101, + 115, 117, 108, 116, 115, 0, 0, 0, } +}; +::capnp::word const* const bp_8a3eba1758c0916e = b_8a3eba1758c0916e.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8a3eba1758c0916e = { + 0x8a3eba1758c0916e, b_8a3eba1758c0916e.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8a3eba1758c0916e, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<66> b_99160a25fa50fbf1 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 241, 251, 80, 250, 37, 10, 22, 153, + 25, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 109, 101, 116, 104, 111, 100, 87, + 105, 116, 104, 68, 101, 102, 97, 117, + 108, 116, 115, 36, 80, 97, 114, 97, + 109, 115, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 97, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 123, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_99160a25fa50fbf1 = b_99160a25fa50fbf1.words; +#if !CAPNP_LITE +static const uint16_t m_99160a25fa50fbf1[] = {0, 1, 2}; +static const uint16_t i_99160a25fa50fbf1[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_99160a25fa50fbf1 = { + 0x99160a25fa50fbf1, b_99160a25fa50fbf1.words, 66, nullptr, m_99160a25fa50fbf1, + 0, 3, i_99160a25fa50fbf1, nullptr, nullptr, { &s_99160a25fa50fbf1, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<51> b_9c7e066f845a6c56 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 86, 108, 90, 132, 111, 6, 126, 156, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 162, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 109, 101, 116, 104, 111, 100, 87, + 105, 116, 104, 68, 101, 102, 97, 117, + 108, 116, 115, 36, 82, 101, 115, 117, + 108, 116, 115, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9c7e066f845a6c56 = b_9c7e066f845a6c56.words; +#if !CAPNP_LITE +static const uint16_t m_9c7e066f845a6c56[] = {0, 1}; +static const uint16_t i_9c7e066f845a6c56[] = {0, 1}; +const ::capnp::_::RawSchema s_9c7e066f845a6c56 = { + 0x9c7e066f845a6c56, b_9c7e066f845a6c56.words, 51, nullptr, m_9c7e066f845a6c56, + 0, 2, i_9c7e066f845a6c56, nullptr, nullptr, { &s_9c7e066f845a6c56, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_ead024a301a092a1 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 161, 146, 160, 1, 163, 36, 208, 234, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 72, 97, 110, 100, + 108, 101, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ead024a301a092a1 = b_ead024a301a092a1.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ead024a301a092a1 = { + 0xead024a301a092a1, b_ead024a301a092a1.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ead024a301a092a1, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_c3490d75420a1fe8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 232, 31, 10, 66, 117, 13, 73, 195, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 72, 97, 110, 100, + 108, 101, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 104, 97, 110, 100, 108, 101, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 21, 58, 229, 65, 254, 94, 142, 163, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c3490d75420a1fe8 = b_c3490d75420a1fe8.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c3490d75420a1fe8[] = { + &s_a38e5efe41e53a15, +}; +static const uint16_t m_c3490d75420a1fe8[] = {0}; +static const uint16_t i_c3490d75420a1fe8[] = {0}; +const ::capnp::_::RawSchema s_c3490d75420a1fe8 = { + 0xc3490d75420a1fe8, b_c3490d75420a1fe8.words, 34, d_c3490d75420a1fe8, m_c3490d75420a1fe8, + 1, 1, i_c3490d75420a1fe8, nullptr, nullptr, { &s_c3490d75420a1fe8, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_d8493f0e175d61f2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 242, 97, 93, 23, 14, 63, 73, 216, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 78, 117, 108, 108, + 36, 80, 97, 114, 97, 109, 115, 0, } +}; +::capnp::word const* const bp_d8493f0e175d61f2 = b_d8493f0e175d61f2.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d8493f0e175d61f2 = { + 0xd8493f0e175d61f2, b_d8493f0e175d61f2.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d8493f0e175d61f2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_e6955d8ef1023671 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 113, 54, 2, 241, 142, 93, 149, 230, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 78, 117, 108, 108, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 110, 117, 108, 108, 67, 97, 112, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 207, 51, 65, 120, 249, 11, 199, 221, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e6955d8ef1023671 = b_e6955d8ef1023671.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e6955d8ef1023671[] = { + &s_ddc70bf9784133cf, +}; +static const uint16_t m_e6955d8ef1023671[] = {0}; +static const uint16_t i_e6955d8ef1023671[] = {0}; +const ::capnp::_::RawSchema s_e6955d8ef1023671 = { + 0xe6955d8ef1023671, b_e6955d8ef1023671.words, 34, d_e6955d8ef1023671, m_e6955d8ef1023671, + 1, 1, i_e6955d8ef1023671, nullptr, nullptr, { &s_e6955d8ef1023671, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<19> b_805df436f55dd07a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 122, 208, 93, 245, 54, 244, 93, 128, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 146, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 69, 110, 111, 114, + 109, 111, 117, 115, 83, 116, 114, 105, + 110, 103, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_805df436f55dd07a = b_805df436f55dd07a.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_805df436f55dd07a = { + 0x805df436f55dd07a, b_805df436f55dd07a.words, 19, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_805df436f55dd07a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<35> b_860e7512dc3925b0 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 176, 37, 57, 220, 18, 117, 14, 134, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 154, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 103, 101, 116, 69, 110, 111, 114, + 109, 111, 117, 115, 83, 116, 114, 105, + 110, 103, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 115, 116, 114, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_860e7512dc3925b0 = b_860e7512dc3925b0.words; +#if !CAPNP_LITE +static const uint16_t m_860e7512dc3925b0[] = {0}; +static const uint16_t i_860e7512dc3925b0[] = {0}; +const ::capnp::_::RawSchema s_860e7512dc3925b0 = { + 0x860e7512dc3925b0, b_860e7512dc3925b0.words, 35, nullptr, m_860e7512dc3925b0, + 0, 1, i_860e7512dc3925b0, nullptr, nullptr, { &s_860e7512dc3925b0, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<50> b_fb92899aeb0ee74f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 79, 231, 14, 235, 154, 137, 146, 251, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 178, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 109, 101, 116, 104, 111, 100, 87, + 105, 116, 104, 78, 117, 108, 108, 68, + 101, 102, 97, 117, 108, 116, 36, 80, + 97, 114, 97, 109, 115, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 97, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_fb92899aeb0ee74f = b_fb92899aeb0ee74f.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_fb92899aeb0ee74f[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_fb92899aeb0ee74f[] = {0, 1}; +static const uint16_t i_fb92899aeb0ee74f[] = {0, 1}; +const ::capnp::_::RawSchema s_fb92899aeb0ee74f = { + 0xfb92899aeb0ee74f, b_fb92899aeb0ee74f.words, 50, d_fb92899aeb0ee74f, m_fb92899aeb0ee74f, + 1, 2, i_fb92899aeb0ee74f, nullptr, nullptr, { &s_fb92899aeb0ee74f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<19> b_8467348247305cf7 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 247, 92, 48, 71, 130, 52, 103, 132, + 25, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 186, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 111, 114, 101, 83, 116, 117, 102, 102, + 46, 109, 101, 116, 104, 111, 100, 87, + 105, 116, 104, 78, 117, 108, 108, 68, + 101, 102, 97, 117, 108, 116, 36, 82, + 101, 115, 117, 108, 116, 115, 0, 0, } +}; +::capnp::word const* const bp_8467348247305cf7 = b_8467348247305cf7.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8467348247305cf7 = { + 0x8467348247305cf7, b_8467348247305cf7.words, 19, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8467348247305cf7, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<79> b_c07d8dcd80a69c0c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 12, 156, 166, 128, 205, 141, 125, 192, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 194, 0, 0, 0, + 29, 0, 0, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 71, 1, 0, 0, + 13, 1, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 9, 0, 0, 0, 50, 0, 0, 0, + 101, 25, 41, 175, 63, 22, 198, 176, + 5, 0, 0, 0, 58, 0, 0, 0, + 84, 104, 105, 110, 103, 0, 0, 0, + 82, 101, 115, 117, 108, 116, 0, 0, + 20, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 86, 101, 206, 62, 204, 42, 172, 216, + 41, 191, 204, 20, 72, 144, 212, 229, + 145, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 137, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 218, 41, 106, 74, 99, 159, 93, 148, + 101, 25, 41, 175, 63, 22, 198, 176, + 125, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 0, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 113, 92, 92, 55, 195, 170, 73, 135, + 101, 25, 41, 175, 63, 22, 198, 176, + 105, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 7, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 201, 66, 75, 179, 122, 27, 154, 134, + 92, 171, 136, 253, 152, 147, 209, 236, + 85, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 7, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 255, 23, 41, 198, 12, 179, 107, 143, + 1, 190, 128, 114, 144, 164, 67, 195, + 65, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 57, 0, 0, 0, 7, 0, 0, 0, + 109, 97, 107, 101, 84, 104, 105, 110, + 103, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 97, 108, 108, 80, 97, 115, 115, + 84, 104, 114, 111, 117, 103, 104, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 97, 108, 108, 73, 110, 116, 101, + 114, 99, 101, 112, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 108, 111, 111, 112, 98, 97, 99, 107, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 119, 97, 105, 116, 70, 111, 114, 101, + 118, 101, 114, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_c07d8dcd80a69c0c = b_c07d8dcd80a69c0c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c07d8dcd80a69c0c[] = { + &s_869a1b7ab34b42c9, + &s_8749aac3375c5c71, + &s_8f6bb30cc62917ff, + &s_945d9f634a6a29da, + &s_b0c6163faf291965, + &s_c343a4907280be01, + &s_d8ac2acc3ece6556, + &s_e5d4904814ccbf29, + &s_ecd19398fd88ab5c, +}; +static const uint16_t m_c07d8dcd80a69c0c[] = {2, 1, 3, 0, 4}; +const ::capnp::_::RawSchema s_c07d8dcd80a69c0c = { + 0xc07d8dcd80a69c0c, b_c07d8dcd80a69c0c.words, 79, d_c07d8dcd80a69c0c, m_c07d8dcd80a69c0c, + 9, 5, nullptr, nullptr, nullptr, { &s_c07d8dcd80a69c0c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<41> b_9352e4e41f173917 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 24, 0, 0, 0, 3, 0, 0, 0, + 12, 156, 166, 128, 205, 141, 125, 192, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 135, 0, 0, 0, + 117, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 84, 104, 105, 110, 103, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 134, 215, 133, 80, 208, 220, 155, 255, + 101, 25, 41, 175, 63, 22, 198, 176, + 49, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 69, 231, 94, 97, 211, 190, 148, 238, + 101, 25, 41, 175, 63, 22, 198, 176, + 29, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 112, 97, 115, 115, 84, 104, 114, 111, + 117, 103, 104, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 105, 110, 116, 101, 114, 99, 101, 112, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_9352e4e41f173917 = b_9352e4e41f173917.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_9352e4e41f173917[] = { + &s_b0c6163faf291965, + &s_ee94bed3615ee745, + &s_ff9bdcd05085d786, +}; +static const uint16_t m_9352e4e41f173917[] = {1, 0}; +const ::capnp::_::RawSchema s_9352e4e41f173917 = { + 0x9352e4e41f173917, b_9352e4e41f173917.words, 41, d_9352e4e41f173917, m_9352e4e41f173917, + 3, 2, nullptr, nullptr, nullptr, { &s_9352e4e41f173917, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<19> b_ff9bdcd05085d786 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 134, 215, 133, 80, 208, 220, 155, 255, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 138, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 84, 104, 105, 110, 103, 46, 112, 97, + 115, 115, 84, 104, 114, 111, 117, 103, + 104, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ff9bdcd05085d786 = b_ff9bdcd05085d786.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ff9bdcd05085d786 = { + 0xff9bdcd05085d786, b_ff9bdcd05085d786.words, 19, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ff9bdcd05085d786, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_ee94bed3615ee745 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 69, 231, 94, 97, 211, 190, 148, 238, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 84, 104, 105, 110, 103, 46, 105, 110, + 116, 101, 114, 99, 101, 112, 116, 36, + 80, 97, 114, 97, 109, 115, 0, 0, } +}; +::capnp::word const* const bp_ee94bed3615ee745 = b_ee94bed3615ee745.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ee94bed3615ee745 = { + 0xee94bed3615ee745, b_ee94bed3615ee745.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ee94bed3615ee745, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_b0c6163faf291965 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 101, 25, 41, 175, 63, 22, 198, 176, + 24, 0, 0, 0, 1, 0, 0, 0, + 12, 156, 166, 128, 205, 141, 125, 192, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 82, 101, 115, 117, 108, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b0c6163faf291965 = b_b0c6163faf291965.words; +#if !CAPNP_LITE +static const uint16_t m_b0c6163faf291965[] = {0}; +static const uint16_t i_b0c6163faf291965[] = {0}; +const ::capnp::_::RawSchema s_b0c6163faf291965 = { + 0xb0c6163faf291965, b_b0c6163faf291965.words, 33, nullptr, m_b0c6163faf291965, + 0, 1, i_b0c6163faf291965, nullptr, nullptr, { &s_b0c6163faf291965, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_d8ac2acc3ece6556 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 86, 101, 206, 62, 204, 42, 172, 216, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 109, 97, 107, 101, 84, 104, 105, 110, + 103, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d8ac2acc3ece6556 = b_d8ac2acc3ece6556.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_d8ac2acc3ece6556 = { + 0xd8ac2acc3ece6556, b_d8ac2acc3ece6556.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_d8ac2acc3ece6556, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_e5d4904814ccbf29 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 41, 191, 204, 20, 72, 144, 212, 229, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 109, 97, 107, 101, 84, 104, 105, 110, + 103, 36, 82, 101, 115, 117, 108, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 116, 104, 105, 110, 103, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e5d4904814ccbf29 = b_e5d4904814ccbf29.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_e5d4904814ccbf29[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_e5d4904814ccbf29[] = {0}; +static const uint16_t i_e5d4904814ccbf29[] = {0}; +const ::capnp::_::RawSchema s_e5d4904814ccbf29 = { + 0xe5d4904814ccbf29, b_e5d4904814ccbf29.words, 34, d_e5d4904814ccbf29, m_e5d4904814ccbf29, + 1, 1, i_e5d4904814ccbf29, nullptr, nullptr, { &s_e5d4904814ccbf29, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<50> b_945d9f634a6a29da = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 218, 41, 106, 74, 99, 159, 93, 148, + 24, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 122, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 99, 97, 108, 108, 80, 97, 115, 115, + 84, 104, 114, 111, 117, 103, 104, 36, + 80, 97, 114, 97, 109, 115, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 3, 0, 1, 0, + 56, 0, 0, 0, 2, 0, 1, 0, + 116, 104, 105, 110, 103, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 97, 105, 108, 67, 97, 108, 108, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_945d9f634a6a29da = b_945d9f634a6a29da.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_945d9f634a6a29da[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_945d9f634a6a29da[] = {1, 0}; +static const uint16_t i_945d9f634a6a29da[] = {0, 1}; +const ::capnp::_::RawSchema s_945d9f634a6a29da = { + 0x945d9f634a6a29da, b_945d9f634a6a29da.words, 50, d_945d9f634a6a29da, m_945d9f634a6a29da, + 1, 2, i_945d9f634a6a29da, nullptr, nullptr, { &s_945d9f634a6a29da, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<50> b_8749aac3375c5c71 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 113, 92, 92, 55, 195, 170, 73, 135, + 24, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 99, 97, 108, 108, 73, 110, 116, 101, + 114, 99, 101, 112, 116, 36, 80, 97, + 114, 97, 109, 115, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 3, 0, 1, 0, + 56, 0, 0, 0, 2, 0, 1, 0, + 116, 104, 105, 110, 103, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 97, 105, 108, 67, 97, 108, 108, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8749aac3375c5c71 = b_8749aac3375c5c71.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8749aac3375c5c71[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_8749aac3375c5c71[] = {1, 0}; +static const uint16_t i_8749aac3375c5c71[] = {0, 1}; +const ::capnp::_::RawSchema s_8749aac3375c5c71 = { + 0x8749aac3375c5c71, b_8749aac3375c5c71.words, 50, d_8749aac3375c5c71, m_8749aac3375c5c71, + 1, 2, i_8749aac3375c5c71, nullptr, nullptr, { &s_8749aac3375c5c71, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_869a1b7ab34b42c9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 201, 66, 75, 179, 122, 27, 154, 134, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 108, 111, 111, 112, 98, 97, 99, 107, + 36, 80, 97, 114, 97, 109, 115, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 116, 104, 105, 110, 103, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_869a1b7ab34b42c9 = b_869a1b7ab34b42c9.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_869a1b7ab34b42c9[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_869a1b7ab34b42c9[] = {0}; +static const uint16_t i_869a1b7ab34b42c9[] = {0}; +const ::capnp::_::RawSchema s_869a1b7ab34b42c9 = { + 0x869a1b7ab34b42c9, b_869a1b7ab34b42c9.words, 33, d_869a1b7ab34b42c9, m_869a1b7ab34b42c9, + 1, 1, i_869a1b7ab34b42c9, nullptr, nullptr, { &s_869a1b7ab34b42c9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<34> b_ecd19398fd88ab5c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 92, 171, 136, 253, 152, 147, 209, 236, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 108, 111, 111, 112, 98, 97, 99, 107, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 116, 104, 105, 110, 103, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ecd19398fd88ab5c = b_ecd19398fd88ab5c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ecd19398fd88ab5c[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_ecd19398fd88ab5c[] = {0}; +static const uint16_t i_ecd19398fd88ab5c[] = {0}; +const ::capnp::_::RawSchema s_ecd19398fd88ab5c = { + 0xecd19398fd88ab5c, b_ecd19398fd88ab5c.words, 34, d_ecd19398fd88ab5c, m_ecd19398fd88ab5c, + 1, 1, i_ecd19398fd88ab5c, nullptr, nullptr, { &s_ecd19398fd88ab5c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_8f6bb30cc62917ff = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 255, 23, 41, 198, 12, 179, 107, 143, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 119, 97, 105, 116, 70, 111, 114, 101, + 118, 101, 114, 36, 80, 97, 114, 97, + 109, 115, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8f6bb30cc62917ff = b_8f6bb30cc62917ff.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8f6bb30cc62917ff = { + 0x8f6bb30cc62917ff, b_8f6bb30cc62917ff.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8f6bb30cc62917ff, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_c343a4907280be01 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 1, 190, 128, 114, 144, 164, 67, 195, + 24, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 77, + 101, 109, 98, 114, 97, 110, 101, 46, + 119, 97, 105, 116, 70, 111, 114, 101, + 118, 101, 114, 36, 82, 101, 115, 117, + 108, 116, 115, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c343a4907280be01 = b_c343a4907280be01.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c343a4907280be01 = { + 0xc343a4907280be01, b_c343a4907280be01.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c343a4907280be01, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<52> b_949449ad7c11fa5c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 92, 250, 17, 124, 173, 73, 148, 148, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 67, + 111, 110, 116, 97, 105, 110, 77, 101, + 109, 98, 114, 97, 110, 101, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 68, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 23, 57, 23, 31, 228, 228, 82, 147, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_949449ad7c11fa5c = b_949449ad7c11fa5c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_949449ad7c11fa5c[] = { + &s_9352e4e41f173917, +}; +static const uint16_t m_949449ad7c11fa5c[] = {0, 1}; +static const uint16_t i_949449ad7c11fa5c[] = {0, 1}; +const ::capnp::_::RawSchema s_949449ad7c11fa5c = { + 0x949449ad7c11fa5c, b_949449ad7c11fa5c.words, 52, d_949449ad7c11fa5c, m_949449ad7c11fa5c, + 1, 2, i_949449ad7c11fa5c, nullptr, nullptr, { &s_949449ad7c11fa5c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<40> b_dd2b66a791a279f0 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 240, 121, 162, 145, 167, 102, 43, 221, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 114, 97, 110, 115, 102, 101, 114, 67, + 97, 112, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 188, 74, 132, 136, 143, 62, 38, 199, + 1, 0, 0, 0, 66, 0, 0, 0, + 69, 108, 101, 109, 101, 110, 116, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 108, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 188, 74, 132, 136, 143, 62, 38, 199, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_dd2b66a791a279f0 = b_dd2b66a791a279f0.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_dd2b66a791a279f0[] = { + &s_c7263e8f88844abc, +}; +static const uint16_t m_dd2b66a791a279f0[] = {0}; +static const uint16_t i_dd2b66a791a279f0[] = {0}; +const ::capnp::_::RawSchema s_dd2b66a791a279f0 = { + 0xdd2b66a791a279f0, b_dd2b66a791a279f0.words, 40, d_dd2b66a791a279f0, m_dd2b66a791a279f0, + 1, 1, i_dd2b66a791a279f0, nullptr, nullptr, { &s_dd2b66a791a279f0, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_c7263e8f88844abc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 188, 74, 132, 136, 143, 62, 38, 199, + 27, 0, 0, 0, 1, 0, 0, 0, + 240, 121, 162, 145, 167, 102, 43, 221, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 114, 97, 110, 115, 102, 101, 114, 67, + 97, 112, 46, 69, 108, 101, 109, 101, + 110, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 116, 101, 120, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c7263e8f88844abc = b_c7263e8f88844abc.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c7263e8f88844abc[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_c7263e8f88844abc[] = {1, 0}; +static const uint16_t i_c7263e8f88844abc[] = {0, 1}; +const ::capnp::_::RawSchema s_c7263e8f88844abc = { + 0xc7263e8f88844abc, b_c7263e8f88844abc.words, 49, d_c7263e8f88844abc, m_c7263e8f88844abc, + 1, 2, i_c7263e8f88844abc, nullptr, nullptr, { &s_c7263e8f88844abc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<59> b_9ae342d394247cfc = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 252, 124, 36, 148, 211, 66, 227, 154, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 7, 1, 0, 0, + 189, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 183, 214, 107, 235, 205, 137, 58, 202, + 146, 117, 48, 152, 53, 132, 181, 238, + 113, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 54, 176, 93, 60, 49, 168, 245, 156, + 216, 231, 18, 172, 104, 56, 37, 192, + 89, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 7, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 87, 119, 60, 131, 99, 135, 160, 164, + 171, 174, 192, 137, 48, 119, 130, 222, + 65, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 7, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 163, 140, 94, 98, 96, 115, 129, 153, + 47, 153, 170, 126, 224, 114, 8, 183, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 100, 101, 108, 101, 116, 101, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 99, 108, 97, 115, 115, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 118, 111, 105, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 114, 101, 116, 117, 114, 110, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_9ae342d394247cfc = b_9ae342d394247cfc.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_9ae342d394247cfc[] = { + &s_99817360625e8ca3, + &s_9cf5a8313c5db036, + &s_a4a08763833c7757, + &s_b70872e07eaa992f, + &s_c0253868ac12e7d8, + &s_ca3a89cdeb6bd6b7, + &s_de82773089c0aeab, + &s_eeb5843598307592, +}; +static const uint16_t m_9ae342d394247cfc[] = {1, 0, 3, 2}; +const ::capnp::_::RawSchema s_9ae342d394247cfc = { + 0x9ae342d394247cfc, b_9ae342d394247cfc.words, 59, d_9ae342d394247cfc, m_9ae342d394247cfc, + 8, 4, nullptr, nullptr, nullptr, { &s_9ae342d394247cfc, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_ca3a89cdeb6bd6b7 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 183, 214, 107, 235, 205, 137, 58, 202, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 100, 101, + 108, 101, 116, 101, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ca3a89cdeb6bd6b7 = b_ca3a89cdeb6bd6b7.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ca3a89cdeb6bd6b7 = { + 0xca3a89cdeb6bd6b7, b_ca3a89cdeb6bd6b7.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ca3a89cdeb6bd6b7, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_eeb5843598307592 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 146, 117, 48, 152, 53, 132, 181, 238, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 100, 101, + 108, 101, 116, 101, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_eeb5843598307592 = b_eeb5843598307592.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_eeb5843598307592 = { + 0xeeb5843598307592, b_eeb5843598307592.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_eeb5843598307592, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_9cf5a8313c5db036 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 54, 176, 93, 60, 49, 168, 245, 156, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 99, 108, + 97, 115, 115, 36, 80, 97, 114, 97, + 109, 115, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_9cf5a8313c5db036 = b_9cf5a8313c5db036.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9cf5a8313c5db036 = { + 0x9cf5a8313c5db036, b_9cf5a8313c5db036.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9cf5a8313c5db036, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_c0253868ac12e7d8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 216, 231, 18, 172, 104, 56, 37, 192, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 99, 108, + 97, 115, 115, 36, 82, 101, 115, 117, + 108, 116, 115, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c0253868ac12e7d8 = b_c0253868ac12e7d8.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_c0253868ac12e7d8 = { + 0xc0253868ac12e7d8, b_c0253868ac12e7d8.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_c0253868ac12e7d8, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_a4a08763833c7757 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 87, 119, 60, 131, 99, 135, 160, 164, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 118, 111, + 105, 100, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_a4a08763833c7757 = b_a4a08763833c7757.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a4a08763833c7757 = { + 0xa4a08763833c7757, b_a4a08763833c7757.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a4a08763833c7757, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_de82773089c0aeab = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 171, 174, 192, 137, 48, 119, 130, 222, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 118, 111, + 105, 100, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_de82773089c0aeab = b_de82773089c0aeab.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_de82773089c0aeab = { + 0xde82773089c0aeab, b_de82773089c0aeab.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_de82773089c0aeab, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_99817360625e8ca3 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 163, 140, 94, 98, 96, 115, 129, 153, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 114, 101, + 116, 117, 114, 110, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_99817360625e8ca3 = b_99817360625e8ca3.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_99817360625e8ca3 = { + 0x99817360625e8ca3, b_99817360625e8ca3.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_99817360625e8ca3, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<18> b_b70872e07eaa992f = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 47, 153, 170, 126, 224, 114, 8, 183, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 75, + 101, 121, 119, 111, 114, 100, 77, 101, + 116, 104, 111, 100, 115, 46, 114, 101, + 116, 117, 114, 110, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_b70872e07eaa992f = b_b70872e07eaa992f.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_b70872e07eaa992f = { + 0xb70872e07eaa992f, b_b70872e07eaa992f.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_b70872e07eaa992f, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<44> b_ea72cc77253798cd = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 205, 152, 55, 37, 119, 204, 114, 234, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 71, 0, 0, 0, + 117, 0, 0, 0, 7, 0, 0, 0, + 117, 0, 0, 0, 15, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 117, 116, 104, 101, 110, 116, 105, 99, + 97, 116, 101, 100, 66, 111, 111, 116, + 115, 116, 114, 97, 112, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 254, 207, 241, 81, 36, 14, 195, 142, + 103, 62, 74, 3, 118, 247, 28, 199, + 17, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 1, 0, + 32, 0, 0, 0, 0, 0, 1, 0, + 49, 0, 0, 0, 7, 0, 0, 0, + 103, 101, 116, 67, 97, 108, 108, 101, + 114, 73, 100, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 205, 152, 55, 37, 119, 204, 114, 234, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 31, 0, 0, 0, + 4, 0, 0, 0, 2, 0, 1, 0, + 205, 152, 55, 37, 119, 204, 114, 234, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 50, 0, 0, 0, + 86, 97, 116, 73, 100, 0, 0, 0, } +}; +::capnp::word const* const bp_ea72cc77253798cd = b_ea72cc77253798cd.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ea72cc77253798cd[] = { + &s_8ec30e2451f1cffe, + &s_c71cf776034a3e67, +}; +static const uint16_t m_ea72cc77253798cd[] = {0}; +KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_ea72cc77253798cd[] = { + { 33554432, ::capnproto_test::capnp::test::TestAuthenticatedBootstrap< ::capnp::AnyPointer>::GetCallerIdParams::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestAuthenticatedBootstrap< ::capnp::AnyPointer>::GetCallerIdResults::_capnpPrivate::brand() }, +}; +const ::capnp::_::RawSchema s_ea72cc77253798cd = { + 0xea72cc77253798cd, b_ea72cc77253798cd.words, 44, d_ea72cc77253798cd, m_ea72cc77253798cd, + 2, 1, nullptr, nullptr, nullptr, { &s_ea72cc77253798cd, nullptr, bd_ea72cc77253798cd, 0, sizeof(bd_ea72cc77253798cd) / sizeof(bd_ea72cc77253798cd[0]), nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<20> b_8ec30e2451f1cffe = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 254, 207, 241, 81, 36, 14, 195, 142, + 38, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 202, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 117, 116, 104, 101, 110, 116, 105, 99, + 97, 116, 101, 100, 66, 111, 111, 116, + 115, 116, 114, 97, 112, 46, 103, 101, + 116, 67, 97, 108, 108, 101, 114, 73, + 100, 36, 80, 97, 114, 97, 109, 115, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_8ec30e2451f1cffe = b_8ec30e2451f1cffe.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_8ec30e2451f1cffe = { + 0x8ec30e2451f1cffe, b_8ec30e2451f1cffe.words, 20, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_8ec30e2451f1cffe, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<36> b_c71cf776034a3e67 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 103, 62, 74, 3, 118, 247, 28, 199, + 38, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 21, 0, 0, 0, 210, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 65, + 117, 116, 104, 101, 110, 116, 105, 99, + 97, 116, 101, 100, 66, 111, 111, 116, + 115, 116, 114, 97, 112, 46, 103, 101, + 116, 67, 97, 108, 108, 101, 114, 73, + 100, 36, 82, 101, 115, 117, 108, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 108, 108, 101, 114, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 205, 152, 55, 37, 119, 204, 114, 234, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c71cf776034a3e67 = b_c71cf776034a3e67.words; +#if !CAPNP_LITE +static const uint16_t m_c71cf776034a3e67[] = {0}; +static const uint16_t i_c71cf776034a3e67[] = {0}; +const ::capnp::_::RawSchema s_c71cf776034a3e67 = { + 0xc71cf776034a3e67, b_c71cf776034a3e67.words, 36, nullptr, m_c71cf776034a3e67, + 0, 1, i_c71cf776034a3e67, nullptr, nullptr, { &s_c71cf776034a3e67, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_ceba982cb629f6c2 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 194, 246, 41, 182, 44, 152, 186, 206, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 202, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 117, 114, 100, 121, 82, 101, 102, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 3, 0, 1, 0, + 56, 0, 0, 0, 2, 0, 1, 0, + 104, 111, 115, 116, 73, 100, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 66, 227, 16, 16, 190, 59, 45, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 98, 106, 101, 99, 116, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_ceba982cb629f6c2 = b_ceba982cb629f6c2.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_ceba982cb629f6c2[] = { + &s_e02d3bbe1010e342, +}; +static const uint16_t m_ceba982cb629f6c2[] = {0, 1}; +static const uint16_t i_ceba982cb629f6c2[] = {0, 1}; +const ::capnp::_::RawSchema s_ceba982cb629f6c2 = { + 0xceba982cb629f6c2, b_ceba982cb629f6c2.words, 49, d_ceba982cb629f6c2, m_ceba982cb629f6c2, + 1, 2, i_ceba982cb629f6c2, nullptr, nullptr, { &s_ceba982cb629f6c2, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<33> b_e02d3bbe1010e342 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 66, 227, 16, 16, 190, 59, 45, 224, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 117, 114, 100, 121, 82, 101, 102, + 72, 111, 115, 116, 73, 100, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 104, 111, 115, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_e02d3bbe1010e342 = b_e02d3bbe1010e342.words; +#if !CAPNP_LITE +static const uint16_t m_e02d3bbe1010e342[] = {0}; +static const uint16_t i_e02d3bbe1010e342[] = {0}; +const ::capnp::_::RawSchema s_e02d3bbe1010e342 = { + 0xe02d3bbe1010e342, b_e02d3bbe1010e342.words, 33, nullptr, m_e02d3bbe1010e342, + 0, 1, i_e02d3bbe1010e342, nullptr, nullptr, { &s_e02d3bbe1010e342, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<37> b_aeb2ad168e2f5697 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 151, 86, 47, 142, 22, 173, 178, 174, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 10, 1, 0, 0, + 37, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 117, 114, 100, 121, 82, 101, 102, + 79, 98, 106, 101, 99, 116, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 1, 0, 0, 0, 34, 0, 0, 0, + 84, 97, 103, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 116, 97, 103, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_aeb2ad168e2f5697 = b_aeb2ad168e2f5697.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_aeb2ad168e2f5697[] = { + &s_ef428f2f67c4d439, +}; +static const uint16_t m_aeb2ad168e2f5697[] = {0}; +static const uint16_t i_aeb2ad168e2f5697[] = {0}; +const ::capnp::_::RawSchema s_aeb2ad168e2f5697 = { + 0xaeb2ad168e2f5697, b_aeb2ad168e2f5697.words, 37, d_aeb2ad168e2f5697, m_aeb2ad168e2f5697, + 1, 1, i_aeb2ad168e2f5697, nullptr, nullptr, { &s_aeb2ad168e2f5697, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<49> b_ef428f2f67c4d439 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 33, 0, 0, 0, 2, 0, 0, 0, + 151, 86, 47, 142, 22, 173, 178, 174, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 42, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 151, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 83, + 116, 117, 114, 100, 121, 82, 101, 102, + 79, 98, 106, 101, 99, 116, 73, 100, + 46, 84, 97, 103, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 24, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 65, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 61, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 57, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 73, 110, 116, 101, + 114, 102, 97, 99, 101, 0, 0, 0, + 116, 101, 115, 116, 69, 120, 116, 101, + 110, 100, 115, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 80, 105, 112, 101, + 108, 105, 110, 101, 0, 0, 0, 0, + 116, 101, 115, 116, 84, 97, 105, 108, + 67, 97, 108, 108, 101, 101, 0, 0, + 116, 101, 115, 116, 84, 97, 105, 108, + 67, 97, 108, 108, 101, 114, 0, 0, + 116, 101, 115, 116, 77, 111, 114, 101, + 83, 116, 117, 102, 102, 0, 0, 0, } +}; +::capnp::word const* const bp_ef428f2f67c4d439 = b_ef428f2f67c4d439.words; +#if !CAPNP_LITE +static const uint16_t m_ef428f2f67c4d439[] = {1, 0, 5, 2, 3, 4}; +const ::capnp::_::RawSchema s_ef428f2f67c4d439 = { + 0xef428f2f67c4d439, b_ef428f2f67c4d439.words, 49, nullptr, m_ef428f2f67c4d439, + 0, 6, nullptr, nullptr, nullptr, { &s_ef428f2f67c4d439, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(Tag_ef428f2f67c4d439, ef428f2f67c4d439); +static const ::capnp::_::AlignedData<17> b_9e5c574772b1d462 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 98, 212, 177, 114, 71, 87, 92, 158, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 80, + 114, 111, 118, 105, 115, 105, 111, 110, + 73, 100, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_9e5c574772b1d462 = b_9e5c574772b1d462.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_9e5c574772b1d462 = { + 0x9e5c574772b1d462, b_9e5c574772b1d462.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_9e5c574772b1d462, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_ea2fb7dca9cdbdea = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 234, 189, 205, 169, 220, 183, 47, 234, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 218, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 82, + 101, 99, 105, 112, 105, 101, 110, 116, + 73, 100, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_ea2fb7dca9cdbdea = b_ea2fb7dca9cdbdea.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_ea2fb7dca9cdbdea = { + 0xea2fb7dca9cdbdea, b_ea2fb7dca9cdbdea.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_ea2fb7dca9cdbdea, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_a805157b98b65469 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 105, 84, 182, 152, 123, 21, 5, 168, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 84, + 104, 105, 114, 100, 80, 97, 114, 116, + 121, 67, 97, 112, 73, 100, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_a805157b98b65469 = b_a805157b98b65469.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_a805157b98b65469 = { + 0xa805157b98b65469, b_a805157b98b65469.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_a805157b98b65469, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<17> b_f4c58a8ebcd0f600 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 0, 246, 208, 188, 142, 138, 197, 244, + 11, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 210, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 74, + 111, 105, 110, 82, 101, 115, 117, 108, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_f4c58a8ebcd0f600 = b_f4c58a8ebcd0f600.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_f4c58a8ebcd0f600 = { + 0xf4c58a8ebcd0f600, b_f4c58a8ebcd0f600.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_f4c58a8ebcd0f600, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<124> b_d1fd8e9caf2a5d58 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 88, 93, 42, 175, 156, 142, 253, 209, + 11, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 2, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 0, 0, 0, + 33, 0, 0, 0, 39, 0, 0, 0, + 65, 0, 0, 0, 31, 0, 0, 0, + 101, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 74, 232, 201, 180, 222, 209, 16, 246, + 9, 0, 0, 0, 122, 0, 0, 0, + 132, 34, 213, 65, 99, 107, 64, 190, + 9, 0, 0, 0, 106, 0, 0, 0, + 66, 97, 100, 108, 121, 78, 97, 109, + 101, 100, 69, 110, 117, 109, 0, 0, + 78, 101, 115, 116, 101, 100, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 114, 0, 0, 0, + 82, 101, 110, 97, 109, 101, 100, 83, + 116, 114, 117, 99, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 106, 0, 0, 0, + 101, 0, 0, 0, 31, 0, 0, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 3, 0, 1, 0, + 152, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 0, 0, 0, 162, 0, 0, 0, + 157, 0, 0, 0, 31, 0, 0, 0, + 196, 0, 0, 0, 3, 0, 1, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 124, 1, 52, 107, 98, 209, 217, 137, + 205, 0, 0, 0, 130, 0, 0, 0, + 209, 0, 0, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 100, 70, 105, 101, 108, 100, + 78, 97, 109, 101, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 114, 0, 0, 0, + 103, 111, 111, 100, 70, 105, 101, 108, + 100, 78, 97, 109, 101, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 66, + 97, 100, 70, 105, 101, 108, 100, 78, + 97, 109, 101, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 170, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 71, + 111, 111, 100, 70, 105, 101, 108, 100, + 78, 97, 109, 101, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 74, 232, 201, 180, 222, 209, 16, 246, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 100, 108, 121, 78, 97, 109, + 101, 100, 85, 110, 105, 111, 110, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 106, 0, 0, 0, + 114, 101, 110, 97, 109, 101, 100, 85, + 110, 105, 111, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_d1fd8e9caf2a5d58 = b_d1fd8e9caf2a5d58.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d1fd8e9caf2a5d58[] = { + &s_89d9d1626b34017c, + &s_f610d1deb4c9e84a, +}; +static const uint16_t m_d1fd8e9caf2a5d58[] = {2, 0, 3, 1}; +static const uint16_t i_d1fd8e9caf2a5d58[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_d1fd8e9caf2a5d58 = { + 0xd1fd8e9caf2a5d58, b_d1fd8e9caf2a5d58.words, 124, d_d1fd8e9caf2a5d58, m_d1fd8e9caf2a5d58, + 2, 4, i_d1fd8e9caf2a5d58, nullptr, nullptr, { &s_d1fd8e9caf2a5d58, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<51> b_f610d1deb4c9e84a = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 74, 232, 201, 180, 222, 209, 16, 246, + 30, 0, 0, 0, 2, 0, 0, 0, + 88, 93, 42, 175, 156, 142, 253, 209, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 1, 0, 0, + 41, 0, 0, 0, 7, 0, 0, 0, + 41, 0, 0, 0, 31, 0, 0, 0, + 77, 0, 0, 0, 79, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 46, 66, 97, + 100, 108, 121, 78, 97, 109, 101, 100, + 69, 110, 117, 109, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 98, 0, 0, 0, + 82, 101, 110, 97, 109, 101, 100, 69, + 110, 117, 109, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 13, 0, 0, 0, 31, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f610d1deb4c9e84a = b_f610d1deb4c9e84a.words; +#if !CAPNP_LITE +static const uint16_t m_f610d1deb4c9e84a[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_f610d1deb4c9e84a = { + 0xf610d1deb4c9e84a, b_f610d1deb4c9e84a.words, 51, nullptr, m_f610d1deb4c9e84a, + 0, 3, nullptr, nullptr, nullptr, { &s_f610d1deb4c9e84a, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(RenamedEnum_f610d1deb4c9e84a, f610d1deb4c9e84a); +static const ::capnp::_::AlignedData<94> b_be406b6341d52284 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 132, 34, 213, 65, 99, 107, 64, 190, + 30, 0, 0, 0, 1, 0, 1, 0, + 88, 93, 42, 175, 156, 142, 253, 209, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 90, 1, 0, 0, + 41, 0, 0, 0, 23, 0, 0, 0, + 61, 0, 0, 0, 31, 0, 0, 0, + 101, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 46, 78, 101, + 115, 116, 101, 100, 83, 116, 114, 117, + 99, 116, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 224, 34, 67, 122, 156, 63, 203, 246, + 1, 0, 0, 0, 138, 0, 0, 0, + 68, 101, 101, 112, 108, 121, 78, 101, + 115, 116, 101, 100, 69, 110, 117, 109, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 162, 0, 0, 0, + 82, 101, 110, 97, 109, 101, 100, 78, + 101, 115, 116, 101, 100, 83, 116, 114, + 117, 99, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 154, 0, 0, 0, + 49, 0, 0, 0, 31, 0, 0, 0, + 88, 0, 0, 0, 3, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 210, 0, 0, 0, + 109, 0, 0, 0, 31, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 1, 0, + 164, 0, 0, 0, 2, 0, 1, 0, + 98, 97, 100, 78, 101, 115, 116, 101, + 100, 70, 105, 101, 108, 100, 78, 97, + 109, 101, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 162, 0, 0, 0, + 103, 111, 111, 100, 78, 101, 115, 116, + 101, 100, 70, 105, 101, 108, 100, 78, + 97, 109, 101, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 66, + 97, 100, 78, 101, 115, 116, 101, 100, + 70, 105, 101, 108, 100, 78, 97, 109, + 101, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 218, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 71, + 111, 111, 100, 78, 101, 115, 116, 101, + 100, 70, 105, 101, 108, 100, 78, 97, + 109, 101, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 132, 34, 213, 65, 99, 107, 64, 190, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_be406b6341d52284 = b_be406b6341d52284.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_be406b6341d52284[] = { + &s_be406b6341d52284, +}; +static const uint16_t m_be406b6341d52284[] = {1, 0}; +static const uint16_t i_be406b6341d52284[] = {0, 1}; +const ::capnp::_::RawSchema s_be406b6341d52284 = { + 0xbe406b6341d52284, b_be406b6341d52284.words, 94, d_be406b6341d52284, m_be406b6341d52284, + 1, 2, i_be406b6341d52284, nullptr, nullptr, { &s_be406b6341d52284, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<54> b_f6cb3f9c7a4322e0 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 224, 34, 67, 122, 156, 63, 203, 246, + 43, 0, 0, 0, 2, 0, 0, 0, + 132, 34, 213, 65, 99, 107, 64, 190, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 226, 1, 0, 0, + 49, 0, 0, 0, 7, 0, 0, 0, + 49, 0, 0, 0, 31, 0, 0, 0, + 89, 0, 0, 0, 79, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 46, 78, 101, + 115, 116, 101, 100, 83, 116, 114, 117, + 99, 116, 46, 68, 101, 101, 112, 108, + 121, 78, 101, 115, 116, 101, 100, 69, + 110, 117, 109, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 194, 0, 0, 0, + 82, 101, 110, 97, 109, 101, 100, 68, + 101, 101, 112, 108, 121, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 13, 0, 0, 0, 31, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_f6cb3f9c7a4322e0 = b_f6cb3f9c7a4322e0.words; +#if !CAPNP_LITE +static const uint16_t m_f6cb3f9c7a4322e0[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_f6cb3f9c7a4322e0 = { + 0xf6cb3f9c7a4322e0, b_f6cb3f9c7a4322e0.words, 54, nullptr, m_f6cb3f9c7a4322e0, + 0, 3, nullptr, nullptr, nullptr, { &s_f6cb3f9c7a4322e0, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +CAPNP_DEFINE_ENUM(RenamedDeeplyNestedEnum_f6cb3f9c7a4322e0, f6cb3f9c7a4322e0); +static const ::capnp::_::AlignedData<62> b_89d9d1626b34017c = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 124, 1, 52, 107, 98, 209, 217, 137, + 30, 0, 0, 0, 1, 0, 1, 0, + 88, 93, 42, 175, 156, 142, 253, 209, + 1, 0, 7, 0, 1, 0, 2, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 46, 98, 97, + 100, 108, 121, 78, 97, 109, 101, 100, + 85, 110, 105, 111, 110, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 34, 183, 36, 91, 206, 75, 89, 195, + 41, 0, 0, 0, 130, 0, 0, 0, + 45, 0, 0, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 0, 0, 0, 34, 0, 0, 0, + 61, 0, 0, 0, 31, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 98, 97, 100, 108, 121, 78, 97, 109, + 101, 100, 71, 114, 111, 117, 112, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 106, 0, 0, 0, + 114, 101, 110, 97, 109, 101, 100, 71, + 114, 111, 117, 112, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 132, 34, 213, 65, 99, 107, 64, 190, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_89d9d1626b34017c = b_89d9d1626b34017c.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_89d9d1626b34017c[] = { + &s_be406b6341d52284, + &s_c3594bce5b24b722, + &s_d1fd8e9caf2a5d58, +}; +static const uint16_t m_89d9d1626b34017c[] = {0, 1}; +static const uint16_t i_89d9d1626b34017c[] = {0, 1}; +const ::capnp::_::RawSchema s_89d9d1626b34017c = { + 0x89d9d1626b34017c, b_89d9d1626b34017c.words, 62, d_89d9d1626b34017c, m_89d9d1626b34017c, + 3, 2, i_89d9d1626b34017c, nullptr, nullptr, { &s_89d9d1626b34017c, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<51> b_c3594bce5b24b722 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 34, 183, 36, 91, 206, 75, 89, 195, + 46, 0, 0, 0, 1, 0, 1, 0, + 124, 1, 52, 107, 98, 209, 217, 137, + 1, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 242, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 46, 98, 97, + 100, 108, 121, 78, 97, 109, 101, 100, + 85, 110, 105, 111, 110, 46, 98, 97, + 100, 108, 121, 78, 97, 109, 101, 100, + 71, 114, 111, 117, 112, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c3594bce5b24b722 = b_c3594bce5b24b722.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_c3594bce5b24b722[] = { + &s_89d9d1626b34017c, +}; +static const uint16_t m_c3594bce5b24b722[] = {1, 0}; +static const uint16_t i_c3594bce5b24b722[] = {0, 1}; +const ::capnp::_::RawSchema s_c3594bce5b24b722 = { + 0xc3594bce5b24b722, b_c3594bce5b24b722.words, 51, d_c3594bce5b24b722, m_c3594bce5b24b722, + 1, 2, i_c3594bce5b24b722, nullptr, nullptr, { &s_c3594bce5b24b722, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<53> b_d112a69d31ed918b = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 139, 145, 237, 49, 157, 166, 18, 209, + 11, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 58, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 37, 0, 0, 0, 31, 0, 0, 0, + 77, 0, 0, 0, 71, 0, 0, 0, + 165, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 138, 0, 0, 0, + 82, 101, 110, 97, 109, 101, 100, 73, + 110, 116, 101, 114, 102, 97, 99, 101, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 223, 90, 7, 59, 252, 46, 193, + 134, 108, 143, 178, 180, 205, 195, 220, + 17, 0, 0, 0, 138, 0, 0, 0, + 25, 0, 0, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 7, 0, 0, 0, + 98, 97, 100, 108, 121, 78, 97, 109, + 101, 100, 77, 101, 116, 104, 111, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 114, 0, 0, 0, + 114, 101, 110, 97, 109, 101, 100, 77, + 101, 116, 104, 111, 100, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +::capnp::word const* const bp_d112a69d31ed918b = b_d112a69d31ed918b.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_d112a69d31ed918b[] = { + &s_c12efc3b075adfe9, + &s_dcc3cdb4b28f6c86, +}; +static const uint16_t m_d112a69d31ed918b[] = {0}; +const ::capnp::_::RawSchema s_d112a69d31ed918b = { + 0xd112a69d31ed918b, b_d112a69d31ed918b.words, 53, d_d112a69d31ed918b, m_d112a69d31ed918b, + 2, 1, nullptr, nullptr, nullptr, { &s_d112a69d31ed918b, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<47> b_c12efc3b075adfe9 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 233, 223, 90, 7, 59, 252, 46, 193, + 39, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 100, 108, 121, 78, 97, 109, 101, + 100, 77, 101, 116, 104, 111, 100, 36, + 80, 97, 114, 97, 109, 115, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 130, 0, 0, 0, + 17, 0, 0, 0, 31, 0, 0, 0, + 52, 0, 0, 0, 3, 0, 1, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 98, 97, 100, 108, 121, 78, 97, 109, + 101, 100, 80, 97, 114, 97, 109, 0, + 4, 0, 0, 0, 1, 0, 2, 0, + 206, 145, 241, 254, 121, 167, 100, 242, + 4, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 0, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 106, 0, 0, 0, + 114, 101, 110, 97, 109, 101, 100, 80, + 97, 114, 97, 109, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_c12efc3b075adfe9 = b_c12efc3b075adfe9.words; +#if !CAPNP_LITE +static const uint16_t m_c12efc3b075adfe9[] = {0}; +static const uint16_t i_c12efc3b075adfe9[] = {0}; +const ::capnp::_::RawSchema s_c12efc3b075adfe9 = { + 0xc12efc3b075adfe9, b_c12efc3b075adfe9.words, 47, nullptr, m_c12efc3b075adfe9, + 0, 1, i_c12efc3b075adfe9, nullptr, nullptr, { &s_c12efc3b075adfe9, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<20> b_dcc3cdb4b28f6c86 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 134, 108, 143, 178, 180, 205, 195, 220, + 39, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 2, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 46, 99, 97, 112, + 110, 112, 58, 84, 101, 115, 116, 78, + 97, 109, 101, 65, 110, 110, 111, 116, + 97, 116, 105, 111, 110, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 100, 108, 121, 78, 97, 109, 101, + 100, 77, 101, 116, 104, 111, 100, 36, + 82, 101, 115, 117, 108, 116, 115, 0, } +}; +::capnp::word const* const bp_dcc3cdb4b28f6c86 = b_dcc3cdb4b28f6c86.words; +#if !CAPNP_LITE +const ::capnp::_::RawSchema s_dcc3cdb4b28f6c86 = { + 0xdcc3cdb4b28f6c86, b_dcc3cdb4b28f6c86.words, 20, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr, { &s_dcc3cdb4b28f6c86, nullptr, nullptr, 0, 0, nullptr } +}; +#endif // !CAPNP_LITE +} // namespace schemas +} // namespace capnp + +// ======================================================================================= + +namespace capnproto_test { +namespace capnp { +namespace test { + +// TestAllTypes +constexpr uint16_t TestAllTypes::_capnpPrivate::dataWordSize; +constexpr uint16_t TestAllTypes::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestAllTypes::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestAllTypes::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestDefaults +constexpr uint16_t TestDefaults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestDefaults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestDefaults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestDefaults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestAnyPointer +constexpr uint16_t TestAnyPointer::_capnpPrivate::dataWordSize; +constexpr uint16_t TestAnyPointer::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestAnyPointer::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestAnyPointer::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestAnyOthers +constexpr uint16_t TestAnyOthers::_capnpPrivate::dataWordSize; +constexpr uint16_t TestAnyOthers::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestAnyOthers::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestAnyOthers::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestOutOfOrder +constexpr uint16_t TestOutOfOrder::_capnpPrivate::dataWordSize; +constexpr uint16_t TestOutOfOrder::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestOutOfOrder::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestOutOfOrder::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnion +constexpr uint16_t TestUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnion::Union0 +constexpr uint16_t TestUnion::Union0::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnion::Union0::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnion::Union0::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnion::Union0::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnion::Union1 +constexpr uint16_t TestUnion::Union1::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnion::Union1::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnion::Union1::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnion::Union1::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnion::Union2 +constexpr uint16_t TestUnion::Union2::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnion::Union2::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnion::Union2::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnion::Union2::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnion::Union3 +constexpr uint16_t TestUnion::Union3::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnion::Union3::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnion::Union3::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnion::Union3::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnnamedUnion +constexpr uint16_t TestUnnamedUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnnamedUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnnamedUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnnamedUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnionInUnion +constexpr uint16_t TestUnionInUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnionInUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnionInUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnionInUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnionInUnion::Outer +constexpr uint16_t TestUnionInUnion::Outer::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnionInUnion::Outer::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnionInUnion::Outer::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnionInUnion::Outer::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnionInUnion::Outer::Inner +constexpr uint16_t TestUnionInUnion::Outer::Inner::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnionInUnion::Outer::Inner::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnionInUnion::Outer::Inner::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnionInUnion::Outer::Inner::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestGroups +constexpr uint16_t TestGroups::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGroups::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGroups::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGroups::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestGroups::Groups +constexpr uint16_t TestGroups::Groups::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGroups::Groups::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGroups::Groups::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGroups::Groups::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestGroups::Groups::Foo +constexpr uint16_t TestGroups::Groups::Foo::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGroups::Groups::Foo::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGroups::Groups::Foo::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGroups::Groups::Foo::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestGroups::Groups::Baz +constexpr uint16_t TestGroups::Groups::Baz::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGroups::Groups::Baz::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGroups::Groups::Baz::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGroups::Groups::Baz::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestGroups::Groups::Bar +constexpr uint16_t TestGroups::Groups::Bar::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGroups::Groups::Bar::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGroups::Groups::Bar::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGroups::Groups::Bar::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterleavedGroups +constexpr uint16_t TestInterleavedGroups::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterleavedGroups::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterleavedGroups::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterleavedGroups::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterleavedGroups::Group1 +constexpr uint16_t TestInterleavedGroups::Group1::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterleavedGroups::Group1::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterleavedGroups::Group1::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterleavedGroups::Group1::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterleavedGroups::Group1::Corge +constexpr uint16_t TestInterleavedGroups::Group1::Corge::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterleavedGroups::Group1::Corge::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterleavedGroups::Group1::Corge::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterleavedGroups::Group1::Corge::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterleavedGroups::Group2 +constexpr uint16_t TestInterleavedGroups::Group2::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterleavedGroups::Group2::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterleavedGroups::Group2::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterleavedGroups::Group2::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterleavedGroups::Group2::Corge +constexpr uint16_t TestInterleavedGroups::Group2::Corge::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterleavedGroups::Group2::Corge::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterleavedGroups::Group2::Corge::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterleavedGroups::Group2::Corge::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUnionDefaults +constexpr uint16_t TestUnionDefaults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUnionDefaults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUnionDefaults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUnionDefaults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestNestedTypes +constexpr uint16_t TestNestedTypes::_capnpPrivate::dataWordSize; +constexpr uint16_t TestNestedTypes::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestNestedTypes::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestNestedTypes::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestNestedTypes::NestedStruct +constexpr uint16_t TestNestedTypes::NestedStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t TestNestedTypes::NestedStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestNestedTypes::NestedStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestNestedTypes::NestedStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUsing +constexpr uint16_t TestUsing::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUsing::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUsing::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUsing::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists +constexpr uint16_t TestLists::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct0 +constexpr uint16_t TestLists::Struct0::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct0::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct0::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct0::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct1 +constexpr uint16_t TestLists::Struct1::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct1::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct1::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct1::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct8 +constexpr uint16_t TestLists::Struct8::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct8::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct8::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct8::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct16 +constexpr uint16_t TestLists::Struct16::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct16::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct16::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct16::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct32 +constexpr uint16_t TestLists::Struct32::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct32::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct32::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct32::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct64 +constexpr uint16_t TestLists::Struct64::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct64::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct64::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct64::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::StructP +constexpr uint16_t TestLists::StructP::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::StructP::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::StructP::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::StructP::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct0c +constexpr uint16_t TestLists::Struct0c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct0c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct0c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct0c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct1c +constexpr uint16_t TestLists::Struct1c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct1c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct1c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct1c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct8c +constexpr uint16_t TestLists::Struct8c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct8c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct8c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct8c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct16c +constexpr uint16_t TestLists::Struct16c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct16c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct16c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct16c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct32c +constexpr uint16_t TestLists::Struct32c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct32c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct32c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct32c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::Struct64c +constexpr uint16_t TestLists::Struct64c::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::Struct64c::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::Struct64c::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::Struct64c::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLists::StructPc +constexpr uint16_t TestLists::StructPc::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLists::StructPc::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLists::StructPc::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLists::StructPc::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestFieldZeroIsBit +constexpr uint16_t TestFieldZeroIsBit::_capnpPrivate::dataWordSize; +constexpr uint16_t TestFieldZeroIsBit::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestFieldZeroIsBit::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestFieldZeroIsBit::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestListDefaults +constexpr uint16_t TestListDefaults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestListDefaults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestListDefaults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestListDefaults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLateUnion +constexpr uint16_t TestLateUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLateUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLateUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLateUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLateUnion::TheUnion +constexpr uint16_t TestLateUnion::TheUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLateUnion::TheUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLateUnion::TheUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLateUnion::TheUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestLateUnion::AnotherUnion +constexpr uint16_t TestLateUnion::AnotherUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestLateUnion::AnotherUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestLateUnion::AnotherUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestLateUnion::AnotherUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestOldVersion +constexpr uint16_t TestOldVersion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestOldVersion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestOldVersion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestOldVersion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestNewVersion +constexpr uint16_t TestNewVersion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestNewVersion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestNewVersion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestNewVersion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestOldUnionVersion +constexpr uint16_t TestOldUnionVersion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestOldUnionVersion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestOldUnionVersion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestOldUnionVersion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestNewUnionVersion +constexpr uint16_t TestNewUnionVersion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestNewUnionVersion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestNewUnionVersion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestNewUnionVersion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestNewUnionVersion::A +constexpr uint16_t TestNewUnionVersion::A::_capnpPrivate::dataWordSize; +constexpr uint16_t TestNewUnionVersion::A::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestNewUnionVersion::A::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestNewUnionVersion::A::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestStructUnion +constexpr uint16_t TestStructUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t TestStructUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestStructUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestStructUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestStructUnion::SomeStruct +constexpr uint16_t TestStructUnion::SomeStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t TestStructUnion::SomeStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestStructUnion::SomeStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestStructUnion::SomeStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestStructUnion::Un +constexpr uint16_t TestStructUnion::Un::_capnpPrivate::dataWordSize; +constexpr uint16_t TestStructUnion::Un::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestStructUnion::Un::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestStructUnion::Un::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPrintInlineStructs +constexpr uint16_t TestPrintInlineStructs::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPrintInlineStructs::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPrintInlineStructs::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPrintInlineStructs::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPrintInlineStructs::InlineStruct +constexpr uint16_t TestPrintInlineStructs::InlineStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPrintInlineStructs::InlineStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPrintInlineStructs::InlineStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPrintInlineStructs::InlineStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestWholeFloatDefault +constexpr uint16_t TestWholeFloatDefault::_capnpPrivate::dataWordSize; +constexpr uint16_t TestWholeFloatDefault::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestWholeFloatDefault::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestWholeFloatDefault::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +KJ_CONSTEXPR(const) float TestWholeFloatDefault::CONSTANT CAPNP_NON_INT_CONSTEXPR_DEF_INIT(456.0f); +KJ_CONSTEXPR(const) float TestWholeFloatDefault::BIG_CONSTANT CAPNP_NON_INT_CONSTEXPR_DEF_INIT(4e30f); +// TestGenericsWrapper2 +constexpr uint16_t TestGenericsWrapper2::_capnpPrivate::dataWordSize; +constexpr uint16_t TestGenericsWrapper2::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestGenericsWrapper2::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestGenericsWrapper2::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::kj::Promise TestImplicitMethodParams::Server::call(CallContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestImplicitMethodParams", "call", + 0x8b9717a3f8d85a9aull, 0); +} +::kj::Promise TestImplicitMethodParams::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x8b9717a3f8d85a9aull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestImplicitMethodParams", interfaceId); + } +} +::kj::Promise TestImplicitMethodParams::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return call(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestImplicitMethodParams::CallParams<>, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestImplicitMethodParams", + 0x8b9717a3f8d85a9aull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestImplicitMethodParams +#if !CAPNP_LITE +constexpr ::capnp::Kind TestImplicitMethodParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestImplicitMethodParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestUseGenerics +constexpr uint16_t TestUseGenerics::_capnpPrivate::dataWordSize; +constexpr uint16_t TestUseGenerics::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestUseGenerics::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestUseGenerics::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestEmptyStruct +constexpr uint16_t TestEmptyStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t TestEmptyStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestEmptyStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestEmptyStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestConstants +constexpr uint16_t TestConstants::_capnpPrivate::dataWordSize; +constexpr uint16_t TestConstants::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestConstants::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestConstants::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +KJ_CONSTEXPR(const) ::capnp::Void TestConstants::VOID_CONST CAPNP_NON_INT_CONSTEXPR_DEF_INIT( ::capnp::VOID); +#ifndef _MSC_VER +constexpr bool TestConstants::BOOL_CONST; +#endif +#ifndef _MSC_VER +constexpr ::int8_t TestConstants::INT8_CONST; +#endif +#ifndef _MSC_VER +constexpr ::int16_t TestConstants::INT16_CONST; +#endif +#ifndef _MSC_VER +constexpr ::int32_t TestConstants::INT32_CONST; +#endif +#ifndef _MSC_VER +constexpr ::int64_t TestConstants::INT64_CONST; +#endif +#ifndef _MSC_VER +constexpr ::uint8_t TestConstants::UINT8_CONST; +#endif +#ifndef _MSC_VER +constexpr ::uint16_t TestConstants::UINT16_CONST; +#endif +#ifndef _MSC_VER +constexpr ::uint32_t TestConstants::UINT32_CONST; +#endif +#ifndef _MSC_VER +constexpr ::uint64_t TestConstants::UINT64_CONST; +#endif +KJ_CONSTEXPR(const) float TestConstants::FLOAT32_CONST CAPNP_NON_INT_CONSTEXPR_DEF_INIT(1234.5f); +KJ_CONSTEXPR(const) double TestConstants::FLOAT64_CONST CAPNP_NON_INT_CONSTEXPR_DEF_INIT(-1.23e47); +const ::capnp::_::ConstText<3> TestConstants::TEXT_CONST(::capnp::schemas::b_f346e8becc34c826.words + 25); +const ::capnp::_::ConstData<3> TestConstants::DATA_CONST(::capnp::schemas::b_aaa4fc67c55b78fd.words + 25); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> TestConstants::STRUCT_CONST(::capnp::schemas::b_ed37d4414bf1157a.words + 24); +#ifndef _MSC_VER +constexpr ::capnproto_test::capnp::test::TestEnum TestConstants::ENUM_CONST; +#endif +const ::capnp::_::ConstList< ::capnp::Void> TestConstants::VOID_LIST_CONST(::capnp::schemas::b_e3201c2e657cf0fc.words + 28); +const ::capnp::_::ConstList TestConstants::BOOL_LIST_CONST(::capnp::schemas::b_ce1810c84e108cdc.words + 28); +const ::capnp::_::ConstList< ::int8_t> TestConstants::INT8_LIST_CONST(::capnp::schemas::b_ff58bf5895b73ee2.words + 28); +const ::capnp::_::ConstList< ::int16_t> TestConstants::INT16_LIST_CONST(::capnp::schemas::b_a145449a15848a09.words + 28); +const ::capnp::_::ConstList< ::int32_t> TestConstants::INT32_LIST_CONST(::capnp::schemas::b_a567a743b6b4bf0d.words + 28); +const ::capnp::_::ConstList< ::int64_t> TestConstants::INT64_LIST_CONST(::capnp::schemas::b_d987eb8af5945021.words + 28); +const ::capnp::_::ConstList< ::uint8_t> TestConstants::UINT8_LIST_CONST(::capnp::schemas::b_9e55f87eb2ffa805.words + 28); +const ::capnp::_::ConstList< ::uint16_t> TestConstants::UINT16_LIST_CONST(::capnp::schemas::b_fe4d1147d7537f4c.words + 29); +const ::capnp::_::ConstList< ::uint32_t> TestConstants::UINT32_LIST_CONST(::capnp::schemas::b_900218d4541375d3.words + 29); +const ::capnp::_::ConstList< ::uint64_t> TestConstants::UINT64_LIST_CONST(::capnp::schemas::b_d26dd7a486f26cd7.words + 29); +const ::capnp::_::ConstList TestConstants::FLOAT32_LIST_CONST(::capnp::schemas::b_feb875138580a065.words + 29); +const ::capnp::_::ConstList TestConstants::FLOAT64_LIST_CONST(::capnp::schemas::b_a815a514acbab212.words + 29); +const ::capnp::_::ConstList< ::capnp::Text> TestConstants::TEXT_LIST_CONST(::capnp::schemas::b_ec56db537c838603.words + 28); +const ::capnp::_::ConstList< ::capnp::Data> TestConstants::DATA_LIST_CONST(::capnp::schemas::b_c468785db6321458.words + 28); +const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestAllTypes> TestConstants::STRUCT_LIST_CONST(::capnp::schemas::b_d1f994d3d4fbbaed.words + 29); +const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestEnum> TestConstants::ENUM_LIST_CONST(::capnp::schemas::b_c30860d747fd5019.words + 28); +const ::capnp::_::ConstText<6> GLOBAL_TEXT(::capnp::schemas::b_d81b65e268fb3f34.words + 23); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> GLOBAL_STRUCT(::capnp::schemas::b_bd579b448bfbcc7b.words + 22); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestPrintInlineStructs> GLOBAL_PRINTABLE_STRUCT(::capnp::schemas::b_a00141d482942422.words + 24); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> DERIVED_CONSTANT(::capnp::schemas::b_a4764c3483341eeb.words + 23); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>> GENERIC_CONSTANT(::capnp::schemas::b_b70341f0dafa28ef.words + 41); +const ::capnp::_::ConstData<831> EMBEDDED_DATA(::capnp::schemas::b_d7c0fea759d6a0cf.words + 23); +const ::capnp::_::ConstText<4235> EMBEDDED_TEXT(::capnp::schemas::b_8e59556fb309253f.words + 23); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> EMBEDDED_STRUCT(::capnp::schemas::b_dec09c6791841ebb.words + 23); +const ::capnp::_::ConstText<10> NON_ASCII_TEXT(::capnp::schemas::b_fb7ed666617fb649.words + 23); +// TestAnyPointerConstants +constexpr uint16_t TestAnyPointerConstants::_capnpPrivate::dataWordSize; +constexpr uint16_t TestAnyPointerConstants::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestAnyPointerConstants::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestAnyPointerConstants::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAnyPointerConstants> ANY_POINTER_CONSTANTS(::capnp::schemas::b_8139f596ebaf6185.words + 23); +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestInterface::FooParams, ::capnproto_test::capnp::test::TestInterface::FooResults> +TestInterface::Client::fooRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestInterface::FooParams, ::capnproto_test::capnp::test::TestInterface::FooResults>( + 0x88eb12a0e0af92b2ull, 0, sizeHint); +} +::kj::Promise TestInterface::Server::foo(FooContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestInterface", "foo", + 0x88eb12a0e0af92b2ull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestInterface::BarParams, ::capnproto_test::capnp::test::TestInterface::BarResults> +TestInterface::Client::barRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestInterface::BarParams, ::capnproto_test::capnp::test::TestInterface::BarResults>( + 0x88eb12a0e0af92b2ull, 1, sizeHint); +} +::kj::Promise TestInterface::Server::bar(BarContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestInterface", "bar", + 0x88eb12a0e0af92b2ull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestInterface::BazParams, ::capnproto_test::capnp::test::TestInterface::BazResults> +TestInterface::Client::bazRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestInterface::BazParams, ::capnproto_test::capnp::test::TestInterface::BazResults>( + 0x88eb12a0e0af92b2ull, 2, sizeHint); +} +::kj::Promise TestInterface::Server::baz(BazContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestInterface", "baz", + 0x88eb12a0e0af92b2ull, 2); +} +::kj::Promise TestInterface::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x88eb12a0e0af92b2ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestInterface", interfaceId); + } +} +::kj::Promise TestInterface::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return foo(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestInterface::FooParams, ::capnproto_test::capnp::test::TestInterface::FooResults>(context)); + case 1: + return bar(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestInterface::BarParams, ::capnproto_test::capnp::test::TestInterface::BarResults>(context)); + case 2: + return baz(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestInterface::BazParams, ::capnproto_test::capnp::test::TestInterface::BazResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestInterface", + 0x88eb12a0e0af92b2ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestInterface +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::FooParams +constexpr uint16_t TestInterface::FooParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::FooParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::FooParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::FooParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::FooResults +constexpr uint16_t TestInterface::FooResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::FooResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::FooResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::FooResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::BarParams +constexpr uint16_t TestInterface::BarParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::BarParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::BarParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::BarParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::BarResults +constexpr uint16_t TestInterface::BarResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::BarResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::BarResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::BarResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::BazParams +constexpr uint16_t TestInterface::BazParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::BazParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::BazParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::BazParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestInterface::BazResults +constexpr uint16_t TestInterface::BazResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestInterface::BazResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestInterface::BazResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestInterface::BazResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestExtends::QuxParams, ::capnproto_test::capnp::test::TestExtends::QuxResults> +TestExtends::Client::quxRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestExtends::QuxParams, ::capnproto_test::capnp::test::TestExtends::QuxResults>( + 0xe4e9bac98670b748ull, 0, sizeHint); +} +::kj::Promise TestExtends::Server::qux(QuxContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestExtends", "qux", + 0xe4e9bac98670b748ull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestExtends::CorgeResults> +TestExtends::Client::corgeRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestExtends::CorgeResults>( + 0xe4e9bac98670b748ull, 1, sizeHint); +} +::kj::Promise TestExtends::Server::corge(CorgeContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestExtends", "corge", + 0xe4e9bac98670b748ull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestExtends::GraultParams, ::capnproto_test::capnp::test::TestAllTypes> +TestExtends::Client::graultRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestExtends::GraultParams, ::capnproto_test::capnp::test::TestAllTypes>( + 0xe4e9bac98670b748ull, 2, sizeHint); +} +::kj::Promise TestExtends::Server::grault(GraultContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestExtends", "grault", + 0xe4e9bac98670b748ull, 2); +} +::kj::Promise TestExtends::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xe4e9bac98670b748ull: + return dispatchCallInternal(methodId, context); + case 0x88eb12a0e0af92b2ull: + return ::capnproto_test::capnp::test::TestInterface::Server::dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestExtends", interfaceId); + } +} +::kj::Promise TestExtends::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return qux(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestExtends::QuxParams, ::capnproto_test::capnp::test::TestExtends::QuxResults>(context)); + case 1: + return corge(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestExtends::CorgeResults>(context)); + case 2: + return grault(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestExtends::GraultParams, ::capnproto_test::capnp::test::TestAllTypes>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestExtends", + 0xe4e9bac98670b748ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestExtends +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestExtends::QuxParams +constexpr uint16_t TestExtends::QuxParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestExtends::QuxParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends::QuxParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends::QuxParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestExtends::QuxResults +constexpr uint16_t TestExtends::QuxResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestExtends::QuxResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends::QuxResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends::QuxResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestExtends::CorgeResults +constexpr uint16_t TestExtends::CorgeResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestExtends::CorgeResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends::CorgeResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends::CorgeResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestExtends::GraultParams +constexpr uint16_t TestExtends::GraultParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestExtends::GraultParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends::GraultParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends::GraultParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::kj::Promise TestExtends2::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x98d7e0ef61488783ull: + return dispatchCallInternal(methodId, context); + case 0x88eb12a0e0af92b2ull: + return ::capnproto_test::capnp::test::TestInterface::Server::dispatchCallInternal(methodId, context); + case 0xe4e9bac98670b748ull: + return ::capnproto_test::capnp::test::TestExtends::Server::dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestExtends2", interfaceId); + } +} +::kj::Promise TestExtends2::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestExtends2", + 0x98d7e0ef61488783ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestExtends2 +#if !CAPNP_LITE +constexpr ::capnp::Kind TestExtends2::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestExtends2::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::GetCapParams, ::capnproto_test::capnp::test::TestPipeline::GetCapResults> +TestPipeline::Client::getCapRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestPipeline::GetCapParams, ::capnproto_test::capnp::test::TestPipeline::GetCapResults>( + 0xa5a404caa61d4cd0ull, 0, sizeHint); +} +::kj::Promise TestPipeline::Server::getCap(GetCapContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestPipeline", "getCap", + 0xa5a404caa61d4cd0ull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::TestPointersParams, ::capnproto_test::capnp::test::TestPipeline::TestPointersResults> +TestPipeline::Client::testPointersRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestPipeline::TestPointersParams, ::capnproto_test::capnp::test::TestPipeline::TestPointersResults>( + 0xa5a404caa61d4cd0ull, 1, sizeHint); +} +::kj::Promise TestPipeline::Server::testPointers(TestPointersContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestPipeline", "testPointers", + 0xa5a404caa61d4cd0ull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::GetAnyCapParams, ::capnproto_test::capnp::test::TestPipeline::GetAnyCapResults> +TestPipeline::Client::getAnyCapRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestPipeline::GetAnyCapParams, ::capnproto_test::capnp::test::TestPipeline::GetAnyCapResults>( + 0xa5a404caa61d4cd0ull, 2, sizeHint); +} +::kj::Promise TestPipeline::Server::getAnyCap(GetAnyCapContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestPipeline", "getAnyCap", + 0xa5a404caa61d4cd0ull, 2); +} +::kj::Promise TestPipeline::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xa5a404caa61d4cd0ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestPipeline", interfaceId); + } +} +::kj::Promise TestPipeline::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return getCap(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestPipeline::GetCapParams, ::capnproto_test::capnp::test::TestPipeline::GetCapResults>(context)); + case 1: + return testPointers(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestPipeline::TestPointersParams, ::capnproto_test::capnp::test::TestPipeline::TestPointersResults>(context)); + case 2: + return getAnyCap(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestPipeline::GetAnyCapParams, ::capnproto_test::capnp::test::TestPipeline::GetAnyCapResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestPipeline", + 0xa5a404caa61d4cd0ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestPipeline +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::Box +constexpr uint16_t TestPipeline::Box::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::Box::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::Box::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::Box::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::AnyBox +constexpr uint16_t TestPipeline::AnyBox::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::AnyBox::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::AnyBox::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::AnyBox::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::GetCapParams +constexpr uint16_t TestPipeline::GetCapParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::GetCapParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::GetCapParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::GetCapParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::GetCapResults +constexpr uint16_t TestPipeline::GetCapResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::GetCapResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::GetCapResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::GetCapResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::TestPointersParams +constexpr uint16_t TestPipeline::TestPointersParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::TestPointersParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::TestPointersParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::TestPointersParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::TestPointersResults +constexpr uint16_t TestPipeline::TestPointersResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::TestPointersResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::TestPointersResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::TestPointersResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::GetAnyCapParams +constexpr uint16_t TestPipeline::GetAnyCapParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::GetAnyCapParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::GetAnyCapParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::GetAnyCapParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestPipeline::GetAnyCapResults +constexpr uint16_t TestPipeline::GetAnyCapResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestPipeline::GetAnyCapResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestPipeline::GetAnyCapResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestPipeline::GetAnyCapResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceParams, ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceResults> +TestCallOrder::Client::getCallSequenceRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceParams, ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceResults>( + 0xa0e77035bdff0051ull, 0, sizeHint); +} +::kj::Promise TestCallOrder::Server::getCallSequence(GetCallSequenceContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestCallOrder", "getCallSequence", + 0xa0e77035bdff0051ull, 0); +} +::kj::Promise TestCallOrder::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xa0e77035bdff0051ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestCallOrder", interfaceId); + } +} +::kj::Promise TestCallOrder::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return getCallSequence(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceParams, ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestCallOrder", + 0xa0e77035bdff0051ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestCallOrder +#if !CAPNP_LITE +constexpr ::capnp::Kind TestCallOrder::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestCallOrder::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestCallOrder::GetCallSequenceParams +constexpr uint16_t TestCallOrder::GetCallSequenceParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestCallOrder::GetCallSequenceParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestCallOrder::GetCallSequenceParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestCallOrder::GetCallSequenceParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestCallOrder::GetCallSequenceResults +constexpr uint16_t TestCallOrder::GetCallSequenceResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestCallOrder::GetCallSequenceResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestCallOrder::GetCallSequenceResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestCallOrder::GetCallSequenceResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestTailCallee::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult> +TestTailCallee::Client::fooRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestTailCallee::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult>( + 0xddd699207eb8e23bull, 0, sizeHint); +} +::kj::Promise TestTailCallee::Server::foo(FooContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestTailCallee", "foo", + 0xddd699207eb8e23bull, 0); +} +::kj::Promise TestTailCallee::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xddd699207eb8e23bull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestTailCallee", interfaceId); + } +} +::kj::Promise TestTailCallee::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return foo(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestTailCallee::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestTailCallee", + 0xddd699207eb8e23bull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestTailCallee +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTailCallee::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTailCallee::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestTailCallee::TailResult +constexpr uint16_t TestTailCallee::TailResult::_capnpPrivate::dataWordSize; +constexpr uint16_t TestTailCallee::TailResult::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTailCallee::TailResult::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTailCallee::TailResult::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestTailCallee::FooParams +constexpr uint16_t TestTailCallee::FooParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestTailCallee::FooParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTailCallee::FooParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTailCallee::FooParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestTailCaller::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult> +TestTailCaller::Client::fooRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestTailCaller::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult>( + 0x870bf40110ce3035ull, 0, sizeHint); +} +::kj::Promise TestTailCaller::Server::foo(FooContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestTailCaller", "foo", + 0x870bf40110ce3035ull, 0); +} +::kj::Promise TestTailCaller::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x870bf40110ce3035ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestTailCaller", interfaceId); + } +} +::kj::Promise TestTailCaller::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return foo(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestTailCaller::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestTailCaller", + 0x870bf40110ce3035ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestTailCaller +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTailCaller::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTailCaller::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestTailCaller::FooParams +constexpr uint16_t TestTailCaller::FooParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestTailCaller::FooParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTailCaller::FooParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTailCaller::FooParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::kj::Promise TestHandle::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xa38e5efe41e53a15ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestHandle", interfaceId); + } +} +::kj::Promise TestHandle::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestHandle", + 0xa38e5efe41e53a15ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestHandle +#if !CAPNP_LITE +constexpr ::capnp::Kind TestHandle::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestHandle::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallFooParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooResults> +TestMoreStuff::Client::callFooRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::CallFooParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooResults>( + 0xddc70bf9784133cfull, 0, sizeHint); +} +::kj::Promise TestMoreStuff::Server::callFoo(CallFooContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "callFoo", + 0xddc70bf9784133cfull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedResults> +TestMoreStuff::Client::callFooWhenResolvedRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedResults>( + 0xddc70bf9784133cfull, 1, sizeHint); +} +::kj::Promise TestMoreStuff::Server::callFooWhenResolved(CallFooWhenResolvedContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "callFooWhenResolved", + 0xddc70bf9784133cfull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnParams, ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnResults> +TestMoreStuff::Client::neverReturnRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnParams, ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnResults>( + 0xddc70bf9784133cfull, 2, sizeHint); +} +::kj::Promise TestMoreStuff::Server::neverReturn(NeverReturnContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "neverReturn", + 0xddc70bf9784133cfull, 2); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::HoldParams, ::capnproto_test::capnp::test::TestMoreStuff::HoldResults> +TestMoreStuff::Client::holdRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::HoldParams, ::capnproto_test::capnp::test::TestMoreStuff::HoldResults>( + 0xddc70bf9784133cfull, 3, sizeHint); +} +::kj::Promise TestMoreStuff::Server::hold(HoldContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "hold", + 0xddc70bf9784133cfull, 3); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::CallHeldResults> +TestMoreStuff::Client::callHeldRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::CallHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::CallHeldResults>( + 0xddc70bf9784133cfull, 4, sizeHint); +} +::kj::Promise TestMoreStuff::Server::callHeld(CallHeldContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "callHeld", + 0xddc70bf9784133cfull, 4); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHeldResults> +TestMoreStuff::Client::getHeldRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::GetHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHeldResults>( + 0xddc70bf9784133cfull, 5, sizeHint); +} +::kj::Promise TestMoreStuff::Server::getHeld(GetHeldContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "getHeld", + 0xddc70bf9784133cfull, 5); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::EchoParams, ::capnproto_test::capnp::test::TestMoreStuff::EchoResults> +TestMoreStuff::Client::echoRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::EchoParams, ::capnproto_test::capnp::test::TestMoreStuff::EchoResults>( + 0xddc70bf9784133cfull, 6, sizeHint); +} +::kj::Promise TestMoreStuff::Server::echo(EchoContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "echo", + 0xddc70bf9784133cfull, 6); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelParams, ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelResults> +TestMoreStuff::Client::expectCancelRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelParams, ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelResults>( + 0xddc70bf9784133cfull, 7, sizeHint); +} +::kj::Promise TestMoreStuff::Server::expectCancel(ExpectCancelContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "expectCancel", + 0xddc70bf9784133cfull, 7); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsResults> +TestMoreStuff::Client::methodWithDefaultsRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsResults>( + 0xddc70bf9784133cfull, 8, sizeHint); +} +::kj::Promise TestMoreStuff::Server::methodWithDefaults(MethodWithDefaultsContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "methodWithDefaults", + 0xddc70bf9784133cfull, 8); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetHandleParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHandleResults> +TestMoreStuff::Client::getHandleRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::GetHandleParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHandleResults>( + 0xddc70bf9784133cfull, 9, sizeHint); +} +::kj::Promise TestMoreStuff::Server::getHandle(GetHandleContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "getHandle", + 0xddc70bf9784133cfull, 9); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetNullParams, ::capnproto_test::capnp::test::TestMoreStuff::GetNullResults> +TestMoreStuff::Client::getNullRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::GetNullParams, ::capnproto_test::capnp::test::TestMoreStuff::GetNullResults>( + 0xddc70bf9784133cfull, 10, sizeHint); +} +::kj::Promise TestMoreStuff::Server::getNull(GetNullContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "getNull", + 0xddc70bf9784133cfull, 10); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringParams, ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringResults> +TestMoreStuff::Client::getEnormousStringRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringParams, ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringResults>( + 0xddc70bf9784133cfull, 11, sizeHint); +} +::kj::Promise TestMoreStuff::Server::getEnormousString(GetEnormousStringContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "getEnormousString", + 0xddc70bf9784133cfull, 11); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultResults> +TestMoreStuff::Client::methodWithNullDefaultRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultResults>( + 0xddc70bf9784133cfull, 12, sizeHint); +} +::kj::Promise TestMoreStuff::Server::methodWithNullDefault(MethodWithNullDefaultContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", "methodWithNullDefault", + 0xddc70bf9784133cfull, 12); +} +::kj::Promise TestMoreStuff::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xddc70bf9784133cfull: + return dispatchCallInternal(methodId, context); + case 0xa0e77035bdff0051ull: + return ::capnproto_test::capnp::test::TestCallOrder::Server::dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestMoreStuff", interfaceId); + } +} +::kj::Promise TestMoreStuff::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return callFoo(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::CallFooParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooResults>(context)); + case 1: + return callFooWhenResolved(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedResults>(context)); + case 2: + return neverReturn(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnParams, ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnResults>(context)); + case 3: + return hold(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::HoldParams, ::capnproto_test::capnp::test::TestMoreStuff::HoldResults>(context)); + case 4: + return callHeld(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::CallHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::CallHeldResults>(context)); + case 5: + return getHeld(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::GetHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHeldResults>(context)); + case 6: + return echo(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::EchoParams, ::capnproto_test::capnp::test::TestMoreStuff::EchoResults>(context)); + case 7: + return expectCancel(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelParams, ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelResults>(context)); + case 8: + return methodWithDefaults(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsResults>(context)); + case 9: + return getHandle(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::GetHandleParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHandleResults>(context)); + case 10: + return getNull(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::GetNullParams, ::capnproto_test::capnp::test::TestMoreStuff::GetNullResults>(context)); + case 11: + return getEnormousString(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringParams, ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringResults>(context)); + case 12: + return methodWithNullDefault(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMoreStuff", + 0xddc70bf9784133cfull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestMoreStuff +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallFooParams +constexpr uint16_t TestMoreStuff::CallFooParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallFooParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallFooParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallFooParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallFooResults +constexpr uint16_t TestMoreStuff::CallFooResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallFooResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallFooResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallFooResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallFooWhenResolvedParams +constexpr uint16_t TestMoreStuff::CallFooWhenResolvedParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallFooWhenResolvedParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallFooWhenResolvedParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallFooWhenResolvedParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallFooWhenResolvedResults +constexpr uint16_t TestMoreStuff::CallFooWhenResolvedResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallFooWhenResolvedResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallFooWhenResolvedResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallFooWhenResolvedResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::NeverReturnParams +constexpr uint16_t TestMoreStuff::NeverReturnParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::NeverReturnParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::NeverReturnParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::NeverReturnParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::NeverReturnResults +constexpr uint16_t TestMoreStuff::NeverReturnResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::NeverReturnResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::NeverReturnResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::NeverReturnResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::HoldParams +constexpr uint16_t TestMoreStuff::HoldParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::HoldParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::HoldParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::HoldParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::HoldResults +constexpr uint16_t TestMoreStuff::HoldResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::HoldResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::HoldResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::HoldResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallHeldParams +constexpr uint16_t TestMoreStuff::CallHeldParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallHeldParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallHeldParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallHeldParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::CallHeldResults +constexpr uint16_t TestMoreStuff::CallHeldResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::CallHeldResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::CallHeldResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::CallHeldResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetHeldParams +constexpr uint16_t TestMoreStuff::GetHeldParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetHeldParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetHeldParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetHeldParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetHeldResults +constexpr uint16_t TestMoreStuff::GetHeldResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetHeldResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetHeldResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetHeldResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::EchoParams +constexpr uint16_t TestMoreStuff::EchoParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::EchoParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::EchoParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::EchoParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::EchoResults +constexpr uint16_t TestMoreStuff::EchoResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::EchoResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::EchoResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::EchoResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::ExpectCancelParams +constexpr uint16_t TestMoreStuff::ExpectCancelParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::ExpectCancelParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::ExpectCancelParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::ExpectCancelParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::ExpectCancelResults +constexpr uint16_t TestMoreStuff::ExpectCancelResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::ExpectCancelResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::ExpectCancelResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::ExpectCancelResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::MethodWithDefaultsParams +constexpr uint16_t TestMoreStuff::MethodWithDefaultsParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::MethodWithDefaultsParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::MethodWithDefaultsParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::MethodWithDefaultsParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::MethodWithDefaultsResults +constexpr uint16_t TestMoreStuff::MethodWithDefaultsResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::MethodWithDefaultsResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::MethodWithDefaultsResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::MethodWithDefaultsResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetHandleParams +constexpr uint16_t TestMoreStuff::GetHandleParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetHandleParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetHandleParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetHandleParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetHandleResults +constexpr uint16_t TestMoreStuff::GetHandleResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetHandleResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetHandleResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetHandleResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetNullParams +constexpr uint16_t TestMoreStuff::GetNullParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetNullParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetNullParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetNullParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetNullResults +constexpr uint16_t TestMoreStuff::GetNullResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetNullResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetNullResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetNullResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetEnormousStringParams +constexpr uint16_t TestMoreStuff::GetEnormousStringParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetEnormousStringParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetEnormousStringParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetEnormousStringParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::GetEnormousStringResults +constexpr uint16_t TestMoreStuff::GetEnormousStringResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::GetEnormousStringResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::GetEnormousStringResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::GetEnormousStringResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::MethodWithNullDefaultParams +constexpr uint16_t TestMoreStuff::MethodWithNullDefaultParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::MethodWithNullDefaultParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::MethodWithNullDefaultParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::MethodWithNullDefaultParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMoreStuff::MethodWithNullDefaultResults +constexpr uint16_t TestMoreStuff::MethodWithNullDefaultResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMoreStuff::MethodWithNullDefaultResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMoreStuff::MethodWithNullDefaultResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMoreStuff::MethodWithNullDefaultResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::MakeThingParams, ::capnproto_test::capnp::test::TestMembrane::MakeThingResults> +TestMembrane::Client::makeThingRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::MakeThingParams, ::capnproto_test::capnp::test::TestMembrane::MakeThingResults>( + 0xc07d8dcd80a69c0cull, 0, sizeHint); +} +::kj::Promise TestMembrane::Server::makeThing(MakeThingContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", "makeThing", + 0xc07d8dcd80a69c0cull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::CallPassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result> +TestMembrane::Client::callPassThroughRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::CallPassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result>( + 0xc07d8dcd80a69c0cull, 1, sizeHint); +} +::kj::Promise TestMembrane::Server::callPassThrough(CallPassThroughContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", "callPassThrough", + 0xc07d8dcd80a69c0cull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::CallInterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result> +TestMembrane::Client::callInterceptRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::CallInterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result>( + 0xc07d8dcd80a69c0cull, 2, sizeHint); +} +::kj::Promise TestMembrane::Server::callIntercept(CallInterceptContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", "callIntercept", + 0xc07d8dcd80a69c0cull, 2); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::LoopbackParams, ::capnproto_test::capnp::test::TestMembrane::LoopbackResults> +TestMembrane::Client::loopbackRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::LoopbackParams, ::capnproto_test::capnp::test::TestMembrane::LoopbackResults>( + 0xc07d8dcd80a69c0cull, 3, sizeHint); +} +::kj::Promise TestMembrane::Server::loopback(LoopbackContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", "loopback", + 0xc07d8dcd80a69c0cull, 3); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::WaitForeverParams, ::capnproto_test::capnp::test::TestMembrane::WaitForeverResults> +TestMembrane::Client::waitForeverRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::WaitForeverParams, ::capnproto_test::capnp::test::TestMembrane::WaitForeverResults>( + 0xc07d8dcd80a69c0cull, 4, sizeHint); +} +::kj::Promise TestMembrane::Server::waitForever(WaitForeverContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", "waitForever", + 0xc07d8dcd80a69c0cull, 4); +} +::kj::Promise TestMembrane::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xc07d8dcd80a69c0cull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestMembrane", interfaceId); + } +} +::kj::Promise TestMembrane::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return makeThing(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::MakeThingParams, ::capnproto_test::capnp::test::TestMembrane::MakeThingResults>(context)); + case 1: + return callPassThrough(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::CallPassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result>(context)); + case 2: + return callIntercept(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::CallInterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result>(context)); + case 3: + return loopback(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::LoopbackParams, ::capnproto_test::capnp::test::TestMembrane::LoopbackResults>(context)); + case 4: + return waitForever(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::WaitForeverParams, ::capnproto_test::capnp::test::TestMembrane::WaitForeverResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane", + 0xc07d8dcd80a69c0cull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestMembrane +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::Thing::PassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result> +TestMembrane::Thing::Client::passThroughRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::Thing::PassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result>( + 0x9352e4e41f173917ull, 0, sizeHint); +} +::kj::Promise TestMembrane::Thing::Server::passThrough(PassThroughContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane.Thing", "passThrough", + 0x9352e4e41f173917ull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::Thing::InterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result> +TestMembrane::Thing::Client::interceptRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestMembrane::Thing::InterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result>( + 0x9352e4e41f173917ull, 1, sizeHint); +} +::kj::Promise TestMembrane::Thing::Server::intercept(InterceptContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane.Thing", "intercept", + 0x9352e4e41f173917ull, 1); +} +::kj::Promise TestMembrane::Thing::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x9352e4e41f173917ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestMembrane.Thing", interfaceId); + } +} +::kj::Promise TestMembrane::Thing::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return passThrough(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::Thing::PassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result>(context)); + case 1: + return intercept(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestMembrane::Thing::InterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestMembrane.Thing", + 0x9352e4e41f173917ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestMembrane::Thing +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::Thing::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::Thing::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::Thing::PassThroughParams +constexpr uint16_t TestMembrane::Thing::PassThroughParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::Thing::PassThroughParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::Thing::PassThroughParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::Thing::PassThroughParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::Thing::InterceptParams +constexpr uint16_t TestMembrane::Thing::InterceptParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::Thing::InterceptParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::Thing::InterceptParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::Thing::InterceptParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::Result +constexpr uint16_t TestMembrane::Result::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::Result::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::Result::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::Result::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::MakeThingParams +constexpr uint16_t TestMembrane::MakeThingParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::MakeThingParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::MakeThingParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::MakeThingParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::MakeThingResults +constexpr uint16_t TestMembrane::MakeThingResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::MakeThingResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::MakeThingResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::MakeThingResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::CallPassThroughParams +constexpr uint16_t TestMembrane::CallPassThroughParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::CallPassThroughParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::CallPassThroughParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::CallPassThroughParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::CallInterceptParams +constexpr uint16_t TestMembrane::CallInterceptParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::CallInterceptParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::CallInterceptParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::CallInterceptParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::LoopbackParams +constexpr uint16_t TestMembrane::LoopbackParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::LoopbackParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::LoopbackParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::LoopbackParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::LoopbackResults +constexpr uint16_t TestMembrane::LoopbackResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::LoopbackResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::LoopbackResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::LoopbackResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::WaitForeverParams +constexpr uint16_t TestMembrane::WaitForeverParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::WaitForeverParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::WaitForeverParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::WaitForeverParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestMembrane::WaitForeverResults +constexpr uint16_t TestMembrane::WaitForeverResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestMembrane::WaitForeverResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestMembrane::WaitForeverResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestMembrane::WaitForeverResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestContainMembrane +constexpr uint16_t TestContainMembrane::_capnpPrivate::dataWordSize; +constexpr uint16_t TestContainMembrane::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestContainMembrane::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestContainMembrane::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestTransferCap +constexpr uint16_t TestTransferCap::_capnpPrivate::dataWordSize; +constexpr uint16_t TestTransferCap::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTransferCap::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTransferCap::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestTransferCap::Element +constexpr uint16_t TestTransferCap::Element::_capnpPrivate::dataWordSize; +constexpr uint16_t TestTransferCap::Element::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestTransferCap::Element::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestTransferCap::Element::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::DeleteParams, ::capnproto_test::capnp::test::TestKeywordMethods::DeleteResults> +TestKeywordMethods::Client::deleteRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestKeywordMethods::DeleteParams, ::capnproto_test::capnp::test::TestKeywordMethods::DeleteResults>( + 0x9ae342d394247cfcull, 0, sizeHint); +} +::kj::Promise TestKeywordMethods::Server::delete_(DeleteContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestKeywordMethods", "delete", + 0x9ae342d394247cfcull, 0); +} +::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::ClassParams, ::capnproto_test::capnp::test::TestKeywordMethods::ClassResults> +TestKeywordMethods::Client::classRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestKeywordMethods::ClassParams, ::capnproto_test::capnp::test::TestKeywordMethods::ClassResults>( + 0x9ae342d394247cfcull, 1, sizeHint); +} +::kj::Promise TestKeywordMethods::Server::class_(ClassContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestKeywordMethods", "class", + 0x9ae342d394247cfcull, 1); +} +::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::VoidParams, ::capnproto_test::capnp::test::TestKeywordMethods::VoidResults> +TestKeywordMethods::Client::voidRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestKeywordMethods::VoidParams, ::capnproto_test::capnp::test::TestKeywordMethods::VoidResults>( + 0x9ae342d394247cfcull, 2, sizeHint); +} +::kj::Promise TestKeywordMethods::Server::void_(VoidContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestKeywordMethods", "void", + 0x9ae342d394247cfcull, 2); +} +::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::ReturnParams, ::capnproto_test::capnp::test::TestKeywordMethods::ReturnResults> +TestKeywordMethods::Client::returnRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestKeywordMethods::ReturnParams, ::capnproto_test::capnp::test::TestKeywordMethods::ReturnResults>( + 0x9ae342d394247cfcull, 3, sizeHint); +} +::kj::Promise TestKeywordMethods::Server::return_(ReturnContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestKeywordMethods", "return", + 0x9ae342d394247cfcull, 3); +} +::kj::Promise TestKeywordMethods::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x9ae342d394247cfcull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestKeywordMethods", interfaceId); + } +} +::kj::Promise TestKeywordMethods::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return delete_(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestKeywordMethods::DeleteParams, ::capnproto_test::capnp::test::TestKeywordMethods::DeleteResults>(context)); + case 1: + return class_(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestKeywordMethods::ClassParams, ::capnproto_test::capnp::test::TestKeywordMethods::ClassResults>(context)); + case 2: + return void_(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestKeywordMethods::VoidParams, ::capnproto_test::capnp::test::TestKeywordMethods::VoidResults>(context)); + case 3: + return return_(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestKeywordMethods::ReturnParams, ::capnproto_test::capnp::test::TestKeywordMethods::ReturnResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestKeywordMethods", + 0x9ae342d394247cfcull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestKeywordMethods +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::DeleteParams +constexpr uint16_t TestKeywordMethods::DeleteParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::DeleteParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::DeleteParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::DeleteParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::DeleteResults +constexpr uint16_t TestKeywordMethods::DeleteResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::DeleteResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::DeleteResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::DeleteResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::ClassParams +constexpr uint16_t TestKeywordMethods::ClassParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::ClassParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::ClassParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::ClassParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::ClassResults +constexpr uint16_t TestKeywordMethods::ClassResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::ClassResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::ClassResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::ClassResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::VoidParams +constexpr uint16_t TestKeywordMethods::VoidParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::VoidParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::VoidParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::VoidParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::VoidResults +constexpr uint16_t TestKeywordMethods::VoidResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::VoidResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::VoidResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::VoidResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::ReturnParams +constexpr uint16_t TestKeywordMethods::ReturnParams::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::ReturnParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::ReturnParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::ReturnParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestKeywordMethods::ReturnResults +constexpr uint16_t TestKeywordMethods::ReturnResults::_capnpPrivate::dataWordSize; +constexpr uint16_t TestKeywordMethods::ReturnResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestKeywordMethods::ReturnResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestKeywordMethods::ReturnResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestSturdyRef +constexpr uint16_t TestSturdyRef::_capnpPrivate::dataWordSize; +constexpr uint16_t TestSturdyRef::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestSturdyRef::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestSturdyRef::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestSturdyRefHostId +constexpr uint16_t TestSturdyRefHostId::_capnpPrivate::dataWordSize; +constexpr uint16_t TestSturdyRefHostId::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestSturdyRefHostId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestSturdyRefHostId::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestSturdyRefObjectId +constexpr uint16_t TestSturdyRefObjectId::_capnpPrivate::dataWordSize; +constexpr uint16_t TestSturdyRefObjectId::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestSturdyRefObjectId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestSturdyRefObjectId::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestProvisionId +constexpr uint16_t TestProvisionId::_capnpPrivate::dataWordSize; +constexpr uint16_t TestProvisionId::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestProvisionId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestProvisionId::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestRecipientId +constexpr uint16_t TestRecipientId::_capnpPrivate::dataWordSize; +constexpr uint16_t TestRecipientId::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestRecipientId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestRecipientId::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestThirdPartyCapId +constexpr uint16_t TestThirdPartyCapId::_capnpPrivate::dataWordSize; +constexpr uint16_t TestThirdPartyCapId::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestThirdPartyCapId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestThirdPartyCapId::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// TestJoinResult +constexpr uint16_t TestJoinResult::_capnpPrivate::dataWordSize; +constexpr uint16_t TestJoinResult::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind TestJoinResult::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TestJoinResult::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedStruct +constexpr uint16_t RenamedStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedStruct::RenamedNestedStruct +constexpr uint16_t RenamedStruct::RenamedNestedStruct::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedStruct::RenamedNestedStruct::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedStruct::RenamedNestedStruct::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedStruct::RenamedNestedStruct::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedStruct::RenamedUnion +constexpr uint16_t RenamedStruct::RenamedUnion::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedStruct::RenamedUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedStruct::RenamedUnion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedStruct::RenamedUnion::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedStruct::RenamedUnion::RenamedGroup +constexpr uint16_t RenamedStruct::RenamedUnion::RenamedGroup::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedStruct::RenamedUnion::RenamedGroup::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedStruct::RenamedUnion::RenamedGroup::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedStruct::RenamedUnion::RenamedGroup::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +::capnp::Request< ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodParams, ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodResults> +RenamedInterface::Client::renamedMethodRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodParams, ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodResults>( + 0xd112a69d31ed918bull, 0, sizeHint); +} +::kj::Promise RenamedInterface::Server::renamedMethod(RenamedMethodContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestNameAnnotationInterface", "renamedMethod", + 0xd112a69d31ed918bull, 0); +} +::kj::Promise RenamedInterface::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xd112a69d31ed918bull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestNameAnnotationInterface", interfaceId); + } +} +::kj::Promise RenamedInterface::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return renamedMethod(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodParams, ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestNameAnnotationInterface", + 0xd112a69d31ed918bull, methodId); + } +} +#endif // !CAPNP_LITE + +// RenamedInterface +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedInterface::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedInterface::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedInterface::RenamedMethodParams +constexpr uint16_t RenamedInterface::RenamedMethodParams::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedInterface::RenamedMethodParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedInterface::RenamedMethodParams::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedInterface::RenamedMethodParams::_capnpPrivate::schema; +#endif // !CAPNP_LITE + +// RenamedInterface::RenamedMethodResults +constexpr uint16_t RenamedInterface::RenamedMethodResults::_capnpPrivate::dataWordSize; +constexpr uint16_t RenamedInterface::RenamedMethodResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +constexpr ::capnp::Kind RenamedInterface::RenamedMethodResults::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RenamedInterface::RenamedMethodResults::_capnpPrivate::schema; +#endif // !CAPNP_LITE + + +} // namespace +} // namespace +} // namespace + diff --git a/CapnpCompatTest/test.capnp.h b/CapnpCompatTest/test.capnp.h new file mode 100644 index 0000000..cb19809 --- /dev/null +++ b/CapnpCompatTest/test.capnp.h @@ -0,0 +1,33864 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: test.capnp + +#pragma once + +#include +#include +#if !CAPNP_LITE +#include +#endif // !CAPNP_LITE + +#if CAPNP_VERSION != 7000 +#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#endif + + +namespace capnp { +namespace schemas { + +CAPNP_DECLARE_SCHEMA(9c8e9318b29d9cd3); +enum class TestEnum_9c8e9318b29d9cd3: uint16_t { + FOO, + BAR, + BAZ, + QUX, + QUUX, + CORGE, + GRAULT, + GARPLY, +}; +CAPNP_DECLARE_ENUM(TestEnum, 9c8e9318b29d9cd3); +CAPNP_DECLARE_SCHEMA(a0a8f314b80b63fd); +CAPNP_DECLARE_SCHEMA(eb3f9ebe98c73cb6); +CAPNP_DECLARE_SCHEMA(e3da5a2ccd28c0d8); +CAPNP_DECLARE_SCHEMA(f49850f63c2bfa59); +CAPNP_DECLARE_SCHEMA(a9d5f8efe770022b); +CAPNP_DECLARE_SCHEMA(f47697362233ce52); +CAPNP_DECLARE_SCHEMA(fc76a82eecb7a718); +CAPNP_DECLARE_SCHEMA(ee0a6b99b7dc7ab2); +CAPNP_DECLARE_SCHEMA(afc5fd419f0d66d4); +CAPNP_DECLARE_SCHEMA(a2fb022ec7f30053); +CAPNP_DECLARE_SCHEMA(9e2e784c915329b6); +CAPNP_DECLARE_SCHEMA(89a9494f1b900f22); +CAPNP_DECLARE_SCHEMA(d005f6c63707670c); +CAPNP_DECLARE_SCHEMA(ff9ce111c6f8e5db); +CAPNP_DECLARE_SCHEMA(dc841556134c3103); +CAPNP_DECLARE_SCHEMA(e22ae74ff9113268); +CAPNP_DECLARE_SCHEMA(f5fcba89c0c1196f); +CAPNP_DECLARE_SCHEMA(f0fa30304066a4b3); +CAPNP_DECLARE_SCHEMA(b727c0d0091a001d); +CAPNP_DECLARE_SCHEMA(f77ed6f7454eec40); +CAPNP_DECLARE_SCHEMA(c7485a3516c7d3c8); +CAPNP_DECLARE_SCHEMA(db0afd413f4a313a); +CAPNP_DECLARE_SCHEMA(cc85a335569990e9); +CAPNP_DECLARE_SCHEMA(a017f0366827ee37); +CAPNP_DECLARE_SCHEMA(94f7e0b103b4b718); +CAPNP_DECLARE_SCHEMA(d9f2b5941a343bcd); +CAPNP_DECLARE_SCHEMA(b651d2fba42056d4); +enum class NestedEnum_b651d2fba42056d4: uint16_t { + FOO, + BAR, +}; +CAPNP_DECLARE_ENUM(NestedEnum, b651d2fba42056d4); +CAPNP_DECLARE_SCHEMA(82cd03a53b29d76b); +CAPNP_DECLARE_SCHEMA(cfa0d546993a3df3); +enum class NestedEnum_cfa0d546993a3df3: uint16_t { + BAZ, + QUX, + QUUX, +}; +CAPNP_DECLARE_ENUM(NestedEnum, cfa0d546993a3df3); +CAPNP_DECLARE_SCHEMA(e78aac389e77b065); +CAPNP_DECLARE_SCHEMA(e41885c94393277e); +CAPNP_DECLARE_SCHEMA(8412c03b75b2cfee); +CAPNP_DECLARE_SCHEMA(e0fe5870b141ad69); +CAPNP_DECLARE_SCHEMA(a6411a353090145b); +CAPNP_DECLARE_SCHEMA(a8abf7a82928986c); +CAPNP_DECLARE_SCHEMA(ad7beedc4ed30742); +CAPNP_DECLARE_SCHEMA(ef9a34f2ff7cc646); +CAPNP_DECLARE_SCHEMA(c6abf1b0329e6227); +CAPNP_DECLARE_SCHEMA(943a234ca336b16a); +CAPNP_DECLARE_SCHEMA(8991bc0e74a594cd); +CAPNP_DECLARE_SCHEMA(ed267416528c7a24); +CAPNP_DECLARE_SCHEMA(9978837b037d58e6); +CAPNP_DECLARE_SCHEMA(ed5fa940f54a7904); +CAPNP_DECLARE_SCHEMA(bc743778f2597c7d); +CAPNP_DECLARE_SCHEMA(c2e364a40182013d); +CAPNP_DECLARE_SCHEMA(92fc29a80f3ddd5c); +CAPNP_DECLARE_SCHEMA(a851ad32cbc2ffea); +CAPNP_DECLARE_SCHEMA(a76e3c9bb7fd56d3); +CAPNP_DECLARE_SCHEMA(807280a2901aa079); +CAPNP_DECLARE_SCHEMA(c1973984dee98e3a); +CAPNP_DECLARE_SCHEMA(95b30dd14e01dda8); +CAPNP_DECLARE_SCHEMA(8ed75a7469f04ce3); +CAPNP_DECLARE_SCHEMA(bd5fe16e5170c492); +CAPNP_DECLARE_SCHEMA(c7e4c513a975492b); +CAPNP_DECLARE_SCHEMA(86232c1de4513e84); +CAPNP_DECLARE_SCHEMA(faf781ef89a00e39); +CAPNP_DECLARE_SCHEMA(9daec9823f171085); +CAPNP_DECLARE_SCHEMA(992edc677bef5a3c); +CAPNP_DECLARE_SCHEMA(dec497819d097c3c); +CAPNP_DECLARE_SCHEMA(8e4936003708dac2); +CAPNP_DECLARE_SCHEMA(91afd4a864dbb030); +CAPNP_DECLARE_SCHEMA(b24fe52e5b90f3eb); +CAPNP_DECLARE_SCHEMA(f6912d555f7b2f5e); +CAPNP_DECLARE_SCHEMA(9d5b8cd8de9922eb); +CAPNP_DECLARE_SCHEMA(f6a841117e19ac73); +CAPNP_DECLARE_SCHEMA(a9ab42b118d6d435); +CAPNP_DECLARE_SCHEMA(b6a0829c762b06f3); +CAPNP_DECLARE_SCHEMA(8839ed86c9794287); +CAPNP_DECLARE_SCHEMA(b84eecc799437049); +CAPNP_DECLARE_SCHEMA(e080f0fc54614f6f); +CAPNP_DECLARE_SCHEMA(c9e749e8dd54da5c); +CAPNP_DECLARE_SCHEMA(a5b46224e33581ad); +CAPNP_DECLARE_SCHEMA(8952716de9200dff); +CAPNP_DECLARE_SCHEMA(8e656edfb45ba6cf); +CAPNP_DECLARE_SCHEMA(b46a779beaf3384e); +CAPNP_DECLARE_SCHEMA(a9b2b1f52dde845d); +CAPNP_DECLARE_SCHEMA(f28f83667a557a04); +CAPNP_DECLARE_SCHEMA(8b9717a3f8d85a9a); +CAPNP_DECLARE_SCHEMA(f83f8caf54bdc486); +CAPNP_DECLARE_SCHEMA(df9ccdeb81a704c9); +CAPNP_DECLARE_SCHEMA(9aab8e25c808d71e); +CAPNP_DECLARE_SCHEMA(a54870440e919063); +CAPNP_DECLARE_SCHEMA(9427b2a71030338f); +CAPNP_DECLARE_SCHEMA(c5598844441096dc); +CAPNP_DECLARE_SCHEMA(abed745cd8c92095); +CAPNP_DECLARE_SCHEMA(d657409805207187); +CAPNP_DECLARE_SCHEMA(bbe5b10ebd841165); +CAPNP_DECLARE_SCHEMA(e4bf8760a0aded86); +CAPNP_DECLARE_SCHEMA(9747fed267e18cab); +CAPNP_DECLARE_SCHEMA(90794c40ae9ed82b); +CAPNP_DECLARE_SCHEMA(c1834c909dfff36b); +CAPNP_DECLARE_SCHEMA(8b9e0acc1bce0872); +CAPNP_DECLARE_SCHEMA(a32c242eab4fd252); +CAPNP_DECLARE_SCHEMA(b9c5472fc14639d5); +CAPNP_DECLARE_SCHEMA(aae78676ba1dbcbb); +CAPNP_DECLARE_SCHEMA(a25661f8942c24cc); +CAPNP_DECLARE_SCHEMA(db2194bab1b25c48); +CAPNP_DECLARE_SCHEMA(f346e8becc34c826); +CAPNP_DECLARE_SCHEMA(aaa4fc67c55b78fd); +CAPNP_DECLARE_SCHEMA(ed37d4414bf1157a); +CAPNP_DECLARE_SCHEMA(f6a160eb0b3687fa); +CAPNP_DECLARE_SCHEMA(e3201c2e657cf0fc); +CAPNP_DECLARE_SCHEMA(ce1810c84e108cdc); +CAPNP_DECLARE_SCHEMA(ff58bf5895b73ee2); +CAPNP_DECLARE_SCHEMA(a145449a15848a09); +CAPNP_DECLARE_SCHEMA(a567a743b6b4bf0d); +CAPNP_DECLARE_SCHEMA(d987eb8af5945021); +CAPNP_DECLARE_SCHEMA(9e55f87eb2ffa805); +CAPNP_DECLARE_SCHEMA(fe4d1147d7537f4c); +CAPNP_DECLARE_SCHEMA(900218d4541375d3); +CAPNP_DECLARE_SCHEMA(d26dd7a486f26cd7); +CAPNP_DECLARE_SCHEMA(feb875138580a065); +CAPNP_DECLARE_SCHEMA(a815a514acbab212); +CAPNP_DECLARE_SCHEMA(ec56db537c838603); +CAPNP_DECLARE_SCHEMA(c468785db6321458); +CAPNP_DECLARE_SCHEMA(d1f994d3d4fbbaed); +CAPNP_DECLARE_SCHEMA(c30860d747fd5019); +CAPNP_DECLARE_SCHEMA(ca4028a84b8fc2ed); +CAPNP_DECLARE_SCHEMA(d81b65e268fb3f34); +CAPNP_DECLARE_SCHEMA(bd579b448bfbcc7b); +CAPNP_DECLARE_SCHEMA(a00141d482942422); +CAPNP_DECLARE_SCHEMA(a4764c3483341eeb); +CAPNP_DECLARE_SCHEMA(b70341f0dafa28ef); +CAPNP_DECLARE_SCHEMA(d7c0fea759d6a0cf); +CAPNP_DECLARE_SCHEMA(8e59556fb309253f); +CAPNP_DECLARE_SCHEMA(dec09c6791841ebb); +CAPNP_DECLARE_SCHEMA(fb7ed666617fb649); +CAPNP_DECLARE_SCHEMA(ddc280dbee9c99b3); +CAPNP_DECLARE_SCHEMA(8139f596ebaf6185); +CAPNP_DECLARE_SCHEMA(88eb12a0e0af92b2); +CAPNP_DECLARE_SCHEMA(b874edc0d559b391); +CAPNP_DECLARE_SCHEMA(b04fcaddab714ba4); +CAPNP_DECLARE_SCHEMA(d044893357b42568); +CAPNP_DECLARE_SCHEMA(9bf141df4247d52f); +CAPNP_DECLARE_SCHEMA(d9ac8abb2a91cfbc); +CAPNP_DECLARE_SCHEMA(9b99d14f2f375b2d); +CAPNP_DECLARE_SCHEMA(e4e9bac98670b748); +CAPNP_DECLARE_SCHEMA(83a4bc5471363f17); +CAPNP_DECLARE_SCHEMA(8e4b3d1a3e2753dd); +CAPNP_DECLARE_SCHEMA(acf67532a7e7bad9); +CAPNP_DECLARE_SCHEMA(f3b834e851ea8af6); +CAPNP_DECLARE_SCHEMA(98d7e0ef61488783); +CAPNP_DECLARE_SCHEMA(a5a404caa61d4cd0); +CAPNP_DECLARE_SCHEMA(b0b29e51db0e26b1); +CAPNP_DECLARE_SCHEMA(9442ad5a1d2c8acb); +CAPNP_DECLARE_SCHEMA(c7e8df5096257034); +CAPNP_DECLARE_SCHEMA(b2442a9e0ba28fdf); +CAPNP_DECLARE_SCHEMA(a604ee63cf37819f); +CAPNP_DECLARE_SCHEMA(8eda54756c6070d6); +CAPNP_DECLARE_SCHEMA(f8e36b53ab093d4e); +CAPNP_DECLARE_SCHEMA(bf44b4c94c26ef79); +CAPNP_DECLARE_SCHEMA(a0e77035bdff0051); +CAPNP_DECLARE_SCHEMA(8f1e8cd56ceb74dc); +CAPNP_DECLARE_SCHEMA(dedbb6bf3810eab7); +CAPNP_DECLARE_SCHEMA(ddd699207eb8e23b); +CAPNP_DECLARE_SCHEMA(a9ed2e5a9fd53d19); +CAPNP_DECLARE_SCHEMA(c5e1efc325614957); +CAPNP_DECLARE_SCHEMA(870bf40110ce3035); +CAPNP_DECLARE_SCHEMA(b07a279515dc8ac5); +CAPNP_DECLARE_SCHEMA(a38e5efe41e53a15); +CAPNP_DECLARE_SCHEMA(ddc70bf9784133cf); +CAPNP_DECLARE_SCHEMA(931ba418da60f6e4); +CAPNP_DECLARE_SCHEMA(9a28970beccecdd0); +CAPNP_DECLARE_SCHEMA(fabc700c2ebe6378); +CAPNP_DECLARE_SCHEMA(a54ce1e9aa822f90); +CAPNP_DECLARE_SCHEMA(94fe60465c95182b); +CAPNP_DECLARE_SCHEMA(def4e5fa6999c5dc); +CAPNP_DECLARE_SCHEMA(fe7c8fbb769d8e58); +CAPNP_DECLARE_SCHEMA(f839fb1374d003c9); +CAPNP_DECLARE_SCHEMA(f8c5e5ef1edf83be); +CAPNP_DECLARE_SCHEMA(e59935f160ac7578); +CAPNP_DECLARE_SCHEMA(feffc025fce317e3); +CAPNP_DECLARE_SCHEMA(ef4e146185af67ce); +CAPNP_DECLARE_SCHEMA(c07526f7e2e533b9); +CAPNP_DECLARE_SCHEMA(a6224536593d5b92); +CAPNP_DECLARE_SCHEMA(a1cc32d87f3edeb1); +CAPNP_DECLARE_SCHEMA(8a3eba1758c0916e); +CAPNP_DECLARE_SCHEMA(99160a25fa50fbf1); +CAPNP_DECLARE_SCHEMA(9c7e066f845a6c56); +CAPNP_DECLARE_SCHEMA(ead024a301a092a1); +CAPNP_DECLARE_SCHEMA(c3490d75420a1fe8); +CAPNP_DECLARE_SCHEMA(d8493f0e175d61f2); +CAPNP_DECLARE_SCHEMA(e6955d8ef1023671); +CAPNP_DECLARE_SCHEMA(805df436f55dd07a); +CAPNP_DECLARE_SCHEMA(860e7512dc3925b0); +CAPNP_DECLARE_SCHEMA(fb92899aeb0ee74f); +CAPNP_DECLARE_SCHEMA(8467348247305cf7); +CAPNP_DECLARE_SCHEMA(c07d8dcd80a69c0c); +CAPNP_DECLARE_SCHEMA(9352e4e41f173917); +CAPNP_DECLARE_SCHEMA(ff9bdcd05085d786); +CAPNP_DECLARE_SCHEMA(ee94bed3615ee745); +CAPNP_DECLARE_SCHEMA(b0c6163faf291965); +CAPNP_DECLARE_SCHEMA(d8ac2acc3ece6556); +CAPNP_DECLARE_SCHEMA(e5d4904814ccbf29); +CAPNP_DECLARE_SCHEMA(945d9f634a6a29da); +CAPNP_DECLARE_SCHEMA(8749aac3375c5c71); +CAPNP_DECLARE_SCHEMA(869a1b7ab34b42c9); +CAPNP_DECLARE_SCHEMA(ecd19398fd88ab5c); +CAPNP_DECLARE_SCHEMA(8f6bb30cc62917ff); +CAPNP_DECLARE_SCHEMA(c343a4907280be01); +CAPNP_DECLARE_SCHEMA(949449ad7c11fa5c); +CAPNP_DECLARE_SCHEMA(dd2b66a791a279f0); +CAPNP_DECLARE_SCHEMA(c7263e8f88844abc); +CAPNP_DECLARE_SCHEMA(9ae342d394247cfc); +CAPNP_DECLARE_SCHEMA(ca3a89cdeb6bd6b7); +CAPNP_DECLARE_SCHEMA(eeb5843598307592); +CAPNP_DECLARE_SCHEMA(9cf5a8313c5db036); +CAPNP_DECLARE_SCHEMA(c0253868ac12e7d8); +CAPNP_DECLARE_SCHEMA(a4a08763833c7757); +CAPNP_DECLARE_SCHEMA(de82773089c0aeab); +CAPNP_DECLARE_SCHEMA(99817360625e8ca3); +CAPNP_DECLARE_SCHEMA(b70872e07eaa992f); +CAPNP_DECLARE_SCHEMA(ea72cc77253798cd); +CAPNP_DECLARE_SCHEMA(8ec30e2451f1cffe); +CAPNP_DECLARE_SCHEMA(c71cf776034a3e67); +CAPNP_DECLARE_SCHEMA(ceba982cb629f6c2); +CAPNP_DECLARE_SCHEMA(e02d3bbe1010e342); +CAPNP_DECLARE_SCHEMA(aeb2ad168e2f5697); +CAPNP_DECLARE_SCHEMA(ef428f2f67c4d439); +enum class Tag_ef428f2f67c4d439: uint16_t { + TEST_INTERFACE, + TEST_EXTENDS, + TEST_PIPELINE, + TEST_TAIL_CALLEE, + TEST_TAIL_CALLER, + TEST_MORE_STUFF, +}; +CAPNP_DECLARE_ENUM(Tag, ef428f2f67c4d439); +CAPNP_DECLARE_SCHEMA(9e5c574772b1d462); +CAPNP_DECLARE_SCHEMA(ea2fb7dca9cdbdea); +CAPNP_DECLARE_SCHEMA(a805157b98b65469); +CAPNP_DECLARE_SCHEMA(f4c58a8ebcd0f600); +CAPNP_DECLARE_SCHEMA(d1fd8e9caf2a5d58); +CAPNP_DECLARE_SCHEMA(f610d1deb4c9e84a); +enum class RenamedEnum_f610d1deb4c9e84a: uint16_t { + FOO, + BAR, + QUX, +}; +CAPNP_DECLARE_ENUM(RenamedEnum, f610d1deb4c9e84a); +CAPNP_DECLARE_SCHEMA(be406b6341d52284); +CAPNP_DECLARE_SCHEMA(f6cb3f9c7a4322e0); +enum class RenamedDeeplyNestedEnum_f6cb3f9c7a4322e0: uint16_t { + QUUX, + CORGE, + GARPLY, +}; +CAPNP_DECLARE_ENUM(RenamedDeeplyNestedEnum, f6cb3f9c7a4322e0); +CAPNP_DECLARE_SCHEMA(89d9d1626b34017c); +CAPNP_DECLARE_SCHEMA(c3594bce5b24b722); +CAPNP_DECLARE_SCHEMA(d112a69d31ed918b); +CAPNP_DECLARE_SCHEMA(c12efc3b075adfe9); +CAPNP_DECLARE_SCHEMA(dcc3cdb4b28f6c86); + +} // namespace schemas +} // namespace capnp + +namespace capnproto_test { +namespace capnp { +namespace test { + +typedef ::capnp::schemas::TestEnum_9c8e9318b29d9cd3 TestEnum; + +struct TestAllTypes { + TestAllTypes() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a0a8f314b80b63fd, 6, 20) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestDefaults { + TestDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(eb3f9ebe98c73cb6, 6, 20) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestAnyPointer { + TestAnyPointer() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e3da5a2ccd28c0d8, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestAnyOthers { + TestAnyOthers() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f49850f63c2bfa59, 0, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestOutOfOrder { + TestOutOfOrder() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a9d5f8efe770022b, 0, 9) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnion { + TestUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Union0; + struct Union1; + struct Union2; + struct Union3; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f47697362233ce52, 8, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnion::Union0 { + Union0() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U0F0S0, + U0F0S1, + U0F0S8, + U0F0S16, + U0F0S32, + U0F0S64, + U0F0SP, + U0F1S0, + U0F1S1, + U0F1S8, + U0F1S16, + U0F1S32, + U0F1S64, + U0F1SP, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(fc76a82eecb7a718, 8, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnion::Union1 { + Union1() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U1F0S0, + U1F0S1, + U1F1S1, + U1F0S8, + U1F1S8, + U1F0S16, + U1F1S16, + U1F0S32, + U1F1S32, + U1F0S64, + U1F1S64, + U1F0SP, + U1F1SP, + U1F2S0, + U1F2S1, + U1F2S8, + U1F2S16, + U1F2S32, + U1F2S64, + U1F2SP, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ee0a6b99b7dc7ab2, 8, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnion::Union2 { + Union2() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U2F0S1, + U2F0S8, + U2F0S16, + U2F0S32, + U2F0S64, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(afc5fd419f0d66d4, 8, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnion::Union3 { + Union3() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U3F0S1, + U3F0S8, + U3F0S16, + U3F0S32, + U3F0S64, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a2fb022ec7f30053, 8, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnnamedUnion { + TestUnnamedUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAR, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9e2e784c915329b6, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnionInUnion { + TestUnionInUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Outer; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(89a9494f1b900f22, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnionInUnion::Outer { + Outer() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + INNER, + BAZ, + }; + struct Inner; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d005f6c63707670c, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnionInUnion::Outer::Inner { + Inner() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAR, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ff9ce111c6f8e5db, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestGroups { + TestGroups() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Groups; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(dc841556134c3103, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestGroups::Groups { + Groups() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAZ, + BAR, + }; + struct Foo; + struct Baz; + struct Bar; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e22ae74ff9113268, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestGroups::Groups::Foo { + Foo() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f5fcba89c0c1196f, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestGroups::Groups::Baz { + Baz() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f0fa30304066a4b3, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestGroups::Groups::Bar { + Bar() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b727c0d0091a001d, 2, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterleavedGroups { + TestInterleavedGroups() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Group1; + struct Group2; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f77ed6f7454eec40, 6, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterleavedGroups::Group1 { + Group1() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + FRED, + }; + struct Corge; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c7485a3516c7d3c8, 6, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterleavedGroups::Group1::Corge { + Corge() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(db0afd413f4a313a, 6, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterleavedGroups::Group2 { + Group2() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + FRED, + }; + struct Corge; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(cc85a335569990e9, 6, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterleavedGroups::Group2::Corge { + Corge() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a017f0366827ee37, 6, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUnionDefaults { + TestUnionDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(94f7e0b103b4b718, 0, 4) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestNestedTypes { + TestNestedTypes() = delete; + + class Reader; + class Builder; + class Pipeline; + typedef ::capnp::schemas::NestedEnum_b651d2fba42056d4 NestedEnum; + + struct NestedStruct; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d9f2b5941a343bcd, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestNestedTypes::NestedStruct { + NestedStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + typedef ::capnp::schemas::NestedEnum_cfa0d546993a3df3 NestedEnum; + + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(82cd03a53b29d76b, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestUsing { + TestUsing() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e78aac389e77b065, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists { + TestLists() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Struct0; + struct Struct1; + struct Struct8; + struct Struct16; + struct Struct32; + struct Struct64; + struct StructP; + struct Struct0c; + struct Struct1c; + struct Struct8c; + struct Struct16c; + struct Struct32c; + struct Struct64c; + struct StructPc; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e41885c94393277e, 0, 10) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct0 { + Struct0() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8412c03b75b2cfee, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct1 { + Struct1() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e0fe5870b141ad69, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct8 { + Struct8() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a6411a353090145b, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct16 { + Struct16() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a8abf7a82928986c, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct32 { + Struct32() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ad7beedc4ed30742, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct64 { + Struct64() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ef9a34f2ff7cc646, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::StructP { + StructP() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c6abf1b0329e6227, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct0c { + Struct0c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(943a234ca336b16a, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct1c { + Struct1c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8991bc0e74a594cd, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct8c { + Struct8c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ed267416528c7a24, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct16c { + Struct16c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9978837b037d58e6, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct32c { + Struct32c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ed5fa940f54a7904, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::Struct64c { + Struct64c() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(bc743778f2597c7d, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLists::StructPc { + StructPc() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c2e364a40182013d, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestFieldZeroIsBit { + TestFieldZeroIsBit() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(92fc29a80f3ddd5c, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestListDefaults { + TestListDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a851ad32cbc2ffea, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLateUnion { + TestLateUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct TheUnion; + struct AnotherUnion; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a76e3c9bb7fd56d3, 3, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLateUnion::TheUnion { + TheUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + GRAULT, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(807280a2901aa079, 3, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestLateUnion::AnotherUnion { + AnotherUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + GRAULT, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c1973984dee98e3a, 3, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestOldVersion { + TestOldVersion() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(95b30dd14e01dda8, 1, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestNewVersion { + TestNewVersion() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8ed75a7469f04ce3, 2, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestOldUnionVersion { + TestOldUnionVersion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + A, + B, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(bd5fe16e5170c492, 2, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestNewUnionVersion { + TestNewUnionVersion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + A, + B, + }; + struct A; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c7e4c513a975492b, 3, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestNewUnionVersion::A { + A() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + A0, + A1, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(86232c1de4513e84, 3, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestStructUnion { + TestStructUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct SomeStruct; + struct Un; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(faf781ef89a00e39, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestStructUnion::SomeStruct { + SomeStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9daec9823f171085, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestStructUnion::Un { + Un() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + STRUCT, + OBJECT, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(992edc677bef5a3c, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPrintInlineStructs { + TestPrintInlineStructs() = delete; + + class Reader; + class Builder; + class Pipeline; + struct InlineStruct; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(dec497819d097c3c, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPrintInlineStructs::InlineStruct { + InlineStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8e4936003708dac2, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestWholeFloatDefault { + TestWholeFloatDefault() = delete; + + class Reader; + class Builder; + class Pipeline; + static KJ_CONSTEXPR(const) float CONSTANT CAPNP_NON_INT_CONSTEXPR_DECL_INIT(456.0f); + static KJ_CONSTEXPR(const) float BIG_CONSTANT CAPNP_NON_INT_CONSTEXPR_DECL_INIT(4e30f); + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(91afd4a864dbb030, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenerics { + TestGenerics() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + UV, + UG, + }; + struct Inner; + template + struct Inner2; + template + struct Interface; + struct UseAliases; + struct Ug; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9d5b8cd8de9922eb, 1, 3) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenerics::Inner { + Inner() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f6a841117e19ac73, 0, 2) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +template +struct TestGenerics::Inner2 { + Inner2() = delete; + + class Reader; + class Builder; + class Pipeline; + template + struct DeepNest; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a9ab42b118d6d435, 0, 4) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Baz>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +template +template +struct TestGenerics::Inner2::DeepNest { + DeepNest() = delete; + + class Reader; + class Builder; + class Pipeline; + template + struct DeepNestInterface; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b6a0829c762b06f3, 0, 4) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Baz, Qux>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +template +template +template +struct TestGenerics::Inner2::DeepNest::DeepNestInterface { + DeepNestInterface() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct CallParams; + struct CallResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(8839ed86c9794287) + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Baz, Qux, Quux>::brand(); } + }; + #endif // !CAPNP_LITE +}; + +template +template +template +template +struct TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams { + CallParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b84eecc799437049, 0, 0) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Baz, Qux, Quux>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +template +template +template +struct TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults { + CallResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e080f0fc54614f6f, 0, 0) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Baz, Qux, Quux>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +template +struct TestGenerics::Interface { + Interface() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct CallResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(c9e749e8dd54da5c) + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Qux>::brand(); } + }; + #endif // !CAPNP_LITE +}; + +template +template +struct TestGenerics::Interface::CallResults { + CallResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a5b46224e33581ad, 0, 2) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar, Qux>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenerics::UseAliases { + UseAliases() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8e656edfb45ba6cf, 0, 6) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenerics::Ug { + Ug() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b46a779beaf3384e, 1, 3) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenericsWrapper { + TestGenericsWrapper() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a9b2b1f52dde845d, 0, 1) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +struct TestGenericsWrapper2 { + TestGenericsWrapper2() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f28f83667a557a04, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestImplicitMethodParams { + TestImplicitMethodParams() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + template + struct CallParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(8b9717a3f8d85a9a) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +template +struct TestImplicitMethodParams::CallParams { + CallParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f83f8caf54bdc486, 0, 2) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, T, U>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestImplicitMethodParamsInGeneric { + TestImplicitMethodParamsInGeneric() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + template + struct CallParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(df9ccdeb81a704c9) + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, V>::brand(); } + }; + #endif // !CAPNP_LITE +}; + +template +template +struct TestImplicitMethodParamsInGeneric::CallParams { + CallParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9aab8e25c808d71e, 0, 2) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, V, T, U>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestGenericsUnion { + TestGenericsUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAR, + }; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a54870440e919063, 1, 1) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Foo, Bar>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +struct TestUseGenerics { + TestUseGenerics() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9427b2a71030338f, 0, 20) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestEmptyStruct { + TestEmptyStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c5598844441096dc, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestConstants { + TestConstants() = delete; + + class Reader; + class Builder; + class Pipeline; + static KJ_CONSTEXPR(const) ::capnp::Void VOID_CONST CAPNP_NON_INT_CONSTEXPR_DECL_INIT( ::capnp::VOID); + static constexpr bool BOOL_CONST = true; + static constexpr ::int8_t INT8_CONST = -123; + static constexpr ::int16_t INT16_CONST = -12345; + static constexpr ::int32_t INT32_CONST = -12345678; + static constexpr ::int64_t INT64_CONST = -123456789012345ll; + static constexpr ::uint8_t UINT8_CONST = 234u; + static constexpr ::uint16_t UINT16_CONST = 45678u; + static constexpr ::uint32_t UINT32_CONST = 3456789012u; + static constexpr ::uint64_t UINT64_CONST = 12345678901234567890llu; + static KJ_CONSTEXPR(const) float FLOAT32_CONST CAPNP_NON_INT_CONSTEXPR_DECL_INIT(1234.5f); + static KJ_CONSTEXPR(const) double FLOAT64_CONST CAPNP_NON_INT_CONSTEXPR_DECL_INIT(-1.23e47); + static const ::capnp::_::ConstText<3> TEXT_CONST; + static const ::capnp::_::ConstData<3> DATA_CONST; + static const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> STRUCT_CONST; + static constexpr ::capnproto_test::capnp::test::TestEnum ENUM_CONST = ::capnproto_test::capnp::test::TestEnum::CORGE; + static const ::capnp::_::ConstList< ::capnp::Void> VOID_LIST_CONST; + static const ::capnp::_::ConstList BOOL_LIST_CONST; + static const ::capnp::_::ConstList< ::int8_t> INT8_LIST_CONST; + static const ::capnp::_::ConstList< ::int16_t> INT16_LIST_CONST; + static const ::capnp::_::ConstList< ::int32_t> INT32_LIST_CONST; + static const ::capnp::_::ConstList< ::int64_t> INT64_LIST_CONST; + static const ::capnp::_::ConstList< ::uint8_t> UINT8_LIST_CONST; + static const ::capnp::_::ConstList< ::uint16_t> UINT16_LIST_CONST; + static const ::capnp::_::ConstList< ::uint32_t> UINT32_LIST_CONST; + static const ::capnp::_::ConstList< ::uint64_t> UINT64_LIST_CONST; + static const ::capnp::_::ConstList FLOAT32_LIST_CONST; + static const ::capnp::_::ConstList FLOAT64_LIST_CONST; + static const ::capnp::_::ConstList< ::capnp::Text> TEXT_LIST_CONST; + static const ::capnp::_::ConstList< ::capnp::Data> DATA_LIST_CONST; + static const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestAllTypes> STRUCT_LIST_CONST; + static const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestEnum> ENUM_LIST_CONST; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(abed745cd8c92095, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +static constexpr ::uint32_t GLOBAL_INT = 12345u; +extern const ::capnp::_::ConstText<6> GLOBAL_TEXT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> GLOBAL_STRUCT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestPrintInlineStructs> GLOBAL_PRINTABLE_STRUCT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> DERIVED_CONSTANT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>> GENERIC_CONSTANT; +extern const ::capnp::_::ConstData<831> EMBEDDED_DATA; +extern const ::capnp::_::ConstText<4235> EMBEDDED_TEXT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> EMBEDDED_STRUCT; +extern const ::capnp::_::ConstText<10> NON_ASCII_TEXT; +struct TestAnyPointerConstants { + TestAnyPointerConstants() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ddc280dbee9c99b3, 0, 4) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAnyPointerConstants> ANY_POINTER_CONSTANTS; +struct TestInterface { + TestInterface() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct FooParams; + struct FooResults; + struct BarParams; + struct BarResults; + struct BazParams; + struct BazResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(88eb12a0e0af92b2) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestInterface::FooParams { + FooParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b874edc0d559b391, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterface::FooResults { + FooResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b04fcaddab714ba4, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterface::BarParams { + BarParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d044893357b42568, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterface::BarResults { + BarResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9bf141df4247d52f, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterface::BazParams { + BazParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d9ac8abb2a91cfbc, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestInterface::BazResults { + BazResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9b99d14f2f375b2d, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestExtends { + TestExtends() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct QuxParams; + struct QuxResults; + struct CorgeResults; + struct GraultParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(e4e9bac98670b748) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestExtends::QuxParams { + QuxParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(83a4bc5471363f17, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestExtends::QuxResults { + QuxResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8e4b3d1a3e2753dd, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestExtends::CorgeResults { + CorgeResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(acf67532a7e7bad9, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestExtends::GraultParams { + GraultParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f3b834e851ea8af6, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestExtends2 { + TestExtends2() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(98d7e0ef61488783) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestPipeline { + TestPipeline() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct Box; + struct AnyBox; + struct GetCapParams; + struct GetCapResults; + struct TestPointersParams; + struct TestPointersResults; + struct GetAnyCapParams; + struct GetAnyCapResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(a5a404caa61d4cd0) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestPipeline::Box { + Box() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b0b29e51db0e26b1, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::AnyBox { + AnyBox() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9442ad5a1d2c8acb, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::GetCapParams { + GetCapParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c7e8df5096257034, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::GetCapResults { + GetCapResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b2442a9e0ba28fdf, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::TestPointersParams { + TestPointersParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a604ee63cf37819f, 0, 3) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::TestPointersResults { + TestPointersResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8eda54756c6070d6, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::GetAnyCapParams { + GetAnyCapParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f8e36b53ab093d4e, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestPipeline::GetAnyCapResults { + GetAnyCapResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(bf44b4c94c26ef79, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestCallOrder { + TestCallOrder() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct GetCallSequenceParams; + struct GetCallSequenceResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(a0e77035bdff0051) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestCallOrder::GetCallSequenceParams { + GetCallSequenceParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8f1e8cd56ceb74dc, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestCallOrder::GetCallSequenceResults { + GetCallSequenceResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(dedbb6bf3810eab7, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestTailCallee { + TestTailCallee() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct TailResult; + struct FooParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(ddd699207eb8e23b) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestTailCallee::TailResult { + TailResult() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a9ed2e5a9fd53d19, 1, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestTailCallee::FooParams { + FooParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c5e1efc325614957, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestTailCaller { + TestTailCaller() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct FooParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(870bf40110ce3035) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestTailCaller::FooParams { + FooParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b07a279515dc8ac5, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestHandle { + TestHandle() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(a38e5efe41e53a15) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestMoreStuff { + TestMoreStuff() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct CallFooParams; + struct CallFooResults; + struct CallFooWhenResolvedParams; + struct CallFooWhenResolvedResults; + struct NeverReturnParams; + struct NeverReturnResults; + struct HoldParams; + struct HoldResults; + struct CallHeldParams; + struct CallHeldResults; + struct GetHeldParams; + struct GetHeldResults; + struct EchoParams; + struct EchoResults; + struct ExpectCancelParams; + struct ExpectCancelResults; + struct MethodWithDefaultsParams; + struct MethodWithDefaultsResults; + struct GetHandleParams; + struct GetHandleResults; + struct GetNullParams; + struct GetNullResults; + struct GetEnormousStringParams; + struct GetEnormousStringResults; + struct MethodWithNullDefaultParams; + struct MethodWithNullDefaultResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(ddc70bf9784133cf) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestMoreStuff::CallFooParams { + CallFooParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(931ba418da60f6e4, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::CallFooResults { + CallFooResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9a28970beccecdd0, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::CallFooWhenResolvedParams { + CallFooWhenResolvedParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(fabc700c2ebe6378, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::CallFooWhenResolvedResults { + CallFooWhenResolvedResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a54ce1e9aa822f90, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::NeverReturnParams { + NeverReturnParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(94fe60465c95182b, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::NeverReturnResults { + NeverReturnResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(def4e5fa6999c5dc, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::HoldParams { + HoldParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(fe7c8fbb769d8e58, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::HoldResults { + HoldResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f839fb1374d003c9, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::CallHeldParams { + CallHeldParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f8c5e5ef1edf83be, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::CallHeldResults { + CallHeldResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e59935f160ac7578, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetHeldParams { + GetHeldParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(feffc025fce317e3, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetHeldResults { + GetHeldResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ef4e146185af67ce, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::EchoParams { + EchoParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c07526f7e2e533b9, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::EchoResults { + EchoResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a6224536593d5b92, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::ExpectCancelParams { + ExpectCancelParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a1cc32d87f3edeb1, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::ExpectCancelResults { + ExpectCancelResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8a3eba1758c0916e, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::MethodWithDefaultsParams { + MethodWithDefaultsParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(99160a25fa50fbf1, 1, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::MethodWithDefaultsResults { + MethodWithDefaultsResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9c7e066f845a6c56, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetHandleParams { + GetHandleParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ead024a301a092a1, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetHandleResults { + GetHandleResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c3490d75420a1fe8, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetNullParams { + GetNullParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d8493f0e175d61f2, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetNullResults { + GetNullResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e6955d8ef1023671, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetEnormousStringParams { + GetEnormousStringParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(805df436f55dd07a, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::GetEnormousStringResults { + GetEnormousStringResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(860e7512dc3925b0, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::MethodWithNullDefaultParams { + MethodWithNullDefaultParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(fb92899aeb0ee74f, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMoreStuff::MethodWithNullDefaultResults { + MethodWithNullDefaultResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8467348247305cf7, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane { + TestMembrane() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct Thing; + struct Result; + struct MakeThingParams; + struct MakeThingResults; + struct CallPassThroughParams; + struct CallInterceptParams; + struct LoopbackParams; + struct LoopbackResults; + struct WaitForeverParams; + struct WaitForeverResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(c07d8dcd80a69c0c) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestMembrane::Thing { + Thing() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct PassThroughParams; + struct InterceptParams; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(9352e4e41f173917) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestMembrane::Thing::PassThroughParams { + PassThroughParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ff9bdcd05085d786, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::Thing::InterceptParams { + InterceptParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ee94bed3615ee745, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::Result { + Result() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b0c6163faf291965, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::MakeThingParams { + MakeThingParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d8ac2acc3ece6556, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::MakeThingResults { + MakeThingResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e5d4904814ccbf29, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::CallPassThroughParams { + CallPassThroughParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(945d9f634a6a29da, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::CallInterceptParams { + CallInterceptParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8749aac3375c5c71, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::LoopbackParams { + LoopbackParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(869a1b7ab34b42c9, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::LoopbackResults { + LoopbackResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ecd19398fd88ab5c, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::WaitForeverParams { + WaitForeverParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8f6bb30cc62917ff, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestMembrane::WaitForeverResults { + WaitForeverResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c343a4907280be01, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestContainMembrane { + TestContainMembrane() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(949449ad7c11fa5c, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestTransferCap { + TestTransferCap() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Element; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(dd2b66a791a279f0, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestTransferCap::Element { + Element() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c7263e8f88844abc, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods { + TestKeywordMethods() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct DeleteParams; + struct DeleteResults; + struct ClassParams; + struct ClassResults; + struct VoidParams; + struct VoidResults; + struct ReturnParams; + struct ReturnResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(9ae342d394247cfc) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct TestKeywordMethods::DeleteParams { + DeleteParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ca3a89cdeb6bd6b7, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::DeleteResults { + DeleteResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(eeb5843598307592, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::ClassParams { + ClassParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9cf5a8313c5db036, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::ClassResults { + ClassResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c0253868ac12e7d8, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::VoidParams { + VoidParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a4a08763833c7757, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::VoidResults { + VoidResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(de82773089c0aeab, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::ReturnParams { + ReturnParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(99817360625e8ca3, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestKeywordMethods::ReturnResults { + ReturnResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(b70872e07eaa992f, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestAuthenticatedBootstrap { + TestAuthenticatedBootstrap() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct GetCallerIdParams; + struct GetCallerIdResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(ea72cc77253798cd) + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, VatId>::brand(); } + }; + #endif // !CAPNP_LITE +}; + +template +struct TestAuthenticatedBootstrap::GetCallerIdParams { + GetCallerIdParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8ec30e2451f1cffe, 0, 0) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, VatId>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +template +struct TestAuthenticatedBootstrap::GetCallerIdResults { + GetCallerIdResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c71cf776034a3e67, 0, 1) + #if !CAPNP_LITE + static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; + static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; + static const ::capnp::_::RawBrandedSchema specificBrand; + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, VatId>::brand(); } + #endif // !CAPNP_LITE + }; +}; + +struct TestSturdyRef { + TestSturdyRef() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ceba982cb629f6c2, 0, 2) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestSturdyRefHostId { + TestSturdyRefHostId() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(e02d3bbe1010e342, 0, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestSturdyRefObjectId { + TestSturdyRefObjectId() = delete; + + class Reader; + class Builder; + class Pipeline; + typedef ::capnp::schemas::Tag_ef428f2f67c4d439 Tag; + + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(aeb2ad168e2f5697, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestProvisionId { + TestProvisionId() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(9e5c574772b1d462, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestRecipientId { + TestRecipientId() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ea2fb7dca9cdbdea, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestThirdPartyCapId { + TestThirdPartyCapId() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(a805157b98b65469, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct TestJoinResult { + TestJoinResult() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(f4c58a8ebcd0f600, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedStruct { + RenamedStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + GOOD_FIELD_NAME, + BAR, + }; + typedef ::capnp::schemas::RenamedEnum_f610d1deb4c9e84a RenamedEnum; + + struct RenamedNestedStruct; + struct RenamedUnion; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(d1fd8e9caf2a5d58, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedStruct::RenamedNestedStruct { + RenamedNestedStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + typedef ::capnp::schemas::RenamedDeeplyNestedEnum_f6cb3f9c7a4322e0 RenamedDeeplyNestedEnum; + + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(be406b6341d52284, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedStruct::RenamedUnion { + RenamedUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + RENAMED_GROUP, + QUX, + }; + struct RenamedGroup; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(89d9d1626b34017c, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedStruct::RenamedUnion::RenamedGroup { + RenamedGroup() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c3594bce5b24b722, 1, 1) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedInterface { + RenamedInterface() = delete; + +#if !CAPNP_LITE + class Client; + class Server; +#endif // !CAPNP_LITE + + struct RenamedMethodParams; + struct RenamedMethodResults; + + #if !CAPNP_LITE + struct _capnpPrivate { + CAPNP_DECLARE_INTERFACE_HEADER(d112a69d31ed918b) + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + }; + #endif // !CAPNP_LITE +}; + +struct RenamedInterface::RenamedMethodParams { + RenamedMethodParams() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(c12efc3b075adfe9, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct RenamedInterface::RenamedMethodResults { + RenamedMethodResults() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(dcc3cdb4b28f6c86, 0, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +// ======================================================================================= + +class TestAllTypes::Reader { +public: + typedef TestAllTypes Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnp::Void getVoidField() const; + + inline bool getBoolField() const; + + inline ::int8_t getInt8Field() const; + + inline ::int16_t getInt16Field() const; + + inline ::int32_t getInt32Field() const; + + inline ::int64_t getInt64Field() const; + + inline ::uint8_t getUInt8Field() const; + + inline ::uint16_t getUInt16Field() const; + + inline ::uint32_t getUInt32Field() const; + + inline ::uint64_t getUInt64Field() const; + + inline float getFloat32Field() const; + + inline double getFloat64Field() const; + + inline bool hasTextField() const; + inline ::capnp::Text::Reader getTextField() const; + + inline bool hasDataField() const; + inline ::capnp::Data::Reader getDataField() const; + + inline bool hasStructField() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getStructField() const; + + inline ::capnproto_test::capnp::test::TestEnum getEnumField() const; + + inline ::capnp::Void getInterfaceField() const; + + inline bool hasVoidList() const; + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader getVoidList() const; + + inline bool hasBoolList() const; + inline ::capnp::List::Reader getBoolList() const; + + inline bool hasInt8List() const; + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8List() const; + + inline bool hasInt16List() const; + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16List() const; + + inline bool hasInt32List() const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32List() const; + + inline bool hasInt64List() const; + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64List() const; + + inline bool hasUInt8List() const; + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt8List() const; + + inline bool hasUInt16List() const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt16List() const; + + inline bool hasUInt32List() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt32List() const; + + inline bool hasUInt64List() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt64List() const; + + inline bool hasFloat32List() const; + inline ::capnp::List::Reader getFloat32List() const; + + inline bool hasFloat64List() const; + inline ::capnp::List::Reader getFloat64List() const; + + inline bool hasTextList() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getTextList() const; + + inline bool hasDataList() const; + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader getDataList() const; + + inline bool hasStructList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader getStructList() const; + + inline bool hasEnumList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader getEnumList() const; + + inline bool hasInterfaceList() const; + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader getInterfaceList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestAllTypes::Builder { +public: + typedef TestAllTypes Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnp::Void getVoidField(); + inline void setVoidField( ::capnp::Void value = ::capnp::VOID); + + inline bool getBoolField(); + inline void setBoolField(bool value); + + inline ::int8_t getInt8Field(); + inline void setInt8Field( ::int8_t value); + + inline ::int16_t getInt16Field(); + inline void setInt16Field( ::int16_t value); + + inline ::int32_t getInt32Field(); + inline void setInt32Field( ::int32_t value); + + inline ::int64_t getInt64Field(); + inline void setInt64Field( ::int64_t value); + + inline ::uint8_t getUInt8Field(); + inline void setUInt8Field( ::uint8_t value); + + inline ::uint16_t getUInt16Field(); + inline void setUInt16Field( ::uint16_t value); + + inline ::uint32_t getUInt32Field(); + inline void setUInt32Field( ::uint32_t value); + + inline ::uint64_t getUInt64Field(); + inline void setUInt64Field( ::uint64_t value); + + inline float getFloat32Field(); + inline void setFloat32Field(float value); + + inline double getFloat64Field(); + inline void setFloat64Field(double value); + + inline bool hasTextField(); + inline ::capnp::Text::Builder getTextField(); + inline void setTextField( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTextField(unsigned int size); + inline void adoptTextField(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTextField(); + + inline bool hasDataField(); + inline ::capnp::Data::Builder getDataField(); + inline void setDataField( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initDataField(unsigned int size); + inline void adoptDataField(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownDataField(); + + inline bool hasStructField(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getStructField(); + inline void setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initStructField(); + inline void adoptStructField(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownStructField(); + + inline ::capnproto_test::capnp::test::TestEnum getEnumField(); + inline void setEnumField( ::capnproto_test::capnp::test::TestEnum value); + + inline ::capnp::Void getInterfaceField(); + inline void setInterfaceField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasVoidList(); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder getVoidList(); + inline void setVoidList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setVoidList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder initVoidList(unsigned int size); + inline void adoptVoidList(::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> disownVoidList(); + + inline bool hasBoolList(); + inline ::capnp::List::Builder getBoolList(); + inline void setBoolList( ::capnp::List::Reader value); + inline void setBoolList(::kj::ArrayPtr value); + inline ::capnp::List::Builder initBoolList(unsigned int size); + inline void adoptBoolList(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownBoolList(); + + inline bool hasInt8List(); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8List(); + inline void setInt8List( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt8List(::kj::ArrayPtr value); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8List(unsigned int size); + inline void adoptInt8List(::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> disownInt8List(); + + inline bool hasInt16List(); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16List(); + inline void setInt16List( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt16List(::kj::ArrayPtr value); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16List(unsigned int size); + inline void adoptInt16List(::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> disownInt16List(); + + inline bool hasInt32List(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32List(); + inline void setInt32List( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt32List(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32List(unsigned int size); + inline void adoptInt32List(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownInt32List(); + + inline bool hasInt64List(); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64List(); + inline void setInt64List( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt64List(::kj::ArrayPtr value); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64List(unsigned int size); + inline void adoptInt64List(::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> disownInt64List(); + + inline bool hasUInt8List(); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt8List(); + inline void setUInt8List( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt8List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt8List(unsigned int size); + inline void adoptUInt8List(::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> disownUInt8List(); + + inline bool hasUInt16List(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt16List(); + inline void setUInt16List( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt16List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt16List(unsigned int size); + inline void adoptUInt16List(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownUInt16List(); + + inline bool hasUInt32List(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt32List(); + inline void setUInt32List( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt32List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt32List(unsigned int size); + inline void adoptUInt32List(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownUInt32List(); + + inline bool hasUInt64List(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt64List(); + inline void setUInt64List( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt64List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt64List(unsigned int size); + inline void adoptUInt64List(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUInt64List(); + + inline bool hasFloat32List(); + inline ::capnp::List::Builder getFloat32List(); + inline void setFloat32List( ::capnp::List::Reader value); + inline void setFloat32List(::kj::ArrayPtr value); + inline ::capnp::List::Builder initFloat32List(unsigned int size); + inline void adoptFloat32List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat32List(); + + inline bool hasFloat64List(); + inline ::capnp::List::Builder getFloat64List(); + inline void setFloat64List( ::capnp::List::Reader value); + inline void setFloat64List(::kj::ArrayPtr value); + inline ::capnp::List::Builder initFloat64List(unsigned int size); + inline void adoptFloat64List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat64List(); + + inline bool hasTextList(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getTextList(); + inline void setTextList( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setTextList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initTextList(unsigned int size); + inline void adoptTextList(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownTextList(); + + inline bool hasDataList(); + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder getDataList(); + inline void setDataList( ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader value); + inline void setDataList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder initDataList(unsigned int size); + inline void adoptDataList(::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>> disownDataList(); + + inline bool hasStructList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder getStructList(); + inline void setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder initStructList(unsigned int size); + inline void adoptStructList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>> disownStructList(); + + inline bool hasEnumList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder getEnumList(); + inline void setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader value); + inline void setEnumList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder initEnumList(unsigned int size); + inline void adoptEnumList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>> disownEnumList(); + + inline bool hasInterfaceList(); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder getInterfaceList(); + inline void setInterfaceList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInterfaceList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder initInterfaceList(unsigned int size); + inline void adoptInterfaceList(::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> disownInterfaceList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestAllTypes::Pipeline { +public: + typedef TestAllTypes Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getStructField(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestDefaults::Reader { +public: + typedef TestDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnp::Void getVoidField() const; + + inline bool getBoolField() const; + + inline ::int8_t getInt8Field() const; + + inline ::int16_t getInt16Field() const; + + inline ::int32_t getInt32Field() const; + + inline ::int64_t getInt64Field() const; + + inline ::uint8_t getUInt8Field() const; + + inline ::uint16_t getUInt16Field() const; + + inline ::uint32_t getUInt32Field() const; + + inline ::uint64_t getUInt64Field() const; + + inline float getFloat32Field() const; + + inline double getFloat64Field() const; + + inline bool hasTextField() const; + inline ::capnp::Text::Reader getTextField() const; + + inline bool hasDataField() const; + inline ::capnp::Data::Reader getDataField() const; + + inline bool hasStructField() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getStructField() const; + + inline ::capnproto_test::capnp::test::TestEnum getEnumField() const; + + inline ::capnp::Void getInterfaceField() const; + + inline bool hasVoidList() const; + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader getVoidList() const; + + inline bool hasBoolList() const; + inline ::capnp::List::Reader getBoolList() const; + + inline bool hasInt8List() const; + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8List() const; + + inline bool hasInt16List() const; + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16List() const; + + inline bool hasInt32List() const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32List() const; + + inline bool hasInt64List() const; + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64List() const; + + inline bool hasUInt8List() const; + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt8List() const; + + inline bool hasUInt16List() const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt16List() const; + + inline bool hasUInt32List() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt32List() const; + + inline bool hasUInt64List() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUInt64List() const; + + inline bool hasFloat32List() const; + inline ::capnp::List::Reader getFloat32List() const; + + inline bool hasFloat64List() const; + inline ::capnp::List::Reader getFloat64List() const; + + inline bool hasTextList() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getTextList() const; + + inline bool hasDataList() const; + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader getDataList() const; + + inline bool hasStructList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader getStructList() const; + + inline bool hasEnumList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader getEnumList() const; + + inline bool hasInterfaceList() const; + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader getInterfaceList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestDefaults::Builder { +public: + typedef TestDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnp::Void getVoidField(); + inline void setVoidField( ::capnp::Void value = ::capnp::VOID); + + inline bool getBoolField(); + inline void setBoolField(bool value); + + inline ::int8_t getInt8Field(); + inline void setInt8Field( ::int8_t value); + + inline ::int16_t getInt16Field(); + inline void setInt16Field( ::int16_t value); + + inline ::int32_t getInt32Field(); + inline void setInt32Field( ::int32_t value); + + inline ::int64_t getInt64Field(); + inline void setInt64Field( ::int64_t value); + + inline ::uint8_t getUInt8Field(); + inline void setUInt8Field( ::uint8_t value); + + inline ::uint16_t getUInt16Field(); + inline void setUInt16Field( ::uint16_t value); + + inline ::uint32_t getUInt32Field(); + inline void setUInt32Field( ::uint32_t value); + + inline ::uint64_t getUInt64Field(); + inline void setUInt64Field( ::uint64_t value); + + inline float getFloat32Field(); + inline void setFloat32Field(float value); + + inline double getFloat64Field(); + inline void setFloat64Field(double value); + + inline bool hasTextField(); + inline ::capnp::Text::Builder getTextField(); + inline void setTextField( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTextField(unsigned int size); + inline void adoptTextField(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTextField(); + + inline bool hasDataField(); + inline ::capnp::Data::Builder getDataField(); + inline void setDataField( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initDataField(unsigned int size); + inline void adoptDataField(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownDataField(); + + inline bool hasStructField(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getStructField(); + inline void setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initStructField(); + inline void adoptStructField(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownStructField(); + + inline ::capnproto_test::capnp::test::TestEnum getEnumField(); + inline void setEnumField( ::capnproto_test::capnp::test::TestEnum value); + + inline ::capnp::Void getInterfaceField(); + inline void setInterfaceField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasVoidList(); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder getVoidList(); + inline void setVoidList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setVoidList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder initVoidList(unsigned int size); + inline void adoptVoidList(::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> disownVoidList(); + + inline bool hasBoolList(); + inline ::capnp::List::Builder getBoolList(); + inline void setBoolList( ::capnp::List::Reader value); + inline void setBoolList(::kj::ArrayPtr value); + inline ::capnp::List::Builder initBoolList(unsigned int size); + inline void adoptBoolList(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownBoolList(); + + inline bool hasInt8List(); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8List(); + inline void setInt8List( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt8List(::kj::ArrayPtr value); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8List(unsigned int size); + inline void adoptInt8List(::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> disownInt8List(); + + inline bool hasInt16List(); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16List(); + inline void setInt16List( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt16List(::kj::ArrayPtr value); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16List(unsigned int size); + inline void adoptInt16List(::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> disownInt16List(); + + inline bool hasInt32List(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32List(); + inline void setInt32List( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt32List(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32List(unsigned int size); + inline void adoptInt32List(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownInt32List(); + + inline bool hasInt64List(); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64List(); + inline void setInt64List( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt64List(::kj::ArrayPtr value); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64List(unsigned int size); + inline void adoptInt64List(::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> disownInt64List(); + + inline bool hasUInt8List(); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt8List(); + inline void setUInt8List( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt8List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt8List(unsigned int size); + inline void adoptUInt8List(::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> disownUInt8List(); + + inline bool hasUInt16List(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt16List(); + inline void setUInt16List( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt16List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt16List(unsigned int size); + inline void adoptUInt16List(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownUInt16List(); + + inline bool hasUInt32List(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt32List(); + inline void setUInt32List( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt32List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt32List(unsigned int size); + inline void adoptUInt32List(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownUInt32List(); + + inline bool hasUInt64List(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUInt64List(); + inline void setUInt64List( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUInt64List(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUInt64List(unsigned int size); + inline void adoptUInt64List(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUInt64List(); + + inline bool hasFloat32List(); + inline ::capnp::List::Builder getFloat32List(); + inline void setFloat32List( ::capnp::List::Reader value); + inline void setFloat32List(::kj::ArrayPtr value); + inline ::capnp::List::Builder initFloat32List(unsigned int size); + inline void adoptFloat32List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat32List(); + + inline bool hasFloat64List(); + inline ::capnp::List::Builder getFloat64List(); + inline void setFloat64List( ::capnp::List::Reader value); + inline void setFloat64List(::kj::ArrayPtr value); + inline ::capnp::List::Builder initFloat64List(unsigned int size); + inline void adoptFloat64List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat64List(); + + inline bool hasTextList(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getTextList(); + inline void setTextList( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setTextList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initTextList(unsigned int size); + inline void adoptTextList(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownTextList(); + + inline bool hasDataList(); + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder getDataList(); + inline void setDataList( ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader value); + inline void setDataList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder initDataList(unsigned int size); + inline void adoptDataList(::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>> disownDataList(); + + inline bool hasStructList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder getStructList(); + inline void setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder initStructList(unsigned int size); + inline void adoptStructList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>> disownStructList(); + + inline bool hasEnumList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder getEnumList(); + inline void setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader value); + inline void setEnumList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder initEnumList(unsigned int size); + inline void adoptEnumList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>> disownEnumList(); + + inline bool hasInterfaceList(); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder getInterfaceList(); + inline void setInterfaceList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInterfaceList(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder initInterfaceList(unsigned int size); + inline void adoptInterfaceList(::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> disownInterfaceList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestDefaults::Pipeline { +public: + typedef TestDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getStructField(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestAnyPointer::Reader { +public: + typedef TestAnyPointer Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasAnyPointerField() const; + inline ::capnp::AnyPointer::Reader getAnyPointerField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestAnyPointer::Builder { +public: + typedef TestAnyPointer Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasAnyPointerField(); + inline ::capnp::AnyPointer::Builder getAnyPointerField(); + inline ::capnp::AnyPointer::Builder initAnyPointerField(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestAnyPointer::Pipeline { +public: + typedef TestAnyPointer Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestAnyOthers::Reader { +public: + typedef TestAnyOthers Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasAnyStructField() const; + inline ::capnp::AnyStruct::Reader getAnyStructField() const; + + inline bool hasAnyListField() const; + inline ::capnp::AnyList::Reader getAnyListField() const; + + inline bool hasCapabilityField() const; +#if !CAPNP_LITE + inline ::capnp::Capability::Client getCapabilityField() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestAnyOthers::Builder { +public: + typedef TestAnyOthers Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasAnyStructField(); + inline ::capnp::AnyStruct::Builder getAnyStructField(); + inline void setAnyStructField( ::capnp::AnyStruct::Reader value); + template + inline ::capnp::BuilderFor initAnyStructFieldAs(); + inline void adoptAnyStructField(::capnp::Orphan< ::capnp::AnyStruct>&& value); + inline ::capnp::Orphan< ::capnp::AnyStruct> disownAnyStructField(); + + inline bool hasAnyListField(); + inline ::capnp::AnyList::Builder getAnyListField(); + inline void setAnyListField( ::capnp::AnyList::Reader value); + template + inline ::capnp::BuilderFor initAnyListFieldAs(unsigned int size); + inline void adoptAnyListField(::capnp::Orphan< ::capnp::AnyList>&& value); + inline ::capnp::Orphan< ::capnp::AnyList> disownAnyListField(); + + inline bool hasCapabilityField(); +#if !CAPNP_LITE + inline ::capnp::Capability::Client getCapabilityField(); + inline void setCapabilityField( ::capnp::Capability::Client&& value); + inline void setCapabilityField( ::capnp::Capability::Client& value); + inline void adoptCapabilityField(::capnp::Orphan< ::capnp::Capability>&& value); + inline ::capnp::Orphan< ::capnp::Capability> disownCapabilityField(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestAnyOthers::Pipeline { +public: + typedef TestAnyOthers Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::AnyStruct::Pipeline getAnyStructField(); + inline ::capnp::Capability::Client getCapabilityField(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestOutOfOrder::Reader { +public: + typedef TestOutOfOrder Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline bool hasBar() const; + inline ::capnp::Text::Reader getBar() const; + + inline bool hasFoo() const; + inline ::capnp::Text::Reader getFoo() const; + + inline bool hasCorge() const; + inline ::capnp::Text::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool hasQuux() const; + inline ::capnp::Text::Reader getQuux() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + + inline bool hasBaz() const; + inline ::capnp::Text::Reader getBaz() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestOutOfOrder::Builder { +public: + typedef TestOutOfOrder Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline bool hasBar(); + inline ::capnp::Text::Builder getBar(); + inline void setBar( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBar(); + + inline bool hasFoo(); + inline ::capnp::Text::Builder getFoo(); + inline void setFoo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFoo(); + + inline bool hasCorge(); + inline ::capnp::Text::Builder getCorge(); + inline void setCorge( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool hasQuux(); + inline ::capnp::Text::Builder getQuux(); + inline void setQuux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQuux(unsigned int size); + inline void adoptQuux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQuux(); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + + inline bool hasBaz(); + inline ::capnp::Text::Builder getBaz(); + inline void setBaz( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBaz(unsigned int size); + inline void adoptBaz(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBaz(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestOutOfOrder::Pipeline { +public: + typedef TestOutOfOrder Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnion::Reader { +public: + typedef TestUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline typename Union0::Reader getUnion0() const; + + inline typename Union1::Reader getUnion1() const; + + inline typename Union2::Reader getUnion2() const; + + inline typename Union3::Reader getUnion3() const; + + inline bool getBit0() const; + + inline bool getBit2() const; + + inline bool getBit3() const; + + inline bool getBit4() const; + + inline bool getBit5() const; + + inline bool getBit6() const; + + inline bool getBit7() const; + + inline ::uint8_t getByte0() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnion::Builder { +public: + typedef TestUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline typename Union0::Builder getUnion0(); + inline typename Union0::Builder initUnion0(); + + inline typename Union1::Builder getUnion1(); + inline typename Union1::Builder initUnion1(); + + inline typename Union2::Builder getUnion2(); + inline typename Union2::Builder initUnion2(); + + inline typename Union3::Builder getUnion3(); + inline typename Union3::Builder initUnion3(); + + inline bool getBit0(); + inline void setBit0(bool value); + + inline bool getBit2(); + inline void setBit2(bool value); + + inline bool getBit3(); + inline void setBit3(bool value); + + inline bool getBit4(); + inline void setBit4(bool value); + + inline bool getBit5(); + inline void setBit5(bool value); + + inline bool getBit6(); + inline void setBit6(bool value); + + inline bool getBit7(); + inline void setBit7(bool value); + + inline ::uint8_t getByte0(); + inline void setByte0( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnion::Pipeline { +public: + typedef TestUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename Union0::Pipeline getUnion0(); + inline typename Union1::Pipeline getUnion1(); + inline typename Union2::Pipeline getUnion2(); + inline typename Union3::Pipeline getUnion3(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnion::Union0::Reader { +public: + typedef Union0 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isU0f0s0() const; + inline ::capnp::Void getU0f0s0() const; + + inline bool isU0f0s1() const; + inline bool getU0f0s1() const; + + inline bool isU0f0s8() const; + inline ::int8_t getU0f0s8() const; + + inline bool isU0f0s16() const; + inline ::int16_t getU0f0s16() const; + + inline bool isU0f0s32() const; + inline ::int32_t getU0f0s32() const; + + inline bool isU0f0s64() const; + inline ::int64_t getU0f0s64() const; + + inline bool isU0f0sp() const; + inline bool hasU0f0sp() const; + inline ::capnp::Text::Reader getU0f0sp() const; + + inline bool isU0f1s0() const; + inline ::capnp::Void getU0f1s0() const; + + inline bool isU0f1s1() const; + inline bool getU0f1s1() const; + + inline bool isU0f1s8() const; + inline ::int8_t getU0f1s8() const; + + inline bool isU0f1s16() const; + inline ::int16_t getU0f1s16() const; + + inline bool isU0f1s32() const; + inline ::int32_t getU0f1s32() const; + + inline bool isU0f1s64() const; + inline ::int64_t getU0f1s64() const; + + inline bool isU0f1sp() const; + inline bool hasU0f1sp() const; + inline ::capnp::Text::Reader getU0f1sp() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnion::Union0::Builder { +public: + typedef Union0 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isU0f0s0(); + inline ::capnp::Void getU0f0s0(); + inline void setU0f0s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU0f0s1(); + inline bool getU0f0s1(); + inline void setU0f0s1(bool value); + + inline bool isU0f0s8(); + inline ::int8_t getU0f0s8(); + inline void setU0f0s8( ::int8_t value); + + inline bool isU0f0s16(); + inline ::int16_t getU0f0s16(); + inline void setU0f0s16( ::int16_t value); + + inline bool isU0f0s32(); + inline ::int32_t getU0f0s32(); + inline void setU0f0s32( ::int32_t value); + + inline bool isU0f0s64(); + inline ::int64_t getU0f0s64(); + inline void setU0f0s64( ::int64_t value); + + inline bool isU0f0sp(); + inline bool hasU0f0sp(); + inline ::capnp::Text::Builder getU0f0sp(); + inline void setU0f0sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU0f0sp(unsigned int size); + inline void adoptU0f0sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU0f0sp(); + + inline bool isU0f1s0(); + inline ::capnp::Void getU0f1s0(); + inline void setU0f1s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU0f1s1(); + inline bool getU0f1s1(); + inline void setU0f1s1(bool value); + + inline bool isU0f1s8(); + inline ::int8_t getU0f1s8(); + inline void setU0f1s8( ::int8_t value); + + inline bool isU0f1s16(); + inline ::int16_t getU0f1s16(); + inline void setU0f1s16( ::int16_t value); + + inline bool isU0f1s32(); + inline ::int32_t getU0f1s32(); + inline void setU0f1s32( ::int32_t value); + + inline bool isU0f1s64(); + inline ::int64_t getU0f1s64(); + inline void setU0f1s64( ::int64_t value); + + inline bool isU0f1sp(); + inline bool hasU0f1sp(); + inline ::capnp::Text::Builder getU0f1sp(); + inline void setU0f1sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU0f1sp(unsigned int size); + inline void adoptU0f1sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU0f1sp(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnion::Union0::Pipeline { +public: + typedef Union0 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnion::Union1::Reader { +public: + typedef Union1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isU1f0s0() const; + inline ::capnp::Void getU1f0s0() const; + + inline bool isU1f0s1() const; + inline bool getU1f0s1() const; + + inline bool isU1f1s1() const; + inline bool getU1f1s1() const; + + inline bool isU1f0s8() const; + inline ::int8_t getU1f0s8() const; + + inline bool isU1f1s8() const; + inline ::int8_t getU1f1s8() const; + + inline bool isU1f0s16() const; + inline ::int16_t getU1f0s16() const; + + inline bool isU1f1s16() const; + inline ::int16_t getU1f1s16() const; + + inline bool isU1f0s32() const; + inline ::int32_t getU1f0s32() const; + + inline bool isU1f1s32() const; + inline ::int32_t getU1f1s32() const; + + inline bool isU1f0s64() const; + inline ::int64_t getU1f0s64() const; + + inline bool isU1f1s64() const; + inline ::int64_t getU1f1s64() const; + + inline bool isU1f0sp() const; + inline bool hasU1f0sp() const; + inline ::capnp::Text::Reader getU1f0sp() const; + + inline bool isU1f1sp() const; + inline bool hasU1f1sp() const; + inline ::capnp::Text::Reader getU1f1sp() const; + + inline bool isU1f2s0() const; + inline ::capnp::Void getU1f2s0() const; + + inline bool isU1f2s1() const; + inline bool getU1f2s1() const; + + inline bool isU1f2s8() const; + inline ::int8_t getU1f2s8() const; + + inline bool isU1f2s16() const; + inline ::int16_t getU1f2s16() const; + + inline bool isU1f2s32() const; + inline ::int32_t getU1f2s32() const; + + inline bool isU1f2s64() const; + inline ::int64_t getU1f2s64() const; + + inline bool isU1f2sp() const; + inline bool hasU1f2sp() const; + inline ::capnp::Text::Reader getU1f2sp() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnion::Union1::Builder { +public: + typedef Union1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isU1f0s0(); + inline ::capnp::Void getU1f0s0(); + inline void setU1f0s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU1f0s1(); + inline bool getU1f0s1(); + inline void setU1f0s1(bool value); + + inline bool isU1f1s1(); + inline bool getU1f1s1(); + inline void setU1f1s1(bool value); + + inline bool isU1f0s8(); + inline ::int8_t getU1f0s8(); + inline void setU1f0s8( ::int8_t value); + + inline bool isU1f1s8(); + inline ::int8_t getU1f1s8(); + inline void setU1f1s8( ::int8_t value); + + inline bool isU1f0s16(); + inline ::int16_t getU1f0s16(); + inline void setU1f0s16( ::int16_t value); + + inline bool isU1f1s16(); + inline ::int16_t getU1f1s16(); + inline void setU1f1s16( ::int16_t value); + + inline bool isU1f0s32(); + inline ::int32_t getU1f0s32(); + inline void setU1f0s32( ::int32_t value); + + inline bool isU1f1s32(); + inline ::int32_t getU1f1s32(); + inline void setU1f1s32( ::int32_t value); + + inline bool isU1f0s64(); + inline ::int64_t getU1f0s64(); + inline void setU1f0s64( ::int64_t value); + + inline bool isU1f1s64(); + inline ::int64_t getU1f1s64(); + inline void setU1f1s64( ::int64_t value); + + inline bool isU1f0sp(); + inline bool hasU1f0sp(); + inline ::capnp::Text::Builder getU1f0sp(); + inline void setU1f0sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f0sp(unsigned int size); + inline void adoptU1f0sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f0sp(); + + inline bool isU1f1sp(); + inline bool hasU1f1sp(); + inline ::capnp::Text::Builder getU1f1sp(); + inline void setU1f1sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f1sp(unsigned int size); + inline void adoptU1f1sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f1sp(); + + inline bool isU1f2s0(); + inline ::capnp::Void getU1f2s0(); + inline void setU1f2s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU1f2s1(); + inline bool getU1f2s1(); + inline void setU1f2s1(bool value); + + inline bool isU1f2s8(); + inline ::int8_t getU1f2s8(); + inline void setU1f2s8( ::int8_t value); + + inline bool isU1f2s16(); + inline ::int16_t getU1f2s16(); + inline void setU1f2s16( ::int16_t value); + + inline bool isU1f2s32(); + inline ::int32_t getU1f2s32(); + inline void setU1f2s32( ::int32_t value); + + inline bool isU1f2s64(); + inline ::int64_t getU1f2s64(); + inline void setU1f2s64( ::int64_t value); + + inline bool isU1f2sp(); + inline bool hasU1f2sp(); + inline ::capnp::Text::Builder getU1f2sp(); + inline void setU1f2sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f2sp(unsigned int size); + inline void adoptU1f2sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f2sp(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnion::Union1::Pipeline { +public: + typedef Union1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnion::Union2::Reader { +public: + typedef Union2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isU2f0s1() const; + inline bool getU2f0s1() const; + + inline bool isU2f0s8() const; + inline ::int8_t getU2f0s8() const; + + inline bool isU2f0s16() const; + inline ::int16_t getU2f0s16() const; + + inline bool isU2f0s32() const; + inline ::int32_t getU2f0s32() const; + + inline bool isU2f0s64() const; + inline ::int64_t getU2f0s64() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnion::Union2::Builder { +public: + typedef Union2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isU2f0s1(); + inline bool getU2f0s1(); + inline void setU2f0s1(bool value); + + inline bool isU2f0s8(); + inline ::int8_t getU2f0s8(); + inline void setU2f0s8( ::int8_t value); + + inline bool isU2f0s16(); + inline ::int16_t getU2f0s16(); + inline void setU2f0s16( ::int16_t value); + + inline bool isU2f0s32(); + inline ::int32_t getU2f0s32(); + inline void setU2f0s32( ::int32_t value); + + inline bool isU2f0s64(); + inline ::int64_t getU2f0s64(); + inline void setU2f0s64( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnion::Union2::Pipeline { +public: + typedef Union2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnion::Union3::Reader { +public: + typedef Union3 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isU3f0s1() const; + inline bool getU3f0s1() const; + + inline bool isU3f0s8() const; + inline ::int8_t getU3f0s8() const; + + inline bool isU3f0s16() const; + inline ::int16_t getU3f0s16() const; + + inline bool isU3f0s32() const; + inline ::int32_t getU3f0s32() const; + + inline bool isU3f0s64() const; + inline ::int64_t getU3f0s64() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnion::Union3::Builder { +public: + typedef Union3 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isU3f0s1(); + inline bool getU3f0s1(); + inline void setU3f0s1(bool value); + + inline bool isU3f0s8(); + inline ::int8_t getU3f0s8(); + inline void setU3f0s8( ::int8_t value); + + inline bool isU3f0s16(); + inline ::int16_t getU3f0s16(); + inline void setU3f0s16( ::int16_t value); + + inline bool isU3f0s32(); + inline ::int32_t getU3f0s32(); + inline void setU3f0s32( ::int32_t value); + + inline bool isU3f0s64(); + inline ::int64_t getU3f0s64(); + inline void setU3f0s64( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnion::Union3::Pipeline { +public: + typedef Union3 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnnamedUnion::Reader { +public: + typedef TestUnnamedUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool hasBefore() const; + inline ::capnp::Text::Reader getBefore() const; + + inline bool isFoo() const; + inline ::uint16_t getFoo() const; + + inline ::uint16_t getMiddle() const; + + inline bool isBar() const; + inline ::uint32_t getBar() const; + + inline bool hasAfter() const; + inline ::capnp::Text::Reader getAfter() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnnamedUnion::Builder { +public: + typedef TestUnnamedUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool hasBefore(); + inline ::capnp::Text::Builder getBefore(); + inline void setBefore( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBefore(unsigned int size); + inline void adoptBefore(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBefore(); + + inline bool isFoo(); + inline ::uint16_t getFoo(); + inline void setFoo( ::uint16_t value); + + inline ::uint16_t getMiddle(); + inline void setMiddle( ::uint16_t value); + + inline bool isBar(); + inline ::uint32_t getBar(); + inline void setBar( ::uint32_t value); + + inline bool hasAfter(); + inline ::capnp::Text::Builder getAfter(); + inline void setAfter( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAfter(unsigned int size); + inline void adoptAfter(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAfter(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnnamedUnion::Pipeline { +public: + typedef TestUnnamedUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnionInUnion::Reader { +public: + typedef TestUnionInUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline typename Outer::Reader getOuter() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnionInUnion::Builder { +public: + typedef TestUnionInUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline typename Outer::Builder getOuter(); + inline typename Outer::Builder initOuter(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnionInUnion::Pipeline { +public: + typedef TestUnionInUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename Outer::Pipeline getOuter(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnionInUnion::Outer::Reader { +public: + typedef Outer Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isInner() const; + inline typename Inner::Reader getInner() const; + + inline bool isBaz() const; + inline ::int32_t getBaz() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnionInUnion::Outer::Builder { +public: + typedef Outer Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isInner(); + inline typename Inner::Builder getInner(); + inline typename Inner::Builder initInner(); + + inline bool isBaz(); + inline ::int32_t getBaz(); + inline void setBaz( ::int32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnionInUnion::Outer::Pipeline { +public: + typedef Outer Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnionInUnion::Outer::Inner::Reader { +public: + typedef Inner Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isFoo() const; + inline ::int32_t getFoo() const; + + inline bool isBar() const; + inline ::int32_t getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnionInUnion::Outer::Inner::Builder { +public: + typedef Inner Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isFoo(); + inline ::int32_t getFoo(); + inline void setFoo( ::int32_t value); + + inline bool isBar(); + inline ::int32_t getBar(); + inline void setBar( ::int32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnionInUnion::Outer::Inner::Pipeline { +public: + typedef Inner Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGroups::Reader { +public: + typedef TestGroups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline typename Groups::Reader getGroups() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGroups::Builder { +public: + typedef TestGroups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline typename Groups::Builder getGroups(); + inline typename Groups::Builder initGroups(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGroups::Pipeline { +public: + typedef TestGroups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename Groups::Pipeline getGroups(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGroups::Groups::Reader { +public: + typedef Groups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isFoo() const; + inline typename Foo::Reader getFoo() const; + + inline bool isBaz() const; + inline typename Baz::Reader getBaz() const; + + inline bool isBar() const; + inline typename Bar::Reader getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGroups::Groups::Builder { +public: + typedef Groups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isFoo(); + inline typename Foo::Builder getFoo(); + inline typename Foo::Builder initFoo(); + + inline bool isBaz(); + inline typename Baz::Builder getBaz(); + inline typename Baz::Builder initBaz(); + + inline bool isBar(); + inline typename Bar::Builder getBar(); + inline typename Bar::Builder initBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGroups::Groups::Pipeline { +public: + typedef Groups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGroups::Groups::Foo::Reader { +public: + typedef Foo Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge() const; + + inline ::int64_t getGrault() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGroups::Groups::Foo::Builder { +public: + typedef Foo Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline ::int64_t getGrault(); + inline void setGrault( ::int64_t value); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGroups::Groups::Foo::Pipeline { +public: + typedef Foo Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGroups::Groups::Baz::Reader { +public: + typedef Baz Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGroups::Groups::Baz::Builder { +public: + typedef Baz Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGroups::Groups::Baz::Pipeline { +public: + typedef Baz Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGroups::Groups::Bar::Reader { +public: + typedef Bar Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline ::int64_t getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGroups::Groups::Bar::Builder { +public: + typedef Bar Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline ::int64_t getGarply(); + inline void setGarply( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGroups::Groups::Bar::Pipeline { +public: + typedef Bar Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterleavedGroups::Reader { +public: + typedef TestInterleavedGroups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline typename Group1::Reader getGroup1() const; + + inline typename Group2::Reader getGroup2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterleavedGroups::Builder { +public: + typedef TestInterleavedGroups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline typename Group1::Builder getGroup1(); + inline typename Group1::Builder initGroup1(); + + inline typename Group2::Builder getGroup2(); + inline typename Group2::Builder initGroup2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterleavedGroups::Pipeline { +public: + typedef TestInterleavedGroups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename Group1::Pipeline getGroup1(); + inline typename Group2::Pipeline getGroup2(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterleavedGroups::Group1::Reader { +public: + typedef Group1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline ::uint32_t getFoo() const; + + inline ::uint64_t getBar() const; + + inline bool isQux() const; + inline ::uint16_t getQux() const; + + inline bool isCorge() const; + inline typename Corge::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool isFred() const; + inline bool hasFred() const; + inline ::capnp::Text::Reader getFred() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterleavedGroups::Group1::Builder { +public: + typedef Group1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline ::uint32_t getFoo(); + inline void setFoo( ::uint32_t value); + + inline ::uint64_t getBar(); + inline void setBar( ::uint64_t value); + + inline bool isQux(); + inline ::uint16_t getQux(); + inline void setQux( ::uint16_t value); + + inline bool isCorge(); + inline typename Corge::Builder getCorge(); + inline typename Corge::Builder initCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool isFred(); + inline bool hasFred(); + inline ::capnp::Text::Builder getFred(); + inline void setFred( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFred(unsigned int size); + inline void adoptFred(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFred(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterleavedGroups::Group1::Pipeline { +public: + typedef Group1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterleavedGroups::Group1::Corge::Reader { +public: + typedef Corge Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getGrault() const; + + inline ::uint16_t getGarply() const; + + inline bool hasPlugh() const; + inline ::capnp::Text::Reader getPlugh() const; + + inline bool hasXyzzy() const; + inline ::capnp::Text::Reader getXyzzy() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterleavedGroups::Group1::Corge::Builder { +public: + typedef Corge Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getGrault(); + inline void setGrault( ::uint64_t value); + + inline ::uint16_t getGarply(); + inline void setGarply( ::uint16_t value); + + inline bool hasPlugh(); + inline ::capnp::Text::Builder getPlugh(); + inline void setPlugh( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPlugh(unsigned int size); + inline void adoptPlugh(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPlugh(); + + inline bool hasXyzzy(); + inline ::capnp::Text::Builder getXyzzy(); + inline void setXyzzy( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initXyzzy(unsigned int size); + inline void adoptXyzzy(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownXyzzy(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterleavedGroups::Group1::Corge::Pipeline { +public: + typedef Corge Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterleavedGroups::Group2::Reader { +public: + typedef Group2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline ::uint32_t getFoo() const; + + inline ::uint64_t getBar() const; + + inline bool isQux() const; + inline ::uint16_t getQux() const; + + inline bool isCorge() const; + inline typename Corge::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool isFred() const; + inline bool hasFred() const; + inline ::capnp::Text::Reader getFred() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterleavedGroups::Group2::Builder { +public: + typedef Group2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline ::uint32_t getFoo(); + inline void setFoo( ::uint32_t value); + + inline ::uint64_t getBar(); + inline void setBar( ::uint64_t value); + + inline bool isQux(); + inline ::uint16_t getQux(); + inline void setQux( ::uint16_t value); + + inline bool isCorge(); + inline typename Corge::Builder getCorge(); + inline typename Corge::Builder initCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool isFred(); + inline bool hasFred(); + inline ::capnp::Text::Builder getFred(); + inline void setFred( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFred(unsigned int size); + inline void adoptFred(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFred(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterleavedGroups::Group2::Pipeline { +public: + typedef Group2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterleavedGroups::Group2::Corge::Reader { +public: + typedef Corge Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getGrault() const; + + inline ::uint16_t getGarply() const; + + inline bool hasPlugh() const; + inline ::capnp::Text::Reader getPlugh() const; + + inline bool hasXyzzy() const; + inline ::capnp::Text::Reader getXyzzy() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterleavedGroups::Group2::Corge::Builder { +public: + typedef Corge Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getGrault(); + inline void setGrault( ::uint64_t value); + + inline ::uint16_t getGarply(); + inline void setGarply( ::uint16_t value); + + inline bool hasPlugh(); + inline ::capnp::Text::Builder getPlugh(); + inline void setPlugh( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPlugh(unsigned int size); + inline void adoptPlugh(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPlugh(); + + inline bool hasXyzzy(); + inline ::capnp::Text::Builder getXyzzy(); + inline void setXyzzy( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initXyzzy(unsigned int size); + inline void adoptXyzzy(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownXyzzy(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterleavedGroups::Group2::Corge::Pipeline { +public: + typedef Corge Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUnionDefaults::Reader { +public: + typedef TestUnionDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS16s8s64s8Set() const; + inline ::capnproto_test::capnp::test::TestUnion::Reader getS16s8s64s8Set() const; + + inline bool hasS0sps1s32Set() const; + inline ::capnproto_test::capnp::test::TestUnion::Reader getS0sps1s32Set() const; + + inline bool hasUnnamed1() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader getUnnamed1() const; + + inline bool hasUnnamed2() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader getUnnamed2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUnionDefaults::Builder { +public: + typedef TestUnionDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS16s8s64s8Set(); + inline ::capnproto_test::capnp::test::TestUnion::Builder getS16s8s64s8Set(); + inline void setS16s8s64s8Set( ::capnproto_test::capnp::test::TestUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnion::Builder initS16s8s64s8Set(); + inline void adoptS16s8s64s8Set(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> disownS16s8s64s8Set(); + + inline bool hasS0sps1s32Set(); + inline ::capnproto_test::capnp::test::TestUnion::Builder getS0sps1s32Set(); + inline void setS0sps1s32Set( ::capnproto_test::capnp::test::TestUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnion::Builder initS0sps1s32Set(); + inline void adoptS0sps1s32Set(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> disownS0sps1s32Set(); + + inline bool hasUnnamed1(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder getUnnamed1(); + inline void setUnnamed1( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder initUnnamed1(); + inline void adoptUnnamed1(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> disownUnnamed1(); + + inline bool hasUnnamed2(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder getUnnamed2(); + inline void setUnnamed2( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder initUnnamed2(); + inline void adoptUnnamed2(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> disownUnnamed2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUnionDefaults::Pipeline { +public: + typedef TestUnionDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestUnion::Pipeline getS16s8s64s8Set(); + inline ::capnproto_test::capnp::test::TestUnion::Pipeline getS0sps1s32Set(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline getUnnamed1(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline getUnnamed2(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestNestedTypes::Reader { +public: + typedef TestNestedTypes Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasNestedStruct() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader getNestedStruct() const; + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestNestedTypes::Builder { +public: + typedef TestNestedTypes Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasNestedStruct(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder getNestedStruct(); + inline void setNestedStruct( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader value); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder initNestedStruct(); + inline void adoptNestedStruct(::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct> disownNestedStruct(); + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestNestedTypes::Pipeline { +public: + typedef TestNestedTypes Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline getNestedStruct(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestNestedTypes::NestedStruct::Reader { +public: + typedef NestedStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestNestedTypes::NestedStruct::Builder { +public: + typedef NestedStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestNestedTypes::NestedStruct::Pipeline { +public: + typedef NestedStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUsing::Reader { +public: + typedef TestUsing Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUsing::Builder { +public: + typedef TestUsing Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUsing::Pipeline { +public: + typedef TestUsing Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Reader { +public: + typedef TestLists Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasList0() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Reader getList0() const; + + inline bool hasList1() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Reader getList1() const; + + inline bool hasList8() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Reader getList8() const; + + inline bool hasList16() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Reader getList16() const; + + inline bool hasList32() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Reader getList32() const; + + inline bool hasList64() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Reader getList64() const; + + inline bool hasListP() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Reader getListP() const; + + inline bool hasInt32ListList() const; + inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getInt32ListList() const; + + inline bool hasTextListList() const; + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader getTextListList() const; + + inline bool hasStructListList() const; + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader getStructListList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Builder { +public: + typedef TestLists Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasList0(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Builder getList0(); + inline void setList0( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Builder initList0(unsigned int size); + inline void adoptList0(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>> disownList0(); + + inline bool hasList1(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Builder getList1(); + inline void setList1( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Builder initList1(unsigned int size); + inline void adoptList1(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>> disownList1(); + + inline bool hasList8(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Builder getList8(); + inline void setList8( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Builder initList8(unsigned int size); + inline void adoptList8(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>> disownList8(); + + inline bool hasList16(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Builder getList16(); + inline void setList16( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Builder initList16(unsigned int size); + inline void adoptList16(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>> disownList16(); + + inline bool hasList32(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Builder getList32(); + inline void setList32( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Builder initList32(unsigned int size); + inline void adoptList32(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>> disownList32(); + + inline bool hasList64(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Builder getList64(); + inline void setList64( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Builder initList64(unsigned int size); + inline void adoptList64(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>> disownList64(); + + inline bool hasListP(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Builder getListP(); + inline void setListP( ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Builder initListP(unsigned int size); + inline void adoptListP(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>> disownListP(); + + inline bool hasInt32ListList(); + inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getInt32ListList(); + inline void setInt32ListList( ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setInt32ListList(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initInt32ListList(unsigned int size); + inline void adoptInt32ListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownInt32ListList(); + + inline bool hasTextListList(); + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder getTextListList(); + inline void setTextListList( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value); + inline void setTextListList(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder initTextListList(unsigned int size); + inline void adoptTextListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> disownTextListList(); + + inline bool hasStructListList(); + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder getStructListList(); + inline void setStructListList( ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value); + inline void setStructListList(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder initStructListList(unsigned int size); + inline void adoptStructListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> disownStructListList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Pipeline { +public: + typedef TestLists Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct0::Reader { +public: + typedef Struct0 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnp::Void getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct0::Builder { +public: + typedef Struct0 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnp::Void getF(); + inline void setF( ::capnp::Void value = ::capnp::VOID); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct0::Pipeline { +public: + typedef Struct0 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct1::Reader { +public: + typedef Struct1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct1::Builder { +public: + typedef Struct1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool getF(); + inline void setF(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct1::Pipeline { +public: + typedef Struct1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct8::Reader { +public: + typedef Struct8 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint8_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct8::Builder { +public: + typedef Struct8 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint8_t getF(); + inline void setF( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct8::Pipeline { +public: + typedef Struct8 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct16::Reader { +public: + typedef Struct16 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint16_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct16::Builder { +public: + typedef Struct16 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint16_t getF(); + inline void setF( ::uint16_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct16::Pipeline { +public: + typedef Struct16 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct32::Reader { +public: + typedef Struct32 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct32::Builder { +public: + typedef Struct32 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getF(); + inline void setF( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct32::Pipeline { +public: + typedef Struct32 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct64::Reader { +public: + typedef Struct64 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct64::Builder { +public: + typedef Struct64 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getF(); + inline void setF( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct64::Pipeline { +public: + typedef Struct64 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::StructP::Reader { +public: + typedef StructP Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasF() const; + inline ::capnp::Text::Reader getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::StructP::Builder { +public: + typedef StructP Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasF(); + inline ::capnp::Text::Builder getF(); + inline void setF( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initF(unsigned int size); + inline void adoptF(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownF(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::StructP::Pipeline { +public: + typedef StructP Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct0c::Reader { +public: + typedef Struct0c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnp::Void getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct0c::Builder { +public: + typedef Struct0c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnp::Void getF(); + inline void setF( ::capnp::Void value = ::capnp::VOID); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct0c::Pipeline { +public: + typedef Struct0c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct1c::Reader { +public: + typedef Struct1c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct1c::Builder { +public: + typedef Struct1c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool getF(); + inline void setF(bool value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct1c::Pipeline { +public: + typedef Struct1c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct8c::Reader { +public: + typedef Struct8c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint8_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct8c::Builder { +public: + typedef Struct8c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint8_t getF(); + inline void setF( ::uint8_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct8c::Pipeline { +public: + typedef Struct8c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct16c::Reader { +public: + typedef Struct16c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint16_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct16c::Builder { +public: + typedef Struct16c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint16_t getF(); + inline void setF( ::uint16_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct16c::Pipeline { +public: + typedef Struct16c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct32c::Reader { +public: + typedef Struct32c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct32c::Builder { +public: + typedef Struct32c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getF(); + inline void setF( ::uint32_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct32c::Pipeline { +public: + typedef Struct32c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::Struct64c::Reader { +public: + typedef Struct64c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint64_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::Struct64c::Builder { +public: + typedef Struct64c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getF(); + inline void setF( ::uint64_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::Struct64c::Pipeline { +public: + typedef Struct64c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLists::StructPc::Reader { +public: + typedef StructPc Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasF() const; + inline ::capnp::Text::Reader getF() const; + + inline ::uint64_t getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLists::StructPc::Builder { +public: + typedef StructPc Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasF(); + inline ::capnp::Text::Builder getF(); + inline void setF( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initF(unsigned int size); + inline void adoptF(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownF(); + + inline ::uint64_t getPad(); + inline void setPad( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLists::StructPc::Pipeline { +public: + typedef StructPc Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestFieldZeroIsBit::Reader { +public: + typedef TestFieldZeroIsBit Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool getBit() const; + + inline bool getSecondBit() const; + + inline ::uint8_t getThirdField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestFieldZeroIsBit::Builder { +public: + typedef TestFieldZeroIsBit Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool getBit(); + inline void setBit(bool value); + + inline bool getSecondBit(); + inline void setSecondBit(bool value); + + inline ::uint8_t getThirdField(); + inline void setThirdField( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestFieldZeroIsBit::Pipeline { +public: + typedef TestFieldZeroIsBit Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestListDefaults::Reader { +public: + typedef TestListDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasLists() const; + inline ::capnproto_test::capnp::test::TestLists::Reader getLists() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestListDefaults::Builder { +public: + typedef TestListDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasLists(); + inline ::capnproto_test::capnp::test::TestLists::Builder getLists(); + inline void setLists( ::capnproto_test::capnp::test::TestLists::Reader value); + inline ::capnproto_test::capnp::test::TestLists::Builder initLists(); + inline void adoptLists(::capnp::Orphan< ::capnproto_test::capnp::test::TestLists>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists> disownLists(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestListDefaults::Pipeline { +public: + typedef TestListDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestLists::Pipeline getLists(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLateUnion::Reader { +public: + typedef TestLateUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getFoo() const; + + inline bool hasBar() const; + inline ::capnp::Text::Reader getBar() const; + + inline ::int16_t getBaz() const; + + inline typename TheUnion::Reader getTheUnion() const; + + inline typename AnotherUnion::Reader getAnotherUnion() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLateUnion::Builder { +public: + typedef TestLateUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getFoo(); + inline void setFoo( ::int32_t value); + + inline bool hasBar(); + inline ::capnp::Text::Builder getBar(); + inline void setBar( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBar(); + + inline ::int16_t getBaz(); + inline void setBaz( ::int16_t value); + + inline typename TheUnion::Builder getTheUnion(); + inline typename TheUnion::Builder initTheUnion(); + + inline typename AnotherUnion::Builder getAnotherUnion(); + inline typename AnotherUnion::Builder initAnotherUnion(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLateUnion::Pipeline { +public: + typedef TestLateUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename TheUnion::Pipeline getTheUnion(); + inline typename AnotherUnion::Pipeline getAnotherUnion(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLateUnion::TheUnion::Reader { +public: + typedef TheUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isQux() const; + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getCorge() const; + + inline bool isGrault() const; + inline float getGrault() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLateUnion::TheUnion::Builder { +public: + typedef TheUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isQux(); + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool isCorge(); + inline bool hasCorge(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getCorge(); + inline void setCorge( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCorge(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownCorge(); + + inline bool isGrault(); + inline float getGrault(); + inline void setGrault(float value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLateUnion::TheUnion::Pipeline { +public: + typedef TheUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestLateUnion::AnotherUnion::Reader { +public: + typedef AnotherUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isQux() const; + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getCorge() const; + + inline bool isGrault() const; + inline float getGrault() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestLateUnion::AnotherUnion::Builder { +public: + typedef AnotherUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isQux(); + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool isCorge(); + inline bool hasCorge(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getCorge(); + inline void setCorge( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCorge(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownCorge(); + + inline bool isGrault(); + inline float getGrault(); + inline void setGrault(float value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestLateUnion::AnotherUnion::Pipeline { +public: + typedef AnotherUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestOldVersion::Reader { +public: + typedef TestOldVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int64_t getOld1() const; + + inline bool hasOld2() const; + inline ::capnp::Text::Reader getOld2() const; + + inline bool hasOld3() const; + inline ::capnproto_test::capnp::test::TestOldVersion::Reader getOld3() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestOldVersion::Builder { +public: + typedef TestOldVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int64_t getOld1(); + inline void setOld1( ::int64_t value); + + inline bool hasOld2(); + inline ::capnp::Text::Builder getOld2(); + inline void setOld2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOld2(unsigned int size); + inline void adoptOld2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOld2(); + + inline bool hasOld3(); + inline ::capnproto_test::capnp::test::TestOldVersion::Builder getOld3(); + inline void setOld3( ::capnproto_test::capnp::test::TestOldVersion::Reader value); + inline ::capnproto_test::capnp::test::TestOldVersion::Builder initOld3(); + inline void adoptOld3(::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion> disownOld3(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestOldVersion::Pipeline { +public: + typedef TestOldVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestOldVersion::Pipeline getOld3(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestNewVersion::Reader { +public: + typedef TestNewVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int64_t getOld1() const; + + inline bool hasOld2() const; + inline ::capnp::Text::Reader getOld2() const; + + inline bool hasOld3() const; + inline ::capnproto_test::capnp::test::TestNewVersion::Reader getOld3() const; + + inline ::int64_t getNew1() const; + + inline bool hasNew2() const; + inline ::capnp::Text::Reader getNew2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestNewVersion::Builder { +public: + typedef TestNewVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int64_t getOld1(); + inline void setOld1( ::int64_t value); + + inline bool hasOld2(); + inline ::capnp::Text::Builder getOld2(); + inline void setOld2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOld2(unsigned int size); + inline void adoptOld2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOld2(); + + inline bool hasOld3(); + inline ::capnproto_test::capnp::test::TestNewVersion::Builder getOld3(); + inline void setOld3( ::capnproto_test::capnp::test::TestNewVersion::Reader value); + inline ::capnproto_test::capnp::test::TestNewVersion::Builder initOld3(); + inline void adoptOld3(::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion> disownOld3(); + + inline ::int64_t getNew1(); + inline void setNew1( ::int64_t value); + + inline bool hasNew2(); + inline ::capnp::Text::Builder getNew2(); + inline void setNew2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initNew2(unsigned int size); + inline void adoptNew2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownNew2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestNewVersion::Pipeline { +public: + typedef TestNewVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestNewVersion::Pipeline getOld3(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestOldUnionVersion::Reader { +public: + typedef TestOldUnionVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isA() const; + inline ::capnp::Void getA() const; + + inline bool isB() const; + inline ::uint64_t getB() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestOldUnionVersion::Builder { +public: + typedef TestOldUnionVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isA(); + inline ::capnp::Void getA(); + inline void setA( ::capnp::Void value = ::capnp::VOID); + + inline bool isB(); + inline ::uint64_t getB(); + inline void setB( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestOldUnionVersion::Pipeline { +public: + typedef TestOldUnionVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestNewUnionVersion::Reader { +public: + typedef TestNewUnionVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isA() const; + inline typename A::Reader getA() const; + + inline bool isB() const; + inline ::uint64_t getB() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestNewUnionVersion::Builder { +public: + typedef TestNewUnionVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isA(); + inline typename A::Builder getA(); + inline typename A::Builder initA(); + + inline bool isB(); + inline ::uint64_t getB(); + inline void setB( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestNewUnionVersion::Pipeline { +public: + typedef TestNewUnionVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestNewUnionVersion::A::Reader { +public: + typedef A Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isA0() const; + inline ::capnp::Void getA0() const; + + inline bool isA1() const; + inline ::uint64_t getA1() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestNewUnionVersion::A::Builder { +public: + typedef A Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isA0(); + inline ::capnp::Void getA0(); + inline void setA0( ::capnp::Void value = ::capnp::VOID); + + inline bool isA1(); + inline ::uint64_t getA1(); + inline void setA1( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestNewUnionVersion::A::Pipeline { +public: + typedef A Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestStructUnion::Reader { +public: + typedef TestStructUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline typename Un::Reader getUn() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestStructUnion::Builder { +public: + typedef TestStructUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline typename Un::Builder getUn(); + inline typename Un::Builder initUn(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestStructUnion::Pipeline { +public: + typedef TestStructUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename Un::Pipeline getUn(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestStructUnion::SomeStruct::Reader { +public: + typedef SomeStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasSomeText() const; + inline ::capnp::Text::Reader getSomeText() const; + + inline bool hasMoreText() const; + inline ::capnp::Text::Reader getMoreText() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestStructUnion::SomeStruct::Builder { +public: + typedef SomeStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasSomeText(); + inline ::capnp::Text::Builder getSomeText(); + inline void setSomeText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initSomeText(unsigned int size); + inline void adoptSomeText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownSomeText(); + + inline bool hasMoreText(); + inline ::capnp::Text::Builder getMoreText(); + inline void setMoreText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initMoreText(unsigned int size); + inline void adoptMoreText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownMoreText(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestStructUnion::SomeStruct::Pipeline { +public: + typedef SomeStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestStructUnion::Un::Reader { +public: + typedef Un Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isStruct() const; + inline bool hasStruct() const; + inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Reader getStruct() const; + + inline bool isObject() const; + inline bool hasObject() const; + inline ::capnproto_test::capnp::test::TestAnyPointer::Reader getObject() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestStructUnion::Un::Builder { +public: + typedef Un Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isStruct(); + inline bool hasStruct(); + inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Builder getStruct(); + inline void setStruct( ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Reader value); + inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Builder initStruct(); + inline void adoptStruct(::capnp::Orphan< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct> disownStruct(); + + inline bool isObject(); + inline bool hasObject(); + inline ::capnproto_test::capnp::test::TestAnyPointer::Builder getObject(); + inline void setObject( ::capnproto_test::capnp::test::TestAnyPointer::Reader value); + inline ::capnproto_test::capnp::test::TestAnyPointer::Builder initObject(); + inline void adoptObject(::capnp::Orphan< ::capnproto_test::capnp::test::TestAnyPointer>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAnyPointer> disownObject(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestStructUnion::Un::Pipeline { +public: + typedef Un Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPrintInlineStructs::Reader { +public: + typedef TestPrintInlineStructs Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasSomeText() const; + inline ::capnp::Text::Reader getSomeText() const; + + inline bool hasStructList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Reader getStructList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPrintInlineStructs::Builder { +public: + typedef TestPrintInlineStructs Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasSomeText(); + inline ::capnp::Text::Builder getSomeText(); + inline void setSomeText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initSomeText(unsigned int size); + inline void adoptSomeText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownSomeText(); + + inline bool hasStructList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Builder getStructList(); + inline void setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Builder initStructList(unsigned int size); + inline void adoptStructList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>> disownStructList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPrintInlineStructs::Pipeline { +public: + typedef TestPrintInlineStructs Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPrintInlineStructs::InlineStruct::Reader { +public: + typedef InlineStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getInt32Field() const; + + inline bool hasTextField() const; + inline ::capnp::Text::Reader getTextField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPrintInlineStructs::InlineStruct::Builder { +public: + typedef InlineStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getInt32Field(); + inline void setInt32Field( ::int32_t value); + + inline bool hasTextField(); + inline ::capnp::Text::Builder getTextField(); + inline void setTextField( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTextField(unsigned int size); + inline void adoptTextField(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTextField(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPrintInlineStructs::InlineStruct::Pipeline { +public: + typedef InlineStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestWholeFloatDefault::Reader { +public: + typedef TestWholeFloatDefault Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline float getField() const; + + inline float getBigField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestWholeFloatDefault::Builder { +public: + typedef TestWholeFloatDefault Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline float getField(); + inline void setField(float value); + + inline float getBigField(); + inline void setBigField(float value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestWholeFloatDefault::Pipeline { +public: + typedef TestWholeFloatDefault Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenerics::Reader { +public: + typedef TestGenerics Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Reader asGeneric() { + return typename TestGenerics::Reader(_reader); + } + + inline Which which() const; + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasRev() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::Reader getRev() const; + + inline bool isUv() const; + inline ::capnp::Void getUv() const; + + inline bool isUg() const; + inline typename Ug::Reader getUg() const; + + inline bool hasList() const; + inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Reader getList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenerics::Builder { +public: + typedef TestGenerics Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Builder asGeneric() { + return typename TestGenerics::Builder(_builder); + } + + inline Which which(); + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasRev(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Builder getRev(); + inline void setRev(typename ::capnproto_test::capnp::test::TestGenerics::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::Builder initRev(); + inline void adoptRev(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics> disownRev(); + + inline bool isUv(); + inline ::capnp::Void getUv(); + inline void setUv( ::capnp::Void value = ::capnp::VOID); + + inline bool isUg(); + inline typename Ug::Builder getUg(); + inline typename Ug::Builder initUg(); + + inline bool hasList(); + inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Builder getList(); + inline void setList(typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Reader value); + inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Builder initList(unsigned int size); + inline void adoptList(::capnp::Orphan< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List::Inner, ::capnp::Kind::STRUCT>> disownList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenerics::Pipeline { +public: + typedef TestGenerics Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Pipeline getRev(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenerics::Inner::Reader { +public: + typedef Inner Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Inner::Reader asTestGenericsGeneric() { + return typename TestGenerics::Inner::Reader(_reader); + } + + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenerics::Inner::Builder { +public: + typedef Inner Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Inner::Builder asTestGenericsGeneric() { + return typename TestGenerics::Inner::Builder(_builder); + } + + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenerics::Inner::Pipeline { +public: + typedef Inner Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline ::capnp::PipelineFor getBar(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +template +class TestGenerics::Inner2::Reader { +public: + typedef Inner2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename Inner2::Reader asGeneric() { + return typename Inner2::Reader(_reader); + } + + template + typename TestGenerics::template Inner2::Reader asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Reader(_reader); + } + + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + + inline bool hasBaz() const; + inline ::capnp::ReaderFor getBaz() const; + + inline bool hasInnerBound() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader getInnerBound() const; + + inline bool hasInnerUnbound() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Reader getInnerUnbound() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +class TestGenerics::Inner2::Builder { +public: + typedef Inner2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename Inner2::Builder asGeneric() { + return typename Inner2::Builder(_builder); + } + + template + typename TestGenerics::template Inner2::Builder asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Builder(_builder); + } + + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + + inline bool hasBaz(); + inline ::capnp::BuilderFor getBaz(); + inline void setBaz( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBaz(); + inline ::capnp::BuilderFor initBaz(unsigned int size); + inline void adoptBaz(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBaz(); + + inline bool hasInnerBound(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder getInnerBound(); + inline void setInnerBound(typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder initInnerBound(); + inline void adoptInnerBound(::capnp::Orphan::Inner>&& value); + inline ::capnp::Orphan::Inner> disownInnerBound(); + + inline bool hasInnerUnbound(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Builder getInnerUnbound(); + inline void setInnerUnbound( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Builder initInnerUnbound(); + inline void adoptInnerUnbound(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner> disownInnerUnbound(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +class TestGenerics::Inner2::Pipeline { +public: + typedef Inner2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getBar(); + inline ::capnp::PipelineFor getBaz(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline getInnerBound(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Pipeline getInnerUnbound(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +template +template +class TestGenerics::Inner2::DeepNest::Reader { +public: + typedef DeepNest Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename DeepNest::Reader asGeneric() { + return typename DeepNest::Reader(_reader); + } + + template + typename Inner2::template DeepNest::Reader asInner2Generic() { + return typename Inner2::template DeepNest::Reader(_reader); + } + + template + typename TestGenerics::template Inner2::Reader asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Reader(_reader); + } + + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + + inline bool hasBaz() const; + inline ::capnp::ReaderFor getBaz() const; + + inline bool hasQux() const; + inline ::capnp::ReaderFor getQux() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +template +class TestGenerics::Inner2::DeepNest::Builder { +public: + typedef DeepNest Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename DeepNest::Builder asGeneric() { + return typename DeepNest::Builder(_builder); + } + + template + typename Inner2::template DeepNest::Builder asInner2Generic() { + return typename Inner2::template DeepNest::Builder(_builder); + } + + template + typename TestGenerics::template Inner2::Builder asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Builder(_builder); + } + + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + + inline bool hasBaz(); + inline ::capnp::BuilderFor getBaz(); + inline void setBaz( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBaz(); + inline ::capnp::BuilderFor initBaz(unsigned int size); + inline void adoptBaz(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBaz(); + + inline bool hasQux(); + inline ::capnp::BuilderFor getQux(); + inline void setQux( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initQux(); + inline ::capnp::BuilderFor initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan&& value); + inline ::capnp::Orphan disownQux(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +template +class TestGenerics::Inner2::DeepNest::Pipeline { +public: + typedef DeepNest Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline ::capnp::PipelineFor getBar(); + inline ::capnp::PipelineFor getBaz(); + inline ::capnp::PipelineFor getQux(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::Client + : public virtual ::capnp::Capability::Client { +public: + typedef DeepNestInterface Calls; + typedef DeepNestInterface Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + template + typename DeepNestInterface::Client asGeneric() { + return castAs>(); + } + + template + typename DeepNest::template DeepNestInterface::Client asDeepNestGeneric() { + return castAs::template DeepNestInterface>(); + } + + template + typename Inner2::template DeepNest::Client asInner2Generic() { + return castAs::template DeepNest>(); + } + + template + typename TestGenerics::template Inner2::Client asTestGenericsGeneric() { + return castAs::template Inner2>(); + } + + CAPNP_AUTO_IF_MSVC(::capnp::Request::template Inner2::template DeepNest::template DeepNestInterface::CallParams, typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults>) callRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::Server + : public virtual ::capnp::Capability::Server { +public: + typedef DeepNestInterface Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallParams CallParams; + typedef typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults CallResults; + typedef ::capnp::CallContext CallContext; + virtual ::kj::Promise call(CallContext context); + + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs::template Inner2::template DeepNest::template DeepNestInterface>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::Reader { +public: + typedef CallParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename DeepNestInterface::CallParams::Reader asDeepNestInterfaceGeneric() { + return typename DeepNestInterface::CallParams::Reader(_reader); + } + + template + typename DeepNest::template DeepNestInterface::Reader asDeepNestGeneric() { + return typename DeepNest::template DeepNestInterface::Reader(_reader); + } + + template + typename Inner2::template DeepNest::Reader asInner2Generic() { + return typename Inner2::template DeepNest::Reader(_reader); + } + + template + typename TestGenerics::template Inner2::Reader asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Reader(_reader); + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::Builder { +public: + typedef CallParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename DeepNestInterface::CallParams::Builder asDeepNestInterfaceGeneric() { + return typename DeepNestInterface::CallParams::Builder(_builder); + } + + template + typename DeepNest::template DeepNestInterface::Builder asDeepNestGeneric() { + return typename DeepNest::template DeepNestInterface::Builder(_builder); + } + + template + typename Inner2::template DeepNest::Builder asInner2Generic() { + return typename Inner2::template DeepNest::Builder(_builder); + } + + template + typename TestGenerics::template Inner2::Builder asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Builder(_builder); + } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::Pipeline { +public: + typedef CallParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::Reader { +public: + typedef CallResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename DeepNestInterface::CallResults::Reader asDeepNestInterfaceGeneric() { + return typename DeepNestInterface::CallResults::Reader(_reader); + } + + template + typename DeepNest::template DeepNestInterface::Reader asDeepNestGeneric() { + return typename DeepNest::template DeepNestInterface::Reader(_reader); + } + + template + typename Inner2::template DeepNest::Reader asInner2Generic() { + return typename Inner2::template DeepNest::Reader(_reader); + } + + template + typename TestGenerics::template Inner2::Reader asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Reader(_reader); + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::Builder { +public: + typedef CallResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename DeepNestInterface::CallResults::Builder asDeepNestInterfaceGeneric() { + return typename DeepNestInterface::CallResults::Builder(_builder); + } + + template + typename DeepNest::template DeepNestInterface::Builder asDeepNestGeneric() { + return typename DeepNest::template DeepNestInterface::Builder(_builder); + } + + template + typename Inner2::template DeepNest::Builder asInner2Generic() { + return typename Inner2::template DeepNest::Builder(_builder); + } + + template + typename TestGenerics::template Inner2::Builder asTestGenericsGeneric() { + return typename TestGenerics::template Inner2::Builder(_builder); + } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +template +template +class TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::Pipeline { +public: + typedef CallResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +template +class TestGenerics::Interface::Client + : public virtual ::capnp::Capability::Client { +public: + typedef Interface Calls; + typedef Interface Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + template + typename Interface::Client asGeneric() { + return castAs>(); + } + + template + typename TestGenerics::template Interface::Client asTestGenericsGeneric() { + return castAs::template Interface>(); + } + + CAPNP_AUTO_IF_MSVC(::capnp::Request::template Inner2< ::capnp::Text>, typename ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults>) callRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +template +template +class TestGenerics::Interface::Server + : public virtual ::capnp::Capability::Server { +public: + typedef Interface Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef typename ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults CallResults; + typedef ::capnp::CallContext::template Inner2< ::capnp::Text>, CallResults> CallContext; + virtual ::kj::Promise call(CallContext context); + + inline typename ::capnproto_test::capnp::test::TestGenerics::template Interface::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs::template Interface>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +template +template +class TestGenerics::Interface::CallResults::Reader { +public: + typedef CallResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename Interface::CallResults::Reader asInterfaceGeneric() { + return typename Interface::CallResults::Reader(_reader); + } + + template + typename TestGenerics::template Interface::Reader asTestGenericsGeneric() { + return typename TestGenerics::template Interface::Reader(_reader); + } + + inline bool hasQux() const; + inline ::capnp::ReaderFor getQux() const; + + inline bool hasGen() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader getGen() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +class TestGenerics::Interface::CallResults::Builder { +public: + typedef CallResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename Interface::CallResults::Builder asInterfaceGeneric() { + return typename Interface::CallResults::Builder(_builder); + } + + template + typename TestGenerics::template Interface::Builder asTestGenericsGeneric() { + return typename TestGenerics::template Interface::Builder(_builder); + } + + inline bool hasQux(); + inline ::capnp::BuilderFor getQux(); + inline void setQux( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initQux(); + inline ::capnp::BuilderFor initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan&& value); + inline ::capnp::Orphan disownQux(); + + inline bool hasGen(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder getGen(); + inline void setGen( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder initGen(); + inline void adoptGen(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> disownGen(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +class TestGenerics::Interface::CallResults::Pipeline { +public: + typedef CallResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getQux(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline getGen(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenerics::UseAliases::Reader { +public: + typedef UseAliases Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenerics::UseAliases::Reader asTestGenericsGeneric() { + return typename TestGenerics::UseAliases::Reader(_reader); + } + + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasInner() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader getInner() const; + + inline bool hasInner2() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Reader getInner2() const; + + inline bool hasInner2Bind() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader getInner2Bind() const; + + inline bool hasInner2Text() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader getInner2Text() const; + + inline bool hasRevFoo() const; + inline ::capnp::ReaderFor getRevFoo() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenerics::UseAliases::Builder { +public: + typedef UseAliases Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenerics::UseAliases::Builder asTestGenericsGeneric() { + return typename TestGenerics::UseAliases::Builder(_builder); + } + + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasInner(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder getInner(); + inline void setInner(typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder initInner(); + inline void adoptInner(::capnp::Orphan::Inner>&& value); + inline ::capnp::Orphan::Inner> disownInner(); + + inline bool hasInner2(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Builder getInner2(); + inline void setInner2(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Builder initInner2(); + inline void adoptInner2(::capnp::Orphan::template Inner2< ::capnp::AnyPointer>>&& value); + inline ::capnp::Orphan::template Inner2< ::capnp::AnyPointer>> disownInner2(); + + inline bool hasInner2Bind(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder getInner2Bind(); + inline void setInner2Bind(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder initInner2Bind(); + inline void adoptInner2Bind(::capnp::Orphan::template Inner2< ::capnp::Text>>&& value); + inline ::capnp::Orphan::template Inner2< ::capnp::Text>> disownInner2Bind(); + + inline bool hasInner2Text(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder getInner2Text(); + inline void setInner2Text(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder initInner2Text(); + inline void adoptInner2Text(::capnp::Orphan::template Inner2< ::capnp::Text>>&& value); + inline ::capnp::Orphan::template Inner2< ::capnp::Text>> disownInner2Text(); + + inline bool hasRevFoo(); + inline ::capnp::BuilderFor getRevFoo(); + inline void setRevFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initRevFoo(); + inline ::capnp::BuilderFor initRevFoo(unsigned int size); + inline void adoptRevFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownRevFoo(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenerics::UseAliases::Pipeline { +public: + typedef UseAliases Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline getInner(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Pipeline getInner2(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline getInner2Bind(); + inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline getInner2Text(); + inline ::capnp::PipelineFor getRevFoo(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenerics::Ug::Reader { +public: + typedef Ug Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Ug::Reader asTestGenericsGeneric() { + return typename TestGenerics::Ug::Reader(_reader); + } + + inline ::int32_t getUgfoo() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenerics::Ug::Builder { +public: + typedef Ug Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenerics::Ug::Builder asTestGenericsGeneric() { + return typename TestGenerics::Ug::Builder(_builder); + } + + inline ::int32_t getUgfoo(); + inline void setUgfoo( ::int32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenerics::Ug::Pipeline { +public: + typedef Ug Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenericsWrapper::Reader { +public: + typedef TestGenericsWrapper Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenericsWrapper::Reader asGeneric() { + return typename TestGenericsWrapper::Reader(_reader); + } + + inline bool hasValue() const; + inline typename ::capnproto_test::capnp::test::TestGenerics::Reader getValue() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenericsWrapper::Builder { +public: + typedef TestGenericsWrapper Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenericsWrapper::Builder asGeneric() { + return typename TestGenericsWrapper::Builder(_builder); + } + + inline bool hasValue(); + inline typename ::capnproto_test::capnp::test::TestGenerics::Builder getValue(); + inline void setValue(typename ::capnproto_test::capnp::test::TestGenerics::Reader value); + inline typename ::capnproto_test::capnp::test::TestGenerics::Builder initValue(); + inline void adoptValue(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics> disownValue(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenericsWrapper::Pipeline { +public: + typedef TestGenericsWrapper Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename ::capnproto_test::capnp::test::TestGenerics::Pipeline getValue(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestGenericsWrapper2::Reader { +public: + typedef TestGenericsWrapper2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasValue() const; + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader getValue() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestGenericsWrapper2::Builder { +public: + typedef TestGenericsWrapper2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasValue(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder getValue(); + inline void setValue( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader value); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder initValue(); + inline void adoptValue(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>> disownValue(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestGenericsWrapper2::Pipeline { +public: + typedef TestGenericsWrapper2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline getValue(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestImplicitMethodParams::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestImplicitMethodParams Calls; + typedef TestImplicitMethodParams Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + template + ::capnp::Request< ::capnproto_test::capnp::test::TestImplicitMethodParams::CallParams, ::capnproto_test::capnp::test::TestGenerics> callRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestImplicitMethodParams::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestImplicitMethodParams Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestImplicitMethodParams::CallParams<> CallParams; + typedef ::capnp::CallContext> CallContext; + virtual ::kj::Promise call(CallContext context); + + inline ::capnproto_test::capnp::test::TestImplicitMethodParams::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestImplicitMethodParams>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +template +class TestImplicitMethodParams::CallParams::Reader { +public: + typedef CallParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename CallParams::Reader asGeneric() { + return typename CallParams::Reader(_reader); + } + + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestImplicitMethodParams::CallParams::Builder { +public: + typedef CallParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename CallParams::Builder asGeneric() { + return typename CallParams::Builder(_builder); + } + + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestImplicitMethodParams::CallParams::Pipeline { +public: + typedef CallParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline ::capnp::PipelineFor getBar(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +class TestImplicitMethodParamsInGeneric::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestImplicitMethodParamsInGeneric Calls; + typedef TestImplicitMethodParamsInGeneric Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + template + typename TestImplicitMethodParamsInGeneric::Client asGeneric() { + return castAs>(); + } + + template + CAPNP_AUTO_IF_MSVC(::capnp::Request::template CallParams, ::capnproto_test::capnp::test::TestGenerics>) callRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +template +class TestImplicitMethodParamsInGeneric::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestImplicitMethodParamsInGeneric Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef typename ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::template CallParams<> CallParams; + typedef ::capnp::CallContext> CallContext; + virtual ::kj::Promise call(CallContext context); + + inline typename ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +template +template +class TestImplicitMethodParamsInGeneric::CallParams::Reader { +public: + typedef CallParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename CallParams::Reader asGeneric() { + return typename CallParams::Reader(_reader); + } + + template + typename TestImplicitMethodParamsInGeneric::template CallParams::Reader asTestImplicitMethodParamsInGenericGeneric() { + return typename TestImplicitMethodParamsInGeneric::template CallParams::Reader(_reader); + } + + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +template +class TestImplicitMethodParamsInGeneric::CallParams::Builder { +public: + typedef CallParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename CallParams::Builder asGeneric() { + return typename CallParams::Builder(_builder); + } + + template + typename TestImplicitMethodParamsInGeneric::template CallParams::Builder asTestImplicitMethodParamsInGenericGeneric() { + return typename TestImplicitMethodParamsInGeneric::template CallParams::Builder(_builder); + } + + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +template +class TestImplicitMethodParamsInGeneric::CallParams::Pipeline { +public: + typedef CallParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getFoo(); + inline ::capnp::PipelineFor getBar(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestGenericsUnion::Reader { +public: + typedef TestGenericsUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestGenericsUnion::Reader asGeneric() { + return typename TestGenericsUnion::Reader(_reader); + } + + inline Which which() const; + inline bool isFoo() const; + inline bool hasFoo() const; + inline ::capnp::ReaderFor getFoo() const; + + inline bool isBar() const; + inline bool hasBar() const; + inline ::capnp::ReaderFor getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestGenericsUnion::Builder { +public: + typedef TestGenericsUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestGenericsUnion::Builder asGeneric() { + return typename TestGenericsUnion::Builder(_builder); + } + + inline Which which(); + inline bool isFoo(); + inline bool hasFoo(); + inline ::capnp::BuilderFor getFoo(); + inline void setFoo( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initFoo(); + inline ::capnp::BuilderFor initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan&& value); + inline ::capnp::Orphan disownFoo(); + + inline bool isBar(); + inline bool hasBar(); + inline ::capnp::BuilderFor getBar(); + inline void setBar( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initBar(); + inline ::capnp::BuilderFor initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan&& value); + inline ::capnp::Orphan disownBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestGenericsUnion::Pipeline { +public: + typedef TestGenericsUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestUseGenerics::Reader { +public: + typedef TestUseGenerics Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasBasic() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader getBasic() const; + + inline bool hasInner() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader getInner() const; + + inline bool hasInner2() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader getInner2() const; + + inline bool hasUnspecified() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Reader getUnspecified() const; + + inline bool hasUnspecifiedInner() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Reader getUnspecifiedInner() const; + + inline bool hasDefault() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Reader getDefault() const; + + inline bool hasDefaultInner() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Reader getDefaultInner() const; + + inline bool hasDefaultUser() const; + inline ::capnproto_test::capnp::test::TestUseGenerics::Reader getDefaultUser() const; + + inline bool hasWrapper() const; + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader getWrapper() const; + + inline bool hasDefaultWrapper() const; + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader getDefaultWrapper() const; + + inline bool hasDefaultWrapper2() const; + inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Reader getDefaultWrapper2() const; + + inline bool hasAliasFoo() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getAliasFoo() const; + + inline bool hasAliasInner() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader getAliasInner() const; + + inline bool hasAliasInner2() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Reader getAliasInner2() const; + + inline bool hasAliasInner2Bind() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Reader getAliasInner2Bind() const; + + inline bool hasAliasInner2Text() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader getAliasInner2Text() const; + + inline bool hasAliasRev() const; + inline ::capnp::Text::Reader getAliasRev() const; + + inline bool hasUseAliases() const; + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Reader getUseAliases() const; + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Reader getCap() const; +#endif // !CAPNP_LITE + + inline bool hasGenericCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client getGenericCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestUseGenerics::Builder { +public: + typedef TestUseGenerics Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasBasic(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder getBasic(); + inline void setBasic( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder initBasic(); + inline void adoptBasic(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> disownBasic(); + + inline bool hasInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder getInner(); + inline void setInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder initInner(); + inline void adoptInner(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner> disownInner(); + + inline bool hasInner2(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder getInner2(); + inline void setInner2( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder initInner2(); + inline void adoptInner2(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>> disownInner2(); + + inline bool hasUnspecified(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Builder getUnspecified(); + inline void setUnspecified( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Builder initUnspecified(); + inline void adoptUnspecified(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>> disownUnspecified(); + + inline bool hasUnspecifiedInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Builder getUnspecifiedInner(); + inline void setUnspecifiedInner( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Builder initUnspecifiedInner(); + inline void adoptUnspecifiedInner(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>> disownUnspecifiedInner(); + + inline bool hasDefault(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Builder getDefault(); + inline void setDefault( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Builder initDefault(); + inline void adoptDefault(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>> disownDefault(); + + inline bool hasDefaultInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Builder getDefaultInner(); + inline void setDefaultInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Builder initDefaultInner(); + inline void adoptDefaultInner(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner> disownDefaultInner(); + + inline bool hasDefaultUser(); + inline ::capnproto_test::capnp::test::TestUseGenerics::Builder getDefaultUser(); + inline void setDefaultUser( ::capnproto_test::capnp::test::TestUseGenerics::Reader value); + inline ::capnproto_test::capnp::test::TestUseGenerics::Builder initDefaultUser(); + inline void adoptDefaultUser(::capnp::Orphan< ::capnproto_test::capnp::test::TestUseGenerics>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUseGenerics> disownDefaultUser(); + + inline bool hasWrapper(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder getWrapper(); + inline void setWrapper( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder initWrapper(); + inline void adoptWrapper(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> disownWrapper(); + + inline bool hasDefaultWrapper(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder getDefaultWrapper(); + inline void setDefaultWrapper( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader value); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder initDefaultWrapper(); + inline void adoptDefaultWrapper(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>> disownDefaultWrapper(); + + inline bool hasDefaultWrapper2(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Builder getDefaultWrapper2(); + inline void setDefaultWrapper2( ::capnproto_test::capnp::test::TestGenericsWrapper2::Reader value); + inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Builder initDefaultWrapper2(); + inline void adoptDefaultWrapper2(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper2>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper2> disownDefaultWrapper2(); + + inline bool hasAliasFoo(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getAliasFoo(); + inline void setAliasFoo( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initAliasFoo(); + inline void adoptAliasFoo(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownAliasFoo(); + + inline bool hasAliasInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder getAliasInner(); + inline void setAliasInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder initAliasInner(); + inline void adoptAliasInner(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner> disownAliasInner(); + + inline bool hasAliasInner2(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Builder getAliasInner2(); + inline void setAliasInner2( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Builder initAliasInner2(); + inline void adoptAliasInner2(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>> disownAliasInner2(); + + inline bool hasAliasInner2Bind(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Builder getAliasInner2Bind(); + inline void setAliasInner2Bind( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Builder initAliasInner2Bind(); + inline void adoptAliasInner2Bind(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>> disownAliasInner2Bind(); + + inline bool hasAliasInner2Text(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder getAliasInner2Text(); + inline void setAliasInner2Text( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder initAliasInner2Text(); + inline void adoptAliasInner2Text(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>> disownAliasInner2Text(); + + inline bool hasAliasRev(); + inline ::capnp::Text::Builder getAliasRev(); + inline void setAliasRev( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAliasRev(unsigned int size); + inline void adoptAliasRev(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAliasRev(); + + inline bool hasUseAliases(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Builder getUseAliases(); + inline void setUseAliases( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Builder initUseAliases(); + inline void adoptUseAliases(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases> disownUseAliases(); + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Builder getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Reader value); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Builder initCap(); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>> disownCap(); +#endif // !CAPNP_LITE + + inline bool hasGenericCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client getGenericCap(); + inline void setGenericCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client&& value); + inline void setGenericCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client& value); + inline void adoptGenericCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>> disownGenericCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestUseGenerics::Pipeline { +public: + typedef TestUseGenerics Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline getBasic(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline getInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline getInner2(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Pipeline getUnspecified(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Pipeline getUnspecifiedInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Pipeline getDefault(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Pipeline getDefaultInner(); + inline ::capnproto_test::capnp::test::TestUseGenerics::Pipeline getDefaultUser(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline getWrapper(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline getDefaultWrapper(); + inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Pipeline getDefaultWrapper2(); + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getAliasFoo(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline getAliasInner(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Pipeline getAliasInner2(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Pipeline getAliasInner2Bind(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline getAliasInner2Text(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Pipeline getUseAliases(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Pipeline getCap(); + inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client getGenericCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestEmptyStruct::Reader { +public: + typedef TestEmptyStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestEmptyStruct::Builder { +public: + typedef TestEmptyStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestEmptyStruct::Pipeline { +public: + typedef TestEmptyStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestConstants::Reader { +public: + typedef TestConstants Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestConstants::Builder { +public: + typedef TestConstants Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestConstants::Pipeline { +public: + typedef TestConstants Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestAnyPointerConstants::Reader { +public: + typedef TestAnyPointerConstants Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasAnyKindAsStruct() const; + inline ::capnp::AnyPointer::Reader getAnyKindAsStruct() const; + + inline bool hasAnyStructAsStruct() const; + inline ::capnp::AnyStruct::Reader getAnyStructAsStruct() const; + + inline bool hasAnyKindAsList() const; + inline ::capnp::AnyPointer::Reader getAnyKindAsList() const; + + inline bool hasAnyListAsList() const; + inline ::capnp::AnyList::Reader getAnyListAsList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestAnyPointerConstants::Builder { +public: + typedef TestAnyPointerConstants Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasAnyKindAsStruct(); + inline ::capnp::AnyPointer::Builder getAnyKindAsStruct(); + inline ::capnp::AnyPointer::Builder initAnyKindAsStruct(); + + inline bool hasAnyStructAsStruct(); + inline ::capnp::AnyStruct::Builder getAnyStructAsStruct(); + inline void setAnyStructAsStruct( ::capnp::AnyStruct::Reader value); + template + inline ::capnp::BuilderFor initAnyStructAsStructAs(); + inline void adoptAnyStructAsStruct(::capnp::Orphan< ::capnp::AnyStruct>&& value); + inline ::capnp::Orphan< ::capnp::AnyStruct> disownAnyStructAsStruct(); + + inline bool hasAnyKindAsList(); + inline ::capnp::AnyPointer::Builder getAnyKindAsList(); + inline ::capnp::AnyPointer::Builder initAnyKindAsList(); + + inline bool hasAnyListAsList(); + inline ::capnp::AnyList::Builder getAnyListAsList(); + inline void setAnyListAsList( ::capnp::AnyList::Reader value); + template + inline ::capnp::BuilderFor initAnyListAsListAs(unsigned int size); + inline void adoptAnyListAsList(::capnp::Orphan< ::capnp::AnyList>&& value); + inline ::capnp::Orphan< ::capnp::AnyList> disownAnyListAsList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestAnyPointerConstants::Pipeline { +public: + typedef TestAnyPointerConstants Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::AnyStruct::Pipeline getAnyStructAsStruct(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestInterface::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestInterface Calls; + typedef TestInterface Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestInterface::FooParams, ::capnproto_test::capnp::test::TestInterface::FooResults> fooRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestInterface::BarParams, ::capnproto_test::capnp::test::TestInterface::BarResults> barRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestInterface::BazParams, ::capnproto_test::capnp::test::TestInterface::BazResults> bazRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestInterface::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestInterface Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestInterface::FooParams FooParams; + typedef ::capnproto_test::capnp::test::TestInterface::FooResults FooResults; + typedef ::capnp::CallContext FooContext; + virtual ::kj::Promise foo(FooContext context); + typedef ::capnproto_test::capnp::test::TestInterface::BarParams BarParams; + typedef ::capnproto_test::capnp::test::TestInterface::BarResults BarResults; + typedef ::capnp::CallContext BarContext; + virtual ::kj::Promise bar(BarContext context); + typedef ::capnproto_test::capnp::test::TestInterface::BazParams BazParams; + typedef ::capnproto_test::capnp::test::TestInterface::BazResults BazResults; + typedef ::capnp::CallContext BazContext; + virtual ::kj::Promise baz(BazContext context); + + inline ::capnproto_test::capnp::test::TestInterface::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestInterface>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestInterface::FooParams::Reader { +public: + typedef FooParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getI() const; + + inline bool getJ() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::FooParams::Builder { +public: + typedef FooParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getI(); + inline void setI( ::uint32_t value); + + inline bool getJ(); + inline void setJ(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::FooParams::Pipeline { +public: + typedef FooParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterface::FooResults::Reader { +public: + typedef FooResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasX() const; + inline ::capnp::Text::Reader getX() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::FooResults::Builder { +public: + typedef FooResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasX(); + inline ::capnp::Text::Builder getX(); + inline void setX( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initX(unsigned int size); + inline void adoptX(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownX(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::FooResults::Pipeline { +public: + typedef FooResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterface::BarParams::Reader { +public: + typedef BarParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::BarParams::Builder { +public: + typedef BarParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::BarParams::Pipeline { +public: + typedef BarParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterface::BarResults::Reader { +public: + typedef BarResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::BarResults::Builder { +public: + typedef BarResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::BarResults::Pipeline { +public: + typedef BarResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterface::BazParams::Reader { +public: + typedef BazParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getS() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::BazParams::Builder { +public: + typedef BazParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getS(); + inline void setS( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initS(); + inline void adoptS(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownS(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::BazParams::Pipeline { +public: + typedef BazParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getS(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestInterface::BazResults::Reader { +public: + typedef BazResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestInterface::BazResults::Builder { +public: + typedef BazResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestInterface::BazResults::Pipeline { +public: + typedef BazResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestExtends::Client + : public virtual ::capnp::Capability::Client, + public virtual ::capnproto_test::capnp::test::TestInterface::Client { +public: + typedef TestExtends Calls; + typedef TestExtends Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestExtends::QuxParams, ::capnproto_test::capnp::test::TestExtends::QuxResults> quxRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestExtends::CorgeResults> corgeRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestExtends::GraultParams, ::capnproto_test::capnp::test::TestAllTypes> graultRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestExtends::Server + : public virtual ::capnp::Capability::Server, + public virtual ::capnproto_test::capnp::test::TestInterface::Server { +public: + typedef TestExtends Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestExtends::QuxParams QuxParams; + typedef ::capnproto_test::capnp::test::TestExtends::QuxResults QuxResults; + typedef ::capnp::CallContext QuxContext; + virtual ::kj::Promise qux(QuxContext context); + typedef ::capnproto_test::capnp::test::TestExtends::CorgeResults CorgeResults; + typedef ::capnp::CallContext< ::capnproto_test::capnp::test::TestAllTypes, CorgeResults> CorgeContext; + virtual ::kj::Promise corge(CorgeContext context); + typedef ::capnproto_test::capnp::test::TestExtends::GraultParams GraultParams; + typedef ::capnp::CallContext GraultContext; + virtual ::kj::Promise grault(GraultContext context); + + inline ::capnproto_test::capnp::test::TestExtends::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestExtends>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestExtends::QuxParams::Reader { +public: + typedef QuxParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestExtends::QuxParams::Builder { +public: + typedef QuxParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestExtends::QuxParams::Pipeline { +public: + typedef QuxParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestExtends::QuxResults::Reader { +public: + typedef QuxResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestExtends::QuxResults::Builder { +public: + typedef QuxResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestExtends::QuxResults::Pipeline { +public: + typedef QuxResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestExtends::CorgeResults::Reader { +public: + typedef CorgeResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestExtends::CorgeResults::Builder { +public: + typedef CorgeResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestExtends::CorgeResults::Pipeline { +public: + typedef CorgeResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestExtends::GraultParams::Reader { +public: + typedef GraultParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestExtends::GraultParams::Builder { +public: + typedef GraultParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestExtends::GraultParams::Pipeline { +public: + typedef GraultParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestExtends2::Client + : public virtual ::capnp::Capability::Client, + public virtual ::capnproto_test::capnp::test::TestExtends::Client { +public: + typedef TestExtends2 Calls; + typedef TestExtends2 Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + +protected: + Client() = default; +}; + +class TestExtends2::Server + : public virtual ::capnp::Capability::Server, + public virtual ::capnproto_test::capnp::test::TestExtends::Server { +public: + typedef TestExtends2 Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + + inline ::capnproto_test::capnp::test::TestExtends2::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestExtends2>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestPipeline::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestPipeline Calls; + typedef TestPipeline Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::GetCapParams, ::capnproto_test::capnp::test::TestPipeline::GetCapResults> getCapRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::TestPointersParams, ::capnproto_test::capnp::test::TestPipeline::TestPointersResults> testPointersRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestPipeline::GetAnyCapParams, ::capnproto_test::capnp::test::TestPipeline::GetAnyCapResults> getAnyCapRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestPipeline::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestPipeline Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestPipeline::GetCapParams GetCapParams; + typedef ::capnproto_test::capnp::test::TestPipeline::GetCapResults GetCapResults; + typedef ::capnp::CallContext GetCapContext; + virtual ::kj::Promise getCap(GetCapContext context); + typedef ::capnproto_test::capnp::test::TestPipeline::TestPointersParams TestPointersParams; + typedef ::capnproto_test::capnp::test::TestPipeline::TestPointersResults TestPointersResults; + typedef ::capnp::CallContext TestPointersContext; + virtual ::kj::Promise testPointers(TestPointersContext context); + typedef ::capnproto_test::capnp::test::TestPipeline::GetAnyCapParams GetAnyCapParams; + typedef ::capnproto_test::capnp::test::TestPipeline::GetAnyCapResults GetAnyCapResults; + typedef ::capnp::CallContext GetAnyCapContext; + virtual ::kj::Promise getAnyCap(GetAnyCapContext context); + + inline ::capnproto_test::capnp::test::TestPipeline::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestPipeline>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestPipeline::Box::Reader { +public: + typedef Box Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::Box::Builder { +public: + typedef Box Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::Box::Pipeline { +public: + typedef Box Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::AnyBox::Reader { +public: + typedef AnyBox Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnp::Capability::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::AnyBox::Builder { +public: + typedef AnyBox Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnp::Capability::Client getCap(); + inline void setCap( ::capnp::Capability::Client&& value); + inline void setCap( ::capnp::Capability::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnp::Capability>&& value); + inline ::capnp::Orphan< ::capnp::Capability> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::AnyBox::Pipeline { +public: + typedef AnyBox Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::Capability::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::GetCapParams::Reader { +public: + typedef GetCapParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getN() const; + + inline bool hasInCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::GetCapParams::Builder { +public: + typedef GetCapParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getN(); + inline void setN( ::uint32_t value); + + inline bool hasInCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap(); + inline void setInCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setInCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptInCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownInCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::GetCapParams::Pipeline { +public: + typedef GetCapParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::GetCapResults::Reader { +public: + typedef GetCapResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + + inline bool hasOutBox() const; + inline ::capnproto_test::capnp::test::TestPipeline::Box::Reader getOutBox() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::GetCapResults::Builder { +public: + typedef GetCapResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + + inline bool hasOutBox(); + inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder getOutBox(); + inline void setOutBox( ::capnproto_test::capnp::test::TestPipeline::Box::Reader value); + inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder initOutBox(); + inline void adoptOutBox(::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box> disownOutBox(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::GetCapResults::Pipeline { +public: + typedef GetCapResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline getOutBox(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::TestPointersParams::Reader { +public: + typedef TestPointersParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + + inline bool hasObj() const; + inline ::capnp::AnyPointer::Reader getObj() const; + + inline bool hasList() const; +#if !CAPNP_LITE + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Reader getList() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::TestPointersParams::Builder { +public: + typedef TestPointersParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + + inline bool hasObj(); + inline ::capnp::AnyPointer::Builder getObj(); + inline ::capnp::AnyPointer::Builder initObj(); + + inline bool hasList(); +#if !CAPNP_LITE + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Builder getList(); + inline void setList( ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Builder initList(unsigned int size); + inline void adoptList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>> disownList(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::TestPointersParams::Pipeline { +public: + typedef TestPointersParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::TestPointersResults::Reader { +public: + typedef TestPointersResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::TestPointersResults::Builder { +public: + typedef TestPointersResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::TestPointersResults::Pipeline { +public: + typedef TestPointersResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::GetAnyCapParams::Reader { +public: + typedef GetAnyCapParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getN() const; + + inline bool hasInCap() const; +#if !CAPNP_LITE + inline ::capnp::Capability::Client getInCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::GetAnyCapParams::Builder { +public: + typedef GetAnyCapParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getN(); + inline void setN( ::uint32_t value); + + inline bool hasInCap(); +#if !CAPNP_LITE + inline ::capnp::Capability::Client getInCap(); + inline void setInCap( ::capnp::Capability::Client&& value); + inline void setInCap( ::capnp::Capability::Client& value); + inline void adoptInCap(::capnp::Orphan< ::capnp::Capability>&& value); + inline ::capnp::Orphan< ::capnp::Capability> disownInCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::GetAnyCapParams::Pipeline { +public: + typedef GetAnyCapParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::Capability::Client getInCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestPipeline::GetAnyCapResults::Reader { +public: + typedef GetAnyCapResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + + inline bool hasOutBox() const; + inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Reader getOutBox() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestPipeline::GetAnyCapResults::Builder { +public: + typedef GetAnyCapResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + + inline bool hasOutBox(); + inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Builder getOutBox(); + inline void setOutBox( ::capnproto_test::capnp::test::TestPipeline::AnyBox::Reader value); + inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Builder initOutBox(); + inline void adoptOutBox(::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::AnyBox>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::AnyBox> disownOutBox(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestPipeline::GetAnyCapResults::Pipeline { +public: + typedef GetAnyCapResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Pipeline getOutBox(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestCallOrder::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestCallOrder Calls; + typedef TestCallOrder Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceParams, ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceResults> getCallSequenceRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestCallOrder::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestCallOrder Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceParams GetCallSequenceParams; + typedef ::capnproto_test::capnp::test::TestCallOrder::GetCallSequenceResults GetCallSequenceResults; + typedef ::capnp::CallContext GetCallSequenceContext; + virtual ::kj::Promise getCallSequence(GetCallSequenceContext context); + + inline ::capnproto_test::capnp::test::TestCallOrder::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestCallOrder>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestCallOrder::GetCallSequenceParams::Reader { +public: + typedef GetCallSequenceParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getExpected() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestCallOrder::GetCallSequenceParams::Builder { +public: + typedef GetCallSequenceParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getExpected(); + inline void setExpected( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestCallOrder::GetCallSequenceParams::Pipeline { +public: + typedef GetCallSequenceParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestCallOrder::GetCallSequenceResults::Reader { +public: + typedef GetCallSequenceResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getN() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestCallOrder::GetCallSequenceResults::Builder { +public: + typedef GetCallSequenceResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getN(); + inline void setN( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestCallOrder::GetCallSequenceResults::Pipeline { +public: + typedef GetCallSequenceResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestTailCallee::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestTailCallee Calls; + typedef TestTailCallee Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestTailCallee::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult> fooRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestTailCallee::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestTailCallee Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestTailCallee::FooParams FooParams; + typedef ::capnp::CallContext FooContext; + virtual ::kj::Promise foo(FooContext context); + + inline ::capnproto_test::capnp::test::TestTailCallee::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestTailCallee>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestTailCallee::TailResult::Reader { +public: + typedef TailResult Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getI() const; + + inline bool hasT() const; + inline ::capnp::Text::Reader getT() const; + + inline bool hasC() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getC() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestTailCallee::TailResult::Builder { +public: + typedef TailResult Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint32_t getI(); + inline void setI( ::uint32_t value); + + inline bool hasT(); + inline ::capnp::Text::Builder getT(); + inline void setT( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initT(unsigned int size); + inline void adoptT(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownT(); + + inline bool hasC(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getC(); + inline void setC( ::capnproto_test::capnp::test::TestCallOrder::Client&& value); + inline void setC( ::capnproto_test::capnp::test::TestCallOrder::Client& value); + inline void adoptC(::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> disownC(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestTailCallee::TailResult::Pipeline { +public: + typedef TailResult Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestCallOrder::Client getC(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestTailCallee::FooParams::Reader { +public: + typedef FooParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getI() const; + + inline bool hasT() const; + inline ::capnp::Text::Reader getT() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestTailCallee::FooParams::Builder { +public: + typedef FooParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getI(); + inline void setI( ::int32_t value); + + inline bool hasT(); + inline ::capnp::Text::Builder getT(); + inline void setT( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initT(unsigned int size); + inline void adoptT(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownT(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestTailCallee::FooParams::Pipeline { +public: + typedef FooParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestTailCaller::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestTailCaller Calls; + typedef TestTailCaller Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestTailCaller::FooParams, ::capnproto_test::capnp::test::TestTailCallee::TailResult> fooRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestTailCaller::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestTailCaller Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestTailCaller::FooParams FooParams; + typedef ::capnp::CallContext FooContext; + virtual ::kj::Promise foo(FooContext context); + + inline ::capnproto_test::capnp::test::TestTailCaller::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestTailCaller>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestTailCaller::FooParams::Reader { +public: + typedef FooParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::int32_t getI() const; + + inline bool hasCallee() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestTailCallee::Client getCallee() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestTailCaller::FooParams::Builder { +public: + typedef FooParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::int32_t getI(); + inline void setI( ::int32_t value); + + inline bool hasCallee(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestTailCallee::Client getCallee(); + inline void setCallee( ::capnproto_test::capnp::test::TestTailCallee::Client&& value); + inline void setCallee( ::capnproto_test::capnp::test::TestTailCallee::Client& value); + inline void adoptCallee(::capnp::Orphan< ::capnproto_test::capnp::test::TestTailCallee>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestTailCallee> disownCallee(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestTailCaller::FooParams::Pipeline { +public: + typedef FooParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestTailCallee::Client getCallee(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestHandle::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestHandle Calls; + typedef TestHandle Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + +protected: + Client() = default; +}; + +class TestHandle::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestHandle Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + + inline ::capnproto_test::capnp::test::TestHandle::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestHandle>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestMoreStuff::Client + : public virtual ::capnp::Capability::Client, + public virtual ::capnproto_test::capnp::test::TestCallOrder::Client { +public: + typedef TestMoreStuff Calls; + typedef TestMoreStuff Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallFooParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooResults> callFooRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedParams, ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedResults> callFooWhenResolvedRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnParams, ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnResults> neverReturnRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::HoldParams, ::capnproto_test::capnp::test::TestMoreStuff::HoldResults> holdRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::CallHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::CallHeldResults> callHeldRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetHeldParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHeldResults> getHeldRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::EchoParams, ::capnproto_test::capnp::test::TestMoreStuff::EchoResults> echoRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelParams, ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelResults> expectCancelRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsResults> methodWithDefaultsRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetHandleParams, ::capnproto_test::capnp::test::TestMoreStuff::GetHandleResults> getHandleRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetNullParams, ::capnproto_test::capnp::test::TestMoreStuff::GetNullResults> getNullRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringParams, ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringResults> getEnormousStringRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultParams, ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultResults> methodWithNullDefaultRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestMoreStuff::Server + : public virtual ::capnp::Capability::Server, + public virtual ::capnproto_test::capnp::test::TestCallOrder::Server { +public: + typedef TestMoreStuff Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallFooParams CallFooParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallFooResults CallFooResults; + typedef ::capnp::CallContext CallFooContext; + virtual ::kj::Promise callFoo(CallFooContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedParams CallFooWhenResolvedParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallFooWhenResolvedResults CallFooWhenResolvedResults; + typedef ::capnp::CallContext CallFooWhenResolvedContext; + virtual ::kj::Promise callFooWhenResolved(CallFooWhenResolvedContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnParams NeverReturnParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::NeverReturnResults NeverReturnResults; + typedef ::capnp::CallContext NeverReturnContext; + virtual ::kj::Promise neverReturn(NeverReturnContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::HoldParams HoldParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::HoldResults HoldResults; + typedef ::capnp::CallContext HoldContext; + virtual ::kj::Promise hold(HoldContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallHeldParams CallHeldParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::CallHeldResults CallHeldResults; + typedef ::capnp::CallContext CallHeldContext; + virtual ::kj::Promise callHeld(CallHeldContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetHeldParams GetHeldParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetHeldResults GetHeldResults; + typedef ::capnp::CallContext GetHeldContext; + virtual ::kj::Promise getHeld(GetHeldContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::EchoParams EchoParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::EchoResults EchoResults; + typedef ::capnp::CallContext EchoContext; + virtual ::kj::Promise echo(EchoContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelParams ExpectCancelParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::ExpectCancelResults ExpectCancelResults; + typedef ::capnp::CallContext ExpectCancelContext; + virtual ::kj::Promise expectCancel(ExpectCancelContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsParams MethodWithDefaultsParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::MethodWithDefaultsResults MethodWithDefaultsResults; + typedef ::capnp::CallContext MethodWithDefaultsContext; + virtual ::kj::Promise methodWithDefaults(MethodWithDefaultsContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetHandleParams GetHandleParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetHandleResults GetHandleResults; + typedef ::capnp::CallContext GetHandleContext; + virtual ::kj::Promise getHandle(GetHandleContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetNullParams GetNullParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetNullResults GetNullResults; + typedef ::capnp::CallContext GetNullContext; + virtual ::kj::Promise getNull(GetNullContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringParams GetEnormousStringParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::GetEnormousStringResults GetEnormousStringResults; + typedef ::capnp::CallContext GetEnormousStringContext; + virtual ::kj::Promise getEnormousString(GetEnormousStringContext context); + typedef ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultParams MethodWithNullDefaultParams; + typedef ::capnproto_test::capnp::test::TestMoreStuff::MethodWithNullDefaultResults MethodWithNullDefaultResults; + typedef ::capnp::CallContext MethodWithNullDefaultContext; + virtual ::kj::Promise methodWithNullDefault(MethodWithNullDefaultContext context); + + inline ::capnproto_test::capnp::test::TestMoreStuff::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestMoreStuff>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallFooParams::Reader { +public: + typedef CallFooParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallFooParams::Builder { +public: + typedef CallFooParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallFooParams::Pipeline { +public: + typedef CallFooParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallFooResults::Reader { +public: + typedef CallFooResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallFooResults::Builder { +public: + typedef CallFooResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallFooResults::Pipeline { +public: + typedef CallFooResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallFooWhenResolvedParams::Reader { +public: + typedef CallFooWhenResolvedParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallFooWhenResolvedParams::Builder { +public: + typedef CallFooWhenResolvedParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallFooWhenResolvedParams::Pipeline { +public: + typedef CallFooWhenResolvedParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallFooWhenResolvedResults::Reader { +public: + typedef CallFooWhenResolvedResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallFooWhenResolvedResults::Builder { +public: + typedef CallFooWhenResolvedResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallFooWhenResolvedResults::Pipeline { +public: + typedef CallFooWhenResolvedResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::NeverReturnParams::Reader { +public: + typedef NeverReturnParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::NeverReturnParams::Builder { +public: + typedef NeverReturnParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::NeverReturnParams::Pipeline { +public: + typedef NeverReturnParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::NeverReturnResults::Reader { +public: + typedef NeverReturnResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCapCopy() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCapCopy() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::NeverReturnResults::Builder { +public: + typedef NeverReturnResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCapCopy(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCapCopy(); + inline void setCapCopy( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCapCopy( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCapCopy(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCapCopy(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::NeverReturnResults::Pipeline { +public: + typedef NeverReturnResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCapCopy(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::HoldParams::Reader { +public: + typedef HoldParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::HoldParams::Builder { +public: + typedef HoldParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::HoldParams::Pipeline { +public: + typedef HoldParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::HoldResults::Reader { +public: + typedef HoldResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::HoldResults::Builder { +public: + typedef HoldResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::HoldResults::Pipeline { +public: + typedef HoldResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallHeldParams::Reader { +public: + typedef CallHeldParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallHeldParams::Builder { +public: + typedef CallHeldParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallHeldParams::Pipeline { +public: + typedef CallHeldParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::CallHeldResults::Reader { +public: + typedef CallHeldResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::CallHeldResults::Builder { +public: + typedef CallHeldResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::CallHeldResults::Pipeline { +public: + typedef CallHeldResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetHeldParams::Reader { +public: + typedef GetHeldParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetHeldParams::Builder { +public: + typedef GetHeldParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetHeldParams::Pipeline { +public: + typedef GetHeldParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetHeldResults::Reader { +public: + typedef GetHeldResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetHeldResults::Builder { +public: + typedef GetHeldResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetHeldResults::Pipeline { +public: + typedef GetHeldResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::EchoParams::Reader { +public: + typedef EchoParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::EchoParams::Builder { +public: + typedef EchoParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestCallOrder::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestCallOrder::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::EchoParams::Pipeline { +public: + typedef EchoParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::EchoResults::Reader { +public: + typedef EchoResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::EchoResults::Builder { +public: + typedef EchoResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestCallOrder::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestCallOrder::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::EchoResults::Pipeline { +public: + typedef EchoResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestCallOrder::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::ExpectCancelParams::Reader { +public: + typedef ExpectCancelParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::ExpectCancelParams::Builder { +public: + typedef ExpectCancelParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::ExpectCancelParams::Pipeline { +public: + typedef ExpectCancelParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::ExpectCancelResults::Reader { +public: + typedef ExpectCancelResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::ExpectCancelResults::Builder { +public: + typedef ExpectCancelResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::ExpectCancelResults::Pipeline { +public: + typedef ExpectCancelResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::MethodWithDefaultsParams::Reader { +public: + typedef MethodWithDefaultsParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasA() const; + inline ::capnp::Text::Reader getA() const; + + inline ::uint32_t getB() const; + + inline bool hasC() const; + inline ::capnp::Text::Reader getC() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::MethodWithDefaultsParams::Builder { +public: + typedef MethodWithDefaultsParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasA(); + inline ::capnp::Text::Builder getA(); + inline void setA( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initA(unsigned int size); + inline void adoptA(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownA(); + + inline ::uint32_t getB(); + inline void setB( ::uint32_t value); + + inline bool hasC(); + inline ::capnp::Text::Builder getC(); + inline void setC( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initC(unsigned int size); + inline void adoptC(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownC(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::MethodWithDefaultsParams::Pipeline { +public: + typedef MethodWithDefaultsParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::MethodWithDefaultsResults::Reader { +public: + typedef MethodWithDefaultsResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasD() const; + inline ::capnp::Text::Reader getD() const; + + inline bool hasE() const; + inline ::capnp::Text::Reader getE() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::MethodWithDefaultsResults::Builder { +public: + typedef MethodWithDefaultsResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasD(); + inline ::capnp::Text::Builder getD(); + inline void setD( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initD(unsigned int size); + inline void adoptD(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownD(); + + inline bool hasE(); + inline ::capnp::Text::Builder getE(); + inline void setE( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initE(unsigned int size); + inline void adoptE(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownE(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::MethodWithDefaultsResults::Pipeline { +public: + typedef MethodWithDefaultsResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetHandleParams::Reader { +public: + typedef GetHandleParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetHandleParams::Builder { +public: + typedef GetHandleParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetHandleParams::Pipeline { +public: + typedef GetHandleParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetHandleResults::Reader { +public: + typedef GetHandleResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasHandle() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestHandle::Client getHandle() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetHandleResults::Builder { +public: + typedef GetHandleResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasHandle(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestHandle::Client getHandle(); + inline void setHandle( ::capnproto_test::capnp::test::TestHandle::Client&& value); + inline void setHandle( ::capnproto_test::capnp::test::TestHandle::Client& value); + inline void adoptHandle(::capnp::Orphan< ::capnproto_test::capnp::test::TestHandle>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestHandle> disownHandle(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetHandleResults::Pipeline { +public: + typedef GetHandleResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestHandle::Client getHandle(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetNullParams::Reader { +public: + typedef GetNullParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetNullParams::Builder { +public: + typedef GetNullParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetNullParams::Pipeline { +public: + typedef GetNullParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetNullResults::Reader { +public: + typedef GetNullResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasNullCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMoreStuff::Client getNullCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetNullResults::Builder { +public: + typedef GetNullResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasNullCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMoreStuff::Client getNullCap(); + inline void setNullCap( ::capnproto_test::capnp::test::TestMoreStuff::Client&& value); + inline void setNullCap( ::capnproto_test::capnp::test::TestMoreStuff::Client& value); + inline void adoptNullCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestMoreStuff>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMoreStuff> disownNullCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetNullResults::Pipeline { +public: + typedef GetNullResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMoreStuff::Client getNullCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetEnormousStringParams::Reader { +public: + typedef GetEnormousStringParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetEnormousStringParams::Builder { +public: + typedef GetEnormousStringParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetEnormousStringParams::Pipeline { +public: + typedef GetEnormousStringParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::GetEnormousStringResults::Reader { +public: + typedef GetEnormousStringResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasStr() const; + inline ::capnp::Text::Reader getStr() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::GetEnormousStringResults::Builder { +public: + typedef GetEnormousStringResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasStr(); + inline ::capnp::Text::Builder getStr(); + inline void setStr( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStr(unsigned int size); + inline void adoptStr(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownStr(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::GetEnormousStringResults::Pipeline { +public: + typedef GetEnormousStringResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::MethodWithNullDefaultParams::Reader { +public: + typedef MethodWithNullDefaultParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasA() const; + inline ::capnp::Text::Reader getA() const; + + inline bool hasB() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getB() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::MethodWithNullDefaultParams::Builder { +public: + typedef MethodWithNullDefaultParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasA(); + inline ::capnp::Text::Builder getA(); + inline void setA( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initA(unsigned int size); + inline void adoptA(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownA(); + + inline bool hasB(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getB(); + inline void setB( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setB( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptB(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownB(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::MethodWithNullDefaultParams::Pipeline { +public: + typedef MethodWithNullDefaultParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getB(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMoreStuff::MethodWithNullDefaultResults::Reader { +public: + typedef MethodWithNullDefaultResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMoreStuff::MethodWithNullDefaultResults::Builder { +public: + typedef MethodWithNullDefaultResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMoreStuff::MethodWithNullDefaultResults::Pipeline { +public: + typedef MethodWithNullDefaultResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestMembrane::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestMembrane Calls; + typedef TestMembrane Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::MakeThingParams, ::capnproto_test::capnp::test::TestMembrane::MakeThingResults> makeThingRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::CallPassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result> callPassThroughRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::CallInterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result> callInterceptRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::LoopbackParams, ::capnproto_test::capnp::test::TestMembrane::LoopbackResults> loopbackRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::WaitForeverParams, ::capnproto_test::capnp::test::TestMembrane::WaitForeverResults> waitForeverRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestMembrane::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestMembrane Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestMembrane::MakeThingParams MakeThingParams; + typedef ::capnproto_test::capnp::test::TestMembrane::MakeThingResults MakeThingResults; + typedef ::capnp::CallContext MakeThingContext; + virtual ::kj::Promise makeThing(MakeThingContext context); + typedef ::capnproto_test::capnp::test::TestMembrane::CallPassThroughParams CallPassThroughParams; + typedef ::capnp::CallContext CallPassThroughContext; + virtual ::kj::Promise callPassThrough(CallPassThroughContext context); + typedef ::capnproto_test::capnp::test::TestMembrane::CallInterceptParams CallInterceptParams; + typedef ::capnp::CallContext CallInterceptContext; + virtual ::kj::Promise callIntercept(CallInterceptContext context); + typedef ::capnproto_test::capnp::test::TestMembrane::LoopbackParams LoopbackParams; + typedef ::capnproto_test::capnp::test::TestMembrane::LoopbackResults LoopbackResults; + typedef ::capnp::CallContext LoopbackContext; + virtual ::kj::Promise loopback(LoopbackContext context); + typedef ::capnproto_test::capnp::test::TestMembrane::WaitForeverParams WaitForeverParams; + typedef ::capnproto_test::capnp::test::TestMembrane::WaitForeverResults WaitForeverResults; + typedef ::capnp::CallContext WaitForeverContext; + virtual ::kj::Promise waitForever(WaitForeverContext context); + + inline ::capnproto_test::capnp::test::TestMembrane::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestMembrane>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestMembrane::Thing::Client + : public virtual ::capnp::Capability::Client { +public: + typedef Thing Calls; + typedef Thing Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::Thing::PassThroughParams, ::capnproto_test::capnp::test::TestMembrane::Result> passThroughRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestMembrane::Thing::InterceptParams, ::capnproto_test::capnp::test::TestMembrane::Result> interceptRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestMembrane::Thing::Server + : public virtual ::capnp::Capability::Server { +public: + typedef Thing Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestMembrane::Thing::PassThroughParams PassThroughParams; + typedef ::capnp::CallContext PassThroughContext; + virtual ::kj::Promise passThrough(PassThroughContext context); + typedef ::capnproto_test::capnp::test::TestMembrane::Thing::InterceptParams InterceptParams; + typedef ::capnp::CallContext InterceptContext; + virtual ::kj::Promise intercept(InterceptContext context); + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestMembrane::Thing>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestMembrane::Thing::PassThroughParams::Reader { +public: + typedef PassThroughParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::Thing::PassThroughParams::Builder { +public: + typedef PassThroughParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::Thing::PassThroughParams::Pipeline { +public: + typedef PassThroughParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::Thing::InterceptParams::Reader { +public: + typedef InterceptParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::Thing::InterceptParams::Builder { +public: + typedef InterceptParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::Thing::InterceptParams::Pipeline { +public: + typedef InterceptParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::Result::Reader { +public: + typedef Result Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasText() const; + inline ::capnp::Text::Reader getText() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::Result::Builder { +public: + typedef Result Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasText(); + inline ::capnp::Text::Builder getText(); + inline void setText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initText(unsigned int size); + inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownText(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::Result::Pipeline { +public: + typedef Result Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::MakeThingParams::Reader { +public: + typedef MakeThingParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::MakeThingParams::Builder { +public: + typedef MakeThingParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::MakeThingParams::Pipeline { +public: + typedef MakeThingParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::MakeThingResults::Reader { +public: + typedef MakeThingResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasThing() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::MakeThingResults::Builder { +public: + typedef MakeThingResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasThing(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptThing(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownThing(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::MakeThingResults::Pipeline { +public: + typedef MakeThingResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::CallPassThroughParams::Reader { +public: + typedef CallPassThroughParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasThing() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing() const; +#endif // !CAPNP_LITE + + inline bool getTailCall() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::CallPassThroughParams::Builder { +public: + typedef CallPassThroughParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasThing(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptThing(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownThing(); +#endif // !CAPNP_LITE + + inline bool getTailCall(); + inline void setTailCall(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::CallPassThroughParams::Pipeline { +public: + typedef CallPassThroughParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::CallInterceptParams::Reader { +public: + typedef CallInterceptParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasThing() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing() const; +#endif // !CAPNP_LITE + + inline bool getTailCall() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::CallInterceptParams::Builder { +public: + typedef CallInterceptParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasThing(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptThing(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownThing(); +#endif // !CAPNP_LITE + + inline bool getTailCall(); + inline void setTailCall(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::CallInterceptParams::Pipeline { +public: + typedef CallInterceptParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::LoopbackParams::Reader { +public: + typedef LoopbackParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasThing() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::LoopbackParams::Builder { +public: + typedef LoopbackParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasThing(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptThing(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownThing(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::LoopbackParams::Pipeline { +public: + typedef LoopbackParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::LoopbackResults::Reader { +public: + typedef LoopbackResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasThing() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::LoopbackResults::Builder { +public: + typedef LoopbackResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasThing(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptThing(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownThing(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::LoopbackResults::Pipeline { +public: + typedef LoopbackResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getThing(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::WaitForeverParams::Reader { +public: + typedef WaitForeverParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::WaitForeverParams::Builder { +public: + typedef WaitForeverParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::WaitForeverParams::Pipeline { +public: + typedef WaitForeverParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestMembrane::WaitForeverResults::Reader { +public: + typedef WaitForeverResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestMembrane::WaitForeverResults::Builder { +public: + typedef WaitForeverResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestMembrane::WaitForeverResults::Pipeline { +public: + typedef WaitForeverResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestContainMembrane::Reader { +public: + typedef TestContainMembrane Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getCap() const; +#endif // !CAPNP_LITE + + inline bool hasList() const; +#if !CAPNP_LITE + inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Reader getList() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestContainMembrane::Builder { +public: + typedef TestContainMembrane Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> disownCap(); +#endif // !CAPNP_LITE + + inline bool hasList(); +#if !CAPNP_LITE + inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Builder getList(); + inline void setList( ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Builder initList(unsigned int size); + inline void adoptList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>> disownList(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestContainMembrane::Pipeline { +public: + typedef TestContainMembrane Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestTransferCap::Reader { +public: + typedef TestTransferCap Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Reader getList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestTransferCap::Builder { +public: + typedef TestTransferCap Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Builder getList(); + inline void setList( ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Builder initList(unsigned int size); + inline void adoptList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>> disownList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestTransferCap::Pipeline { +public: + typedef TestTransferCap Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestTransferCap::Element::Reader { +public: + typedef Element Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasText() const; + inline ::capnp::Text::Reader getText() const; + + inline bool hasCap() const; +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestTransferCap::Element::Builder { +public: + typedef Element Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasText(); + inline ::capnp::Text::Builder getText(); + inline void setText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initText(unsigned int size); + inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownText(); + + inline bool hasCap(); +#if !CAPNP_LITE + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestTransferCap::Element::Pipeline { +public: + typedef Element Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class TestKeywordMethods::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestKeywordMethods Calls; + typedef TestKeywordMethods Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::DeleteParams, ::capnproto_test::capnp::test::TestKeywordMethods::DeleteResults> deleteRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::ClassParams, ::capnproto_test::capnp::test::TestKeywordMethods::ClassResults> classRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::VoidParams, ::capnproto_test::capnp::test::TestKeywordMethods::VoidResults> voidRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + ::capnp::Request< ::capnproto_test::capnp::test::TestKeywordMethods::ReturnParams, ::capnproto_test::capnp::test::TestKeywordMethods::ReturnResults> returnRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class TestKeywordMethods::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestKeywordMethods Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::TestKeywordMethods::DeleteParams DeleteParams; + typedef ::capnproto_test::capnp::test::TestKeywordMethods::DeleteResults DeleteResults; + typedef ::capnp::CallContext DeleteContext; + virtual ::kj::Promise delete_(DeleteContext context); + typedef ::capnproto_test::capnp::test::TestKeywordMethods::ClassParams ClassParams; + typedef ::capnproto_test::capnp::test::TestKeywordMethods::ClassResults ClassResults; + typedef ::capnp::CallContext ClassContext; + virtual ::kj::Promise class_(ClassContext context); + typedef ::capnproto_test::capnp::test::TestKeywordMethods::VoidParams VoidParams; + typedef ::capnproto_test::capnp::test::TestKeywordMethods::VoidResults VoidResults; + typedef ::capnp::CallContext VoidContext; + virtual ::kj::Promise void_(VoidContext context); + typedef ::capnproto_test::capnp::test::TestKeywordMethods::ReturnParams ReturnParams; + typedef ::capnproto_test::capnp::test::TestKeywordMethods::ReturnResults ReturnResults; + typedef ::capnp::CallContext ReturnContext; + virtual ::kj::Promise return_(ReturnContext context); + + inline ::capnproto_test::capnp::test::TestKeywordMethods::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestKeywordMethods>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::DeleteParams::Reader { +public: + typedef DeleteParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::DeleteParams::Builder { +public: + typedef DeleteParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::DeleteParams::Pipeline { +public: + typedef DeleteParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::DeleteResults::Reader { +public: + typedef DeleteResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::DeleteResults::Builder { +public: + typedef DeleteResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::DeleteResults::Pipeline { +public: + typedef DeleteResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::ClassParams::Reader { +public: + typedef ClassParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::ClassParams::Builder { +public: + typedef ClassParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::ClassParams::Pipeline { +public: + typedef ClassParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::ClassResults::Reader { +public: + typedef ClassResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::ClassResults::Builder { +public: + typedef ClassResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::ClassResults::Pipeline { +public: + typedef ClassResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::VoidParams::Reader { +public: + typedef VoidParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::VoidParams::Builder { +public: + typedef VoidParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::VoidParams::Pipeline { +public: + typedef VoidParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::VoidResults::Reader { +public: + typedef VoidResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::VoidResults::Builder { +public: + typedef VoidResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::VoidResults::Pipeline { +public: + typedef VoidResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::ReturnParams::Reader { +public: + typedef ReturnParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::ReturnParams::Builder { +public: + typedef ReturnParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::ReturnParams::Pipeline { +public: + typedef ReturnParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestKeywordMethods::ReturnResults::Reader { +public: + typedef ReturnResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestKeywordMethods::ReturnResults::Builder { +public: + typedef ReturnResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestKeywordMethods::ReturnResults::Pipeline { +public: + typedef ReturnResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +class TestAuthenticatedBootstrap::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestAuthenticatedBootstrap Calls; + typedef TestAuthenticatedBootstrap Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + template + typename TestAuthenticatedBootstrap::Client asGeneric() { + return castAs>(); + } + + CAPNP_AUTO_IF_MSVC(::capnp::Request::GetCallerIdParams, typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults>) getCallerIdRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +template +class TestAuthenticatedBootstrap::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestAuthenticatedBootstrap Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdParams GetCallerIdParams; + typedef typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults GetCallerIdResults; + typedef ::capnp::CallContext GetCallerIdContext; + virtual ::kj::Promise getCallerId(GetCallerIdContext context); + + inline typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::TestAuthenticatedBootstrap>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +template +class TestAuthenticatedBootstrap::GetCallerIdParams::Reader { +public: + typedef GetCallerIdParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestAuthenticatedBootstrap::GetCallerIdParams::Reader asTestAuthenticatedBootstrapGeneric() { + return typename TestAuthenticatedBootstrap::GetCallerIdParams::Reader(_reader); + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestAuthenticatedBootstrap::GetCallerIdParams::Builder { +public: + typedef GetCallerIdParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestAuthenticatedBootstrap::GetCallerIdParams::Builder asTestAuthenticatedBootstrapGeneric() { + return typename TestAuthenticatedBootstrap::GetCallerIdParams::Builder(_builder); + } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestAuthenticatedBootstrap::GetCallerIdParams::Pipeline { +public: + typedef GetCallerIdParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +template +class TestAuthenticatedBootstrap::GetCallerIdResults::Reader { +public: + typedef GetCallerIdResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + template + typename TestAuthenticatedBootstrap::GetCallerIdResults::Reader asTestAuthenticatedBootstrapGeneric() { + return typename TestAuthenticatedBootstrap::GetCallerIdResults::Reader(_reader); + } + + inline bool hasCaller() const; + inline ::capnp::ReaderFor getCaller() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +template +class TestAuthenticatedBootstrap::GetCallerIdResults::Builder { +public: + typedef GetCallerIdResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + template + typename TestAuthenticatedBootstrap::GetCallerIdResults::Builder asTestAuthenticatedBootstrapGeneric() { + return typename TestAuthenticatedBootstrap::GetCallerIdResults::Builder(_builder); + } + + inline bool hasCaller(); + inline ::capnp::BuilderFor getCaller(); + inline void setCaller( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initCaller(); + inline ::capnp::BuilderFor initCaller(unsigned int size); + inline void adoptCaller(::capnp::Orphan&& value); + inline ::capnp::Orphan disownCaller(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +template +class TestAuthenticatedBootstrap::GetCallerIdResults::Pipeline { +public: + typedef GetCallerIdResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnp::PipelineFor getCaller(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestSturdyRef::Reader { +public: + typedef TestSturdyRef Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasHostId() const; + inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Reader getHostId() const; + + inline bool hasObjectId() const; + inline ::capnp::AnyPointer::Reader getObjectId() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestSturdyRef::Builder { +public: + typedef TestSturdyRef Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasHostId(); + inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Builder getHostId(); + inline void setHostId( ::capnproto_test::capnp::test::TestSturdyRefHostId::Reader value); + inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Builder initHostId(); + inline void adoptHostId(::capnp::Orphan< ::capnproto_test::capnp::test::TestSturdyRefHostId>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestSturdyRefHostId> disownHostId(); + + inline bool hasObjectId(); + inline ::capnp::AnyPointer::Builder getObjectId(); + inline ::capnp::AnyPointer::Builder initObjectId(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestSturdyRef::Pipeline { +public: + typedef TestSturdyRef Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Pipeline getHostId(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestSturdyRefHostId::Reader { +public: + typedef TestSturdyRefHostId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool hasHost() const; + inline ::capnp::Text::Reader getHost() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestSturdyRefHostId::Builder { +public: + typedef TestSturdyRefHostId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool hasHost(); + inline ::capnp::Text::Builder getHost(); + inline void setHost( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initHost(unsigned int size); + inline void adoptHost(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownHost(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestSturdyRefHostId::Pipeline { +public: + typedef TestSturdyRefHostId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestSturdyRefObjectId::Reader { +public: + typedef TestSturdyRefObjectId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag getTag() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestSturdyRefObjectId::Builder { +public: + typedef TestSturdyRefObjectId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag getTag(); + inline void setTag( ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestSturdyRefObjectId::Pipeline { +public: + typedef TestSturdyRefObjectId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestProvisionId::Reader { +public: + typedef TestProvisionId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestProvisionId::Builder { +public: + typedef TestProvisionId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestProvisionId::Pipeline { +public: + typedef TestProvisionId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestRecipientId::Reader { +public: + typedef TestRecipientId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestRecipientId::Builder { +public: + typedef TestRecipientId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestRecipientId::Pipeline { +public: + typedef TestRecipientId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestThirdPartyCapId::Reader { +public: + typedef TestThirdPartyCapId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestThirdPartyCapId::Builder { +public: + typedef TestThirdPartyCapId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestThirdPartyCapId::Pipeline { +public: + typedef TestThirdPartyCapId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class TestJoinResult::Reader { +public: + typedef TestJoinResult Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class TestJoinResult::Builder { +public: + typedef TestJoinResult Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TestJoinResult::Pipeline { +public: + typedef TestJoinResult Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class RenamedStruct::Reader { +public: + typedef RenamedStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isGoodFieldName() const; + inline bool getGoodFieldName() const; + + inline bool isBar() const; + inline ::int8_t getBar() const; + + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum getAnotherGoodFieldName() const; + + inline typename RenamedUnion::Reader getRenamedUnion() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedStruct::Builder { +public: + typedef RenamedStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isGoodFieldName(); + inline bool getGoodFieldName(); + inline void setGoodFieldName(bool value); + + inline bool isBar(); + inline ::int8_t getBar(); + inline void setBar( ::int8_t value); + + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum getAnotherGoodFieldName(); + inline void setAnotherGoodFieldName( ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum value); + + inline typename RenamedUnion::Builder getRenamedUnion(); + inline typename RenamedUnion::Builder initRenamedUnion(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedStruct::Pipeline { +public: + typedef RenamedStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline typename RenamedUnion::Pipeline getRenamedUnion(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class RenamedStruct::RenamedNestedStruct::Reader { +public: + typedef RenamedNestedStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline bool getGoodNestedFieldName() const; + + inline bool hasAnotherGoodNestedFieldName() const; + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader getAnotherGoodNestedFieldName() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedStruct::RenamedNestedStruct::Builder { +public: + typedef RenamedNestedStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline bool getGoodNestedFieldName(); + inline void setGoodNestedFieldName(bool value); + + inline bool hasAnotherGoodNestedFieldName(); + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder getAnotherGoodNestedFieldName(); + inline void setAnotherGoodNestedFieldName( ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader value); + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder initAnotherGoodNestedFieldName(); + inline void adoptAnotherGoodNestedFieldName(::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct> disownAnotherGoodNestedFieldName(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedStruct::RenamedNestedStruct::Pipeline { +public: + typedef RenamedNestedStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Pipeline getAnotherGoodNestedFieldName(); +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class RenamedStruct::RenamedUnion::Reader { +public: + typedef RenamedUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline Which which() const; + inline bool isRenamedGroup() const; + inline typename RenamedGroup::Reader getRenamedGroup() const; + + inline bool isQux() const; + inline bool hasQux() const; + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader getQux() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedStruct::RenamedUnion::Builder { +public: + typedef RenamedUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline Which which(); + inline bool isRenamedGroup(); + inline typename RenamedGroup::Builder getRenamedGroup(); + inline typename RenamedGroup::Builder initRenamedGroup(); + + inline bool isQux(); + inline bool hasQux(); + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder getQux(); + inline void setQux( ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader value); + inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder initQux(); + inline void adoptQux(::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct> disownQux(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedStruct::RenamedUnion::Pipeline { +public: + typedef RenamedUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class RenamedStruct::RenamedUnion::RenamedGroup::Reader { +public: + typedef RenamedGroup Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::capnp::Void getFoo() const; + + inline ::capnp::Void getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedStruct::RenamedUnion::RenamedGroup::Builder { +public: + typedef RenamedGroup Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::capnp::Void getFoo(); + inline void setFoo( ::capnp::Void value = ::capnp::VOID); + + inline ::capnp::Void getBar(); + inline void setBar( ::capnp::Void value = ::capnp::VOID); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedStruct::RenamedUnion::RenamedGroup::Pipeline { +public: + typedef RenamedGroup Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +class RenamedInterface::Client + : public virtual ::capnp::Capability::Client { +public: + typedef RenamedInterface Calls; + typedef RenamedInterface Reads; + + Client(decltype(nullptr)); + explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); + template ()>> + Client(::kj::Own<_t>&& server); + template ()>> + Client(::kj::Promise<_t>&& promise); + Client(::kj::Exception&& exception); + Client(Client&) = default; + Client(Client&&) = default; + Client& operator=(Client& other); + Client& operator=(Client&& other); + + ::capnp::Request< ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodParams, ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodResults> renamedMethodRequest( + ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); + +protected: + Client() = default; +}; + +class RenamedInterface::Server + : public virtual ::capnp::Capability::Server { +public: + typedef RenamedInterface Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) + override; + +protected: + typedef ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodParams RenamedMethodParams; + typedef ::capnproto_test::capnp::test::RenamedInterface::RenamedMethodResults RenamedMethodResults; + typedef ::capnp::CallContext RenamedMethodContext; + virtual ::kj::Promise renamedMethod(RenamedMethodContext context); + + inline ::capnproto_test::capnp::test::RenamedInterface::Client thisCap() { + return ::capnp::Capability::Server::thisCap() + .template castAs< ::capnproto_test::capnp::test::RenamedInterface>(); + } + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); +}; +#endif // !CAPNP_LITE + +class RenamedInterface::RenamedMethodParams::Reader { +public: + typedef RenamedMethodParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint8_t getRenamedParam() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedInterface::RenamedMethodParams::Builder { +public: + typedef RenamedMethodParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint8_t getRenamedParam(); + inline void setRenamedParam( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedInterface::RenamedMethodParams::Pipeline { +public: + typedef RenamedMethodParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class RenamedInterface::RenamedMethodResults::Reader { +public: + typedef RenamedMethodResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class RenamedInterface::RenamedMethodResults::Builder { +public: + typedef RenamedMethodResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RenamedInterface::RenamedMethodResults::Pipeline { +public: + typedef RenamedMethodResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +// ======================================================================================= + +inline ::capnp::Void TestAllTypes::Reader::getVoidField() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestAllTypes::Builder::getVoidField() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setVoidField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::getBoolField() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::getBoolField() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setBoolField(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::int8_t TestAllTypes::Reader::getInt8Field() const { + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestAllTypes::Builder::getInt8Field() { + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt8Field( ::int8_t value) { + _builder.setDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::int16_t TestAllTypes::Reader::getInt16Field() const { + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestAllTypes::Builder::getInt16Field() { + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt16Field( ::int16_t value) { + _builder.setDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::int32_t TestAllTypes::Reader::getInt32Field() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestAllTypes::Builder::getInt32Field() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt32Field( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::int64_t TestAllTypes::Reader::getInt64Field() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestAllTypes::Builder::getInt64Field() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt64Field( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t TestAllTypes::Reader::getUInt8Field() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestAllTypes::Builder::getUInt8Field() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt8Field( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TestAllTypes::Reader::getUInt16Field() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestAllTypes::Builder::getUInt16Field() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt16Field( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t TestAllTypes::Reader::getUInt32Field() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestAllTypes::Builder::getUInt32Field() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt32Field( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t TestAllTypes::Reader::getUInt64Field() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestAllTypes::Builder::getUInt64Field() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt64Field( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline float TestAllTypes::Reader::getFloat32Field() const { + return _reader.getDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} + +inline float TestAllTypes::Builder::getFloat32Field() { + return _builder.getDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setFloat32Field(float value) { + _builder.setDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value); +} + +inline double TestAllTypes::Reader::getFloat64Field() const { + return _reader.getDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline double TestAllTypes::Builder::getFloat64Field() { + return _builder.getDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setFloat64Field(double value) { + _builder.setDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasTextField() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasTextField() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestAllTypes::Reader::getTextField() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestAllTypes::Builder::getTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setTextField( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestAllTypes::Builder::initTextField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptTextField( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestAllTypes::Builder::disownTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasDataField() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasDataField() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader TestAllTypes::Reader::getDataField() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder TestAllTypes::Builder::getDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setDataField( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Data::Builder TestAllTypes::Builder::initDataField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptDataField( + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Data> TestAllTypes::Builder::disownDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasStructField() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasStructField() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestAllTypes::Reader::getStructField() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestAllTypes::Builder::getStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestAllTypes::Pipeline::getStructField() { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void TestAllTypes::Builder::setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestAllTypes::Builder::initStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::adoptStructField( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestAllTypes::Builder::disownStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestEnum TestAllTypes::Reader::getEnumField() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS); +} + +inline ::capnproto_test::capnp::test::TestEnum TestAllTypes::Builder::getEnumField() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setEnumField( ::capnproto_test::capnp::test::TestEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS, value); +} + +inline ::capnp::Void TestAllTypes::Reader::getInterfaceField() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestAllTypes::Builder::getInterfaceField() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInterfaceField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasVoidList() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasVoidList() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getVoidList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setVoidList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setVoidList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initVoidList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptVoidList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasBoolList() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasBoolList() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getBoolList() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setBoolList( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setBoolList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initBoolList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptBoolList( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt8List() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt8List() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt8List( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt8List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt8List( + ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt16List() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt16List() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt16List( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt16List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt16List( + ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt32List() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt32List() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt32List( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt32List( + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt64List() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt64List() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt64List( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt64List( + ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt8List() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt8List() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getUInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt8List( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt8List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initUInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt8List( + ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt16List() const { + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt16List() { + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getUInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt16List( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt16List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initUInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt16List( + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt32List() const { + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt32List() { + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getUInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt32List( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initUInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt32List( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt64List() const { + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt64List() { + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getUInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt64List( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initUInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt64List( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasFloat32List() const { + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasFloat32List() { + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getFloat32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setFloat32List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setFloat32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initFloat32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptFloat32List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasFloat64List() const { + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasFloat64List() { + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getFloat64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setFloat64List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setFloat64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initFloat64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptFloat64List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasTextList() const { + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasTextList() { + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader TestAllTypes::Reader::getTextList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder TestAllTypes::Builder::getTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setTextList( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setTextList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder TestAllTypes::Builder::initTextList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptTextList( + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> TestAllTypes::Builder::disownTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasDataList() const { + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasDataList() { + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader TestAllTypes::Reader::getDataList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder TestAllTypes::Builder::getDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setDataList( ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setDataList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder TestAllTypes::Builder::initDataList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptDataList( + ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>> TestAllTypes::Builder::disownDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasStructList() const { + return !_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasStructList() { + return !_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader TestAllTypes::Reader::getStructList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder TestAllTypes::Builder::getStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder TestAllTypes::Builder::initStructList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptStructList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>> TestAllTypes::Builder::disownStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasEnumList() const { + return !_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasEnumList() { + return !_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader TestAllTypes::Reader::getEnumList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::get(_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder TestAllTypes::Builder::getEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::get(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setEnumList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder TestAllTypes::Builder::initEnumList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::init(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptEnumList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::adopt(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>> TestAllTypes::Builder::disownEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::disown(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInterfaceList() const { + return !_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInterfaceList() { + return !_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader TestAllTypes::Reader::getInterfaceList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::getInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInterfaceList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInterfaceList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestAllTypes::Builder::initInterfaceList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInterfaceList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> TestAllTypes::Builder::disownInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} + +inline ::capnp::Void TestDefaults::Reader::getVoidField() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestDefaults::Builder::getVoidField() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestDefaults::Builder::setVoidField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestDefaults::Reader::getBoolField() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, true); +} + +inline bool TestDefaults::Builder::getBoolField() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, true); +} +inline void TestDefaults::Builder::setBoolField(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, true); +} + +inline ::int8_t TestDefaults::Reader::getInt8Field() const { + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -123); +} + +inline ::int8_t TestDefaults::Builder::getInt8Field() { + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -123); +} +inline void TestDefaults::Builder::setInt8Field( ::int8_t value) { + _builder.setDataField< ::int8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, -123); +} + +inline ::int16_t TestDefaults::Reader::getInt16Field() const { + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -12345); +} + +inline ::int16_t TestDefaults::Builder::getInt16Field() { + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -12345); +} +inline void TestDefaults::Builder::setInt16Field( ::int16_t value) { + _builder.setDataField< ::int16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, -12345); +} + +inline ::int32_t TestDefaults::Reader::getInt32Field() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -12345678); +} + +inline ::int32_t TestDefaults::Builder::getInt32Field() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -12345678); +} +inline void TestDefaults::Builder::setInt32Field( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, -12345678); +} + +inline ::int64_t TestDefaults::Reader::getInt64Field() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -123456789012345ll); +} + +inline ::int64_t TestDefaults::Builder::getInt64Field() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, -123456789012345ll); +} +inline void TestDefaults::Builder::setInt64Field( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, -123456789012345ll); +} + +inline ::uint8_t TestDefaults::Reader::getUInt8Field() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS, 234u); +} + +inline ::uint8_t TestDefaults::Builder::getUInt8Field() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS, 234u); +} +inline void TestDefaults::Builder::setUInt8Field( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<16>() * ::capnp::ELEMENTS, value, 234u); +} + +inline ::uint16_t TestDefaults::Reader::getUInt16Field() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, 45678u); +} + +inline ::uint16_t TestDefaults::Builder::getUInt16Field() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, 45678u); +} +inline void TestDefaults::Builder::setUInt16Field( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value, 45678u); +} + +inline ::uint32_t TestDefaults::Reader::getUInt32Field() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, 3456789012u); +} + +inline ::uint32_t TestDefaults::Builder::getUInt32Field() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, 3456789012u); +} +inline void TestDefaults::Builder::setUInt32Field( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value, 3456789012u); +} + +inline ::uint64_t TestDefaults::Reader::getUInt64Field() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, 12345678901234567890ull); +} + +inline ::uint64_t TestDefaults::Builder::getUInt64Field() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, 12345678901234567890ull); +} +inline void TestDefaults::Builder::setUInt64Field( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value, 12345678901234567890ull); +} + +inline float TestDefaults::Reader::getFloat32Field() const { + return _reader.getDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, 1150963712u); +} + +inline float TestDefaults::Builder::getFloat32Field() { + return _builder.getDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, 1150963712u); +} +inline void TestDefaults::Builder::setFloat32Field(float value) { + _builder.setDataField( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value, 1150963712u); +} + +inline double TestDefaults::Reader::getFloat64Field() const { + return _reader.getDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, 14534676766106106624ull); +} + +inline double TestDefaults::Builder::getFloat64Field() { + return _builder.getDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, 14534676766106106624ull); +} +inline void TestDefaults::Builder::setFloat64Field(double value) { + _builder.setDataField( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value, 14534676766106106624ull); +} + +inline bool TestDefaults::Reader::hasTextField() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasTextField() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestDefaults::Reader::getTextField() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 372, 3); +} +inline ::capnp::Text::Builder TestDefaults::Builder::getTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 372, 3); +} +inline void TestDefaults::Builder::setTextField( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestDefaults::Builder::initTextField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptTextField( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestDefaults::Builder::disownTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasDataField() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasDataField() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader TestDefaults::Reader::getDataField() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 382, 3); +} +inline ::capnp::Data::Builder TestDefaults::Builder::getDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 382, 3); +} +inline void TestDefaults::Builder::setDataField( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Data::Builder TestDefaults::Builder::initDataField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptDataField( + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Data> TestDefaults::Builder::disownDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasStructField() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasStructField() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestDefaults::Reader::getStructField() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 391); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestDefaults::Builder::getStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 391); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestDefaults::Pipeline::getStructField() { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void TestDefaults::Builder::setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestDefaults::Builder::initStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestDefaults::Builder::adoptStructField( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestDefaults::Builder::disownStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestEnum TestDefaults::Reader::getEnumField() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS, 5u); +} + +inline ::capnproto_test::capnp::test::TestEnum TestDefaults::Builder::getEnumField() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS, 5u); +} +inline void TestDefaults::Builder::setEnumField( ::capnproto_test::capnp::test::TestEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestEnum>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS, value, 5u); +} + +inline ::capnp::Void TestDefaults::Reader::getInterfaceField() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestDefaults::Builder::getInterfaceField() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestDefaults::Builder::setInterfaceField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestDefaults::Reader::hasVoidList() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasVoidList() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getVoidList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 629); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 629); +} +inline void TestDefaults::Builder::setVoidList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setVoidList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initVoidList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptVoidList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasBoolList() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasBoolList() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getBoolList() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 642); +} +inline ::capnp::List::Builder TestDefaults::Builder::getBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 642); +} +inline void TestDefaults::Builder::setBoolList( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setBoolList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initBoolList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptBoolList( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt8List() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt8List() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 656); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 656); +} +inline void TestDefaults::Builder::setInt8List( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt8List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt8List( + ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt16List() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt16List() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 670); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 670); +} +inline void TestDefaults::Builder::setInt16List( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt16List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt16List( + ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt32List() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt32List() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 684); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 684); +} +inline void TestDefaults::Builder::setInt32List( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt32List( + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt64List() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt64List() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 698); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 698); +} +inline void TestDefaults::Builder::setInt64List( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt64List( + ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt8List() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt8List() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getUInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 713); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 713); +} +inline void TestDefaults::Builder::setUInt8List( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt8List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initUInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt8List( + ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt16List() const { + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt16List() { + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getUInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 727); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 727); +} +inline void TestDefaults::Builder::setUInt16List( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt16List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initUInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt16List( + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt32List() const { + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt32List() { + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getUInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 741); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 741); +} +inline void TestDefaults::Builder::setUInt32List( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initUInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt32List( + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt64List() const { + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt64List() { + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getUInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 755); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 755); +} +inline void TestDefaults::Builder::setUInt64List( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initUInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt64List( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasFloat32List() const { + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasFloat32List() { + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getFloat32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 769); +} +inline ::capnp::List::Builder TestDefaults::Builder::getFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 769); +} +inline void TestDefaults::Builder::setFloat32List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setFloat32List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initFloat32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptFloat32List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasFloat64List() const { + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasFloat64List() { + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getFloat64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 784); +} +inline ::capnp::List::Builder TestDefaults::Builder::getFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 784); +} +inline void TestDefaults::Builder::setFloat64List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setFloat64List(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initFloat64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptFloat64List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasTextList() const { + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasTextList() { + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader TestDefaults::Reader::getTextList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 801); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder TestDefaults::Builder::getTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 801); +} +inline void TestDefaults::Builder::setTextList( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setTextList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder TestDefaults::Builder::initTextList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptTextList( + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> TestDefaults::Builder::disownTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasDataList() const { + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasDataList() { + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader TestDefaults::Reader::getDataList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 820); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder TestDefaults::Builder::getDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 820); +} +inline void TestDefaults::Builder::setDataList( ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setDataList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>::Builder TestDefaults::Builder::initDataList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptDataList( + ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>> TestDefaults::Builder::disownDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasStructList() const { + return !_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasStructList() { + return !_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader TestDefaults::Reader::getStructList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 840); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder TestDefaults::Builder::getStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 840); +} +inline void TestDefaults::Builder::setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>::Builder TestDefaults::Builder::initStructList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptStructList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>> TestDefaults::Builder::disownStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasEnumList() const { + return !_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasEnumList() { + return !_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader TestDefaults::Reader::getEnumList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::get(_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 938); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder TestDefaults::Builder::getEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::get(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), + ::capnp::schemas::bp_eb3f9ebe98c73cb6 + 938); +} +inline void TestDefaults::Builder::setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setEnumList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>::Builder TestDefaults::Builder::initEnumList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::init(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptEnumList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::adopt(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>> TestDefaults::Builder::disownEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum, ::capnp::Kind::ENUM>>::disown(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInterfaceList() const { + return !_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInterfaceList() { + return !_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader TestDefaults::Reader::getInterfaceList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::getInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline void TestDefaults::Builder::setInterfaceList( ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInterfaceList(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>::Builder TestDefaults::Builder::initInterfaceList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInterfaceList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>> TestDefaults::Builder::disownInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} + +inline bool TestAnyPointer::Reader::hasAnyPointerField() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyPointer::Builder::hasAnyPointerField() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyPointer::Reader TestAnyPointer::Reader::getAnyPointerField() const { + return ::capnp::AnyPointer::Reader(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointer::Builder::getAnyPointerField() { + return ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointer::Builder::initAnyPointerField() { + auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestAnyOthers::Reader::hasAnyStructField() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyOthers::Builder::hasAnyStructField() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyStruct::Reader TestAnyOthers::Reader::getAnyStructField() const { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyStruct::Builder TestAnyOthers::Builder::getAnyStructField() { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnp::AnyStruct::Pipeline TestAnyOthers::Pipeline::getAnyStructField() { + return ::capnp::AnyStruct::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestAnyOthers::Builder::setAnyStructField( ::capnp::AnyStruct::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestAnyOthers::Builder::initAnyStructFieldAs() { + static_assert(::capnp::kind() == ::capnp::Kind::STRUCT, + "anyStructField must be a struct"); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestAnyOthers::Builder::adoptAnyStructField( + ::capnp::Orphan< ::capnp::AnyStruct>&& value) { + ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::AnyStruct> TestAnyOthers::Builder::disownAnyStructField() { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestAnyOthers::Reader::hasAnyListField() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyOthers::Builder::hasAnyListField() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyList::Reader TestAnyOthers::Reader::getAnyListField() const { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyList::Builder TestAnyOthers::Builder::getAnyListField() { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestAnyOthers::Builder::setAnyListField( ::capnp::AnyList::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::AnyList>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestAnyOthers::Builder::initAnyListFieldAs(unsigned int size) { + static_assert(::capnp::kind() == ::capnp::Kind::LIST, + "anyListField must be a list"); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestAnyOthers::Builder::adoptAnyListField( + ::capnp::Orphan< ::capnp::AnyList>&& value) { + ::capnp::_::PointerHelpers< ::capnp::AnyList>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::AnyList> TestAnyOthers::Builder::disownAnyListField() { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestAnyOthers::Reader::hasCapabilityField() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyOthers::Builder::hasCapabilityField() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnp::Capability::Client TestAnyOthers::Reader::getCapabilityField() const { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestAnyOthers::Builder::getCapabilityField() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestAnyOthers::Pipeline::getCapabilityField() { + return ::capnp::Capability::Client(_typeless.getPointerField(2).asCap()); +} +inline void TestAnyOthers::Builder::setCapabilityField( ::capnp::Capability::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestAnyOthers::Builder::setCapabilityField( ::capnp::Capability::Client& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), cap); +} +inline void TestAnyOthers::Builder::adoptCapabilityField( + ::capnp::Orphan< ::capnp::Capability>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Capability> TestAnyOthers::Builder::disownCapabilityField() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestOutOfOrder::Reader::hasQux() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasQux() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getQux() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getQux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setQux( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initQux(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownQux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasGrault() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasGrault() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getBar() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setBar( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptBar( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getFoo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getFoo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setFoo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptFoo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownFoo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasCorge() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasCorge() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getCorge() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getCorge() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setCorge( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initCorge(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownCorge() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasWaldo() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasWaldo() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasQuux() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasQuux() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getQuux() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getQuux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setQuux( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initQuux(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptQuux( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownQuux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasGarply() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasGarply() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasBaz() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasBaz() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getBaz() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getBaz() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setBaz( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initBaz(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptBaz( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownBaz() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline typename TestUnion::Union0::Reader TestUnion::Reader::getUnion0() const { + return typename TestUnion::Union0::Reader(_reader); +} +inline typename TestUnion::Union0::Builder TestUnion::Builder::getUnion0() { + return typename TestUnion::Union0::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestUnion::Union0::Pipeline TestUnion::Pipeline::getUnion0() { + return typename TestUnion::Union0::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestUnion::Union0::Builder TestUnion::Builder::initUnion0() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + return typename TestUnion::Union0::Builder(_builder); +} +inline typename TestUnion::Union1::Reader TestUnion::Reader::getUnion1() const { + return typename TestUnion::Union1::Reader(_reader); +} +inline typename TestUnion::Union1::Builder TestUnion::Builder::getUnion1() { + return typename TestUnion::Union1::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestUnion::Union1::Pipeline TestUnion::Pipeline::getUnion1() { + return typename TestUnion::Union1::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestUnion::Union1::Builder TestUnion::Builder::initUnion1() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField(::capnp::bounded<129>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(::capnp::bounded<17>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<9>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<3>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); + return typename TestUnion::Union1::Builder(_builder); +} +inline typename TestUnion::Union2::Reader TestUnion::Reader::getUnion2() const { + return typename TestUnion::Union2::Reader(_reader); +} +inline typename TestUnion::Union2::Builder TestUnion::Builder::getUnion2() { + return typename TestUnion::Union2::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestUnion::Union2::Pipeline TestUnion::Pipeline::getUnion2() { + return typename TestUnion::Union2::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestUnion::Union2::Builder TestUnion::Builder::initUnion2() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + _builder.setDataField(::capnp::bounded<256>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(::capnp::bounded<33>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<18>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<10>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0); + return typename TestUnion::Union2::Builder(_builder); +} +inline typename TestUnion::Union3::Reader TestUnion::Reader::getUnion3() const { + return typename TestUnion::Union3::Reader(_reader); +} +inline typename TestUnion::Union3::Builder TestUnion::Builder::getUnion3() { + return typename TestUnion::Union3::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestUnion::Union3::Pipeline TestUnion::Pipeline::getUnion3() { + return typename TestUnion::Union3::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestUnion::Union3::Builder TestUnion::Builder::initUnion3() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<3>() * ::capnp::ELEMENTS, 0); + _builder.setDataField(::capnp::bounded<257>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(::capnp::bounded<34>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<19>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<11>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<7>() * ::capnp::ELEMENTS, 0); + return typename TestUnion::Union3::Builder(_builder); +} +inline bool TestUnion::Reader::getBit0() const { + return _reader.getDataField( + ::capnp::bounded<128>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit0() { + return _builder.getDataField( + ::capnp::bounded<128>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit0(bool value) { + _builder.setDataField( + ::capnp::bounded<128>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit2() const { + return _reader.getDataField( + ::capnp::bounded<130>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit2() { + return _builder.getDataField( + ::capnp::bounded<130>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit2(bool value) { + _builder.setDataField( + ::capnp::bounded<130>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit3() const { + return _reader.getDataField( + ::capnp::bounded<131>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit3() { + return _builder.getDataField( + ::capnp::bounded<131>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit3(bool value) { + _builder.setDataField( + ::capnp::bounded<131>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit4() const { + return _reader.getDataField( + ::capnp::bounded<132>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit4() { + return _builder.getDataField( + ::capnp::bounded<132>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit4(bool value) { + _builder.setDataField( + ::capnp::bounded<132>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit5() const { + return _reader.getDataField( + ::capnp::bounded<133>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit5() { + return _builder.getDataField( + ::capnp::bounded<133>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit5(bool value) { + _builder.setDataField( + ::capnp::bounded<133>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit6() const { + return _reader.getDataField( + ::capnp::bounded<134>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit6() { + return _builder.getDataField( + ::capnp::bounded<134>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit6(bool value) { + _builder.setDataField( + ::capnp::bounded<134>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::getBit7() const { + return _reader.getDataField( + ::capnp::bounded<135>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit7() { + return _builder.getDataField( + ::capnp::bounded<135>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit7(bool value) { + _builder.setDataField( + ::capnp::bounded<135>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t TestUnion::Reader::getByte0() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<35>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestUnion::Builder::getByte0() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<35>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setByte0( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<35>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestUnion::Union0::Which TestUnion::Union0::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnion::Union0::Which TestUnion::Union0::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Reader::isU0f0s0() const { + return which() == TestUnion::Union0::U0F0S0; +} +inline bool TestUnion::Union0::Builder::isU0f0s0() { + return which() == TestUnion::Union0::U0F0S0; +} +inline ::capnp::Void TestUnion::Union0::Reader::getU0f0s0() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S0), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union0::Builder::getU0f0s0() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S0), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s0( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S0); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s1() const { + return which() == TestUnion::Union0::U0F0S1; +} +inline bool TestUnion::Union0::Builder::isU0f0s1() { + return which() == TestUnion::Union0::U0F0S1; +} +inline bool TestUnion::Union0::Reader::getU0f0s1() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::getU0f0s1() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s1(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S1); + _builder.setDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s8() const { + return which() == TestUnion::Union0::U0F0S8; +} +inline bool TestUnion::Union0::Builder::isU0f0s8() { + return which() == TestUnion::Union0::U0F0S8; +} +inline ::int8_t TestUnion::Union0::Reader::getU0f0s8() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union0::Builder::getU0f0s8() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s16() const { + return which() == TestUnion::Union0::U0F0S16; +} +inline bool TestUnion::Union0::Builder::isU0f0s16() { + return which() == TestUnion::Union0::U0F0S16; +} +inline ::int16_t TestUnion::Union0::Reader::getU0f0s16() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union0::Builder::getU0f0s16() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s32() const { + return which() == TestUnion::Union0::U0F0S32; +} +inline bool TestUnion::Union0::Builder::isU0f0s32() { + return which() == TestUnion::Union0::U0F0S32; +} +inline ::int32_t TestUnion::Union0::Reader::getU0f0s32() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union0::Builder::getU0f0s32() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s64() const { + return which() == TestUnion::Union0::U0F0S64; +} +inline bool TestUnion::Union0::Builder::isU0f0s64() { + return which() == TestUnion::Union0::U0F0S64; +} +inline ::int64_t TestUnion::Union0::Reader::getU0f0s64() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union0::Builder::getU0f0s64() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0sp() const { + return which() == TestUnion::Union0::U0F0SP; +} +inline bool TestUnion::Union0::Builder::isU0f0sp() { + return which() == TestUnion::Union0::U0F0SP; +} +inline bool TestUnion::Union0::Reader::hasU0f0sp() const { + if (which() != TestUnion::Union0::U0F0SP) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union0::Builder::hasU0f0sp() { + if (which() != TestUnion::Union0::U0F0SP) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union0::Reader::getU0f0sp() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::getU0f0sp() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestUnion::Union0::Builder::setU0f0sp( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::initU0f0sp(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestUnion::Union0::Builder::adoptU0f0sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union0::Builder::disownU0f0sp() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union0::Reader::isU0f1s0() const { + return which() == TestUnion::Union0::U0F1S0; +} +inline bool TestUnion::Union0::Builder::isU0f1s0() { + return which() == TestUnion::Union0::U0F1S0; +} +inline ::capnp::Void TestUnion::Union0::Reader::getU0f1s0() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S0), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union0::Builder::getU0f1s0() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S0), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s0( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S0); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s1() const { + return which() == TestUnion::Union0::U0F1S1; +} +inline bool TestUnion::Union0::Builder::isU0f1s1() { + return which() == TestUnion::Union0::U0F1S1; +} +inline bool TestUnion::Union0::Reader::getU0f1s1() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::getU0f1s1() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s1(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S1); + _builder.setDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s8() const { + return which() == TestUnion::Union0::U0F1S8; +} +inline bool TestUnion::Union0::Builder::isU0f1s8() { + return which() == TestUnion::Union0::U0F1S8; +} +inline ::int8_t TestUnion::Union0::Reader::getU0f1s8() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union0::Builder::getU0f1s8() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<8>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s16() const { + return which() == TestUnion::Union0::U0F1S16; +} +inline bool TestUnion::Union0::Builder::isU0f1s16() { + return which() == TestUnion::Union0::U0F1S16; +} +inline ::int16_t TestUnion::Union0::Reader::getU0f1s16() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union0::Builder::getU0f1s16() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s32() const { + return which() == TestUnion::Union0::U0F1S32; +} +inline bool TestUnion::Union0::Builder::isU0f1s32() { + return which() == TestUnion::Union0::U0F1S32; +} +inline ::int32_t TestUnion::Union0::Reader::getU0f1s32() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union0::Builder::getU0f1s32() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s64() const { + return which() == TestUnion::Union0::U0F1S64; +} +inline bool TestUnion::Union0::Builder::isU0f1s64() { + return which() == TestUnion::Union0::U0F1S64; +} +inline ::int64_t TestUnion::Union0::Reader::getU0f1s64() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union0::Builder::getU0f1s64() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1sp() const { + return which() == TestUnion::Union0::U0F1SP; +} +inline bool TestUnion::Union0::Builder::isU0f1sp() { + return which() == TestUnion::Union0::U0F1SP; +} +inline bool TestUnion::Union0::Reader::hasU0f1sp() const { + if (which() != TestUnion::Union0::U0F1SP) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union0::Builder::hasU0f1sp() { + if (which() != TestUnion::Union0::U0F1SP) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union0::Reader::getU0f1sp() const { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::getU0f1sp() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestUnion::Union0::Builder::setU0f1sp( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::initU0f1sp(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestUnion::Union0::Builder::adoptU0f1sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union0::Builder::disownU0f1sp() { + KJ_IREQUIRE((which() == TestUnion::Union0::U0F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestUnion::Union1::Which TestUnion::Union1::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnion::Union1::Which TestUnion::Union1::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Reader::isU1f0s0() const { + return which() == TestUnion::Union1::U1F0S0; +} +inline bool TestUnion::Union1::Builder::isU1f0s0() { + return which() == TestUnion::Union1::U1F0S0; +} +inline ::capnp::Void TestUnion::Union1::Reader::getU1f0s0() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S0), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union1::Builder::getU1f0s0() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S0), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s0( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S0); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s1() const { + return which() == TestUnion::Union1::U1F0S1; +} +inline bool TestUnion::Union1::Builder::isU1f0s1() { + return which() == TestUnion::Union1::U1F0S1; +} +inline bool TestUnion::Union1::Reader::getU1f0s1() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f0s1() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s1(bool value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S1); + _builder.setDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s1() const { + return which() == TestUnion::Union1::U1F1S1; +} +inline bool TestUnion::Union1::Builder::isU1f1s1() { + return which() == TestUnion::Union1::U1F1S1; +} +inline bool TestUnion::Union1::Reader::getU1f1s1() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f1s1() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s1(bool value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S1); + _builder.setDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s8() const { + return which() == TestUnion::Union1::U1F0S8; +} +inline bool TestUnion::Union1::Builder::isU1f0s8() { + return which() == TestUnion::Union1::U1F0S8; +} +inline ::int8_t TestUnion::Union1::Reader::getU1f0s8() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f0s8() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s8() const { + return which() == TestUnion::Union1::U1F1S8; +} +inline bool TestUnion::Union1::Builder::isU1f1s8() { + return which() == TestUnion::Union1::U1F1S8; +} +inline ::int8_t TestUnion::Union1::Reader::getU1f1s8() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f1s8() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s16() const { + return which() == TestUnion::Union1::U1F0S16; +} +inline bool TestUnion::Union1::Builder::isU1f0s16() { + return which() == TestUnion::Union1::U1F0S16; +} +inline ::int16_t TestUnion::Union1::Reader::getU1f0s16() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f0s16() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s16() const { + return which() == TestUnion::Union1::U1F1S16; +} +inline bool TestUnion::Union1::Builder::isU1f1s16() { + return which() == TestUnion::Union1::U1F1S16; +} +inline ::int16_t TestUnion::Union1::Reader::getU1f1s16() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f1s16() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s32() const { + return which() == TestUnion::Union1::U1F0S32; +} +inline bool TestUnion::Union1::Builder::isU1f0s32() { + return which() == TestUnion::Union1::U1F0S32; +} +inline ::int32_t TestUnion::Union1::Reader::getU1f0s32() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f0s32() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s32() const { + return which() == TestUnion::Union1::U1F1S32; +} +inline bool TestUnion::Union1::Builder::isU1f1s32() { + return which() == TestUnion::Union1::U1F1S32; +} +inline ::int32_t TestUnion::Union1::Reader::getU1f1s32() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f1s32() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s64() const { + return which() == TestUnion::Union1::U1F0S64; +} +inline bool TestUnion::Union1::Builder::isU1f0s64() { + return which() == TestUnion::Union1::U1F0S64; +} +inline ::int64_t TestUnion::Union1::Reader::getU1f0s64() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f0s64() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s64() const { + return which() == TestUnion::Union1::U1F1S64; +} +inline bool TestUnion::Union1::Builder::isU1f1s64() { + return which() == TestUnion::Union1::U1F1S64; +} +inline ::int64_t TestUnion::Union1::Reader::getU1f1s64() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f1s64() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0sp() const { + return which() == TestUnion::Union1::U1F0SP; +} +inline bool TestUnion::Union1::Builder::isU1f0sp() { + return which() == TestUnion::Union1::U1F0SP; +} +inline bool TestUnion::Union1::Reader::hasU1f0sp() const { + if (which() != TestUnion::Union1::U1F0SP) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f0sp() { + if (which() != TestUnion::Union1::U1F0SP) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f0sp() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f0sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f0sp( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f0sp(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f0sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f0sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F0SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union1::Reader::isU1f1sp() const { + return which() == TestUnion::Union1::U1F1SP; +} +inline bool TestUnion::Union1::Builder::isU1f1sp() { + return which() == TestUnion::Union1::U1F1SP; +} +inline bool TestUnion::Union1::Reader::hasU1f1sp() const { + if (which() != TestUnion::Union1::U1F1SP) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f1sp() { + if (which() != TestUnion::Union1::U1F1SP) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f1sp() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f1sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f1sp( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f1sp(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f1sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f1sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F1SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union1::Reader::isU1f2s0() const { + return which() == TestUnion::Union1::U1F2S0; +} +inline bool TestUnion::Union1::Builder::isU1f2s0() { + return which() == TestUnion::Union1::U1F2S0; +} +inline ::capnp::Void TestUnion::Union1::Reader::getU1f2s0() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S0), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union1::Builder::getU1f2s0() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S0), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s0( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S0); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s1() const { + return which() == TestUnion::Union1::U1F2S1; +} +inline bool TestUnion::Union1::Builder::isU1f2s1() { + return which() == TestUnion::Union1::U1F2S1; +} +inline bool TestUnion::Union1::Reader::getU1f2s1() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f2s1() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s1(bool value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S1); + _builder.setDataField( + ::capnp::bounded<129>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s8() const { + return which() == TestUnion::Union1::U1F2S8; +} +inline bool TestUnion::Union1::Builder::isU1f2s8() { + return which() == TestUnion::Union1::U1F2S8; +} +inline ::int8_t TestUnion::Union1::Reader::getU1f2s8() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f2s8() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<17>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s16() const { + return which() == TestUnion::Union1::U1F2S16; +} +inline bool TestUnion::Union1::Builder::isU1f2s16() { + return which() == TestUnion::Union1::U1F2S16; +} +inline ::int16_t TestUnion::Union1::Reader::getU1f2s16() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f2s16() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<9>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s32() const { + return which() == TestUnion::Union1::U1F2S32; +} +inline bool TestUnion::Union1::Builder::isU1f2s32() { + return which() == TestUnion::Union1::U1F2S32; +} +inline ::int32_t TestUnion::Union1::Reader::getU1f2s32() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f2s32() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s64() const { + return which() == TestUnion::Union1::U1F2S64; +} +inline bool TestUnion::Union1::Builder::isU1f2s64() { + return which() == TestUnion::Union1::U1F2S64; +} +inline ::int64_t TestUnion::Union1::Reader::getU1f2s64() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f2s64() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2sp() const { + return which() == TestUnion::Union1::U1F2SP; +} +inline bool TestUnion::Union1::Builder::isU1f2sp() { + return which() == TestUnion::Union1::U1F2SP; +} +inline bool TestUnion::Union1::Reader::hasU1f2sp() const { + if (which() != TestUnion::Union1::U1F2SP) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f2sp() { + if (which() != TestUnion::Union1::U1F2SP) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f2sp() const { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f2sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f2sp( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f2sp(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f2sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f2sp() { + KJ_IREQUIRE((which() == TestUnion::Union1::U1F2SP), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestUnion::Union2::Which TestUnion::Union2::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnion::Union2::Which TestUnion::Union2::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Reader::isU2f0s1() const { + return which() == TestUnion::Union2::U2F0S1; +} +inline bool TestUnion::Union2::Builder::isU2f0s1() { + return which() == TestUnion::Union2::U2F0S1; +} +inline bool TestUnion::Union2::Reader::getU2f0s1() const { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<256>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::getU2f0s1() { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<256>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s1(bool value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S1); + _builder.setDataField( + ::capnp::bounded<256>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s8() const { + return which() == TestUnion::Union2::U2F0S8; +} +inline bool TestUnion::Union2::Builder::isU2f0s8() { + return which() == TestUnion::Union2::U2F0S8; +} +inline ::int8_t TestUnion::Union2::Reader::getU2f0s8() const { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<33>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union2::Builder::getU2f0s8() { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<33>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<33>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s16() const { + return which() == TestUnion::Union2::U2F0S16; +} +inline bool TestUnion::Union2::Builder::isU2f0s16() { + return which() == TestUnion::Union2::U2F0S16; +} +inline ::int16_t TestUnion::Union2::Reader::getU2f0s16() const { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union2::Builder::getU2f0s16() { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<18>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s32() const { + return which() == TestUnion::Union2::U2F0S32; +} +inline bool TestUnion::Union2::Builder::isU2f0s32() { + return which() == TestUnion::Union2::U2F0S32; +} +inline ::int32_t TestUnion::Union2::Reader::getU2f0s32() const { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union2::Builder::getU2f0s32() { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<10>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s64() const { + return which() == TestUnion::Union2::U2F0S64; +} +inline bool TestUnion::Union2::Builder::isU2f0s64() { + return which() == TestUnion::Union2::U2F0S64; +} +inline ::int64_t TestUnion::Union2::Reader::getU2f0s64() const { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union2::Builder::getU2f0s64() { + KJ_IREQUIRE((which() == TestUnion::Union2::U2F0S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestUnion::Union3::Which TestUnion::Union3::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnion::Union3::Which TestUnion::Union3::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Reader::isU3f0s1() const { + return which() == TestUnion::Union3::U3F0S1; +} +inline bool TestUnion::Union3::Builder::isU3f0s1() { + return which() == TestUnion::Union3::U3F0S1; +} +inline bool TestUnion::Union3::Reader::getU3f0s1() const { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S1), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<257>() * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::getU3f0s1() { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S1), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<257>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s1(bool value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S1); + _builder.setDataField( + ::capnp::bounded<257>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s8() const { + return which() == TestUnion::Union3::U3F0S8; +} +inline bool TestUnion::Union3::Builder::isU3f0s8() { + return which() == TestUnion::Union3::U3F0S8; +} +inline ::int8_t TestUnion::Union3::Reader::getU3f0s8() const { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<34>() * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union3::Builder::getU3f0s8() { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<34>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s8( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S8); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<34>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s16() const { + return which() == TestUnion::Union3::U3F0S16; +} +inline bool TestUnion::Union3::Builder::isU3f0s16() { + return which() == TestUnion::Union3::U3F0S16; +} +inline ::int16_t TestUnion::Union3::Reader::getU3f0s16() const { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<19>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union3::Builder::getU3f0s16() { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<19>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s16( ::int16_t value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S16); + _builder.setDataField< ::int16_t>( + ::capnp::bounded<19>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s32() const { + return which() == TestUnion::Union3::U3F0S32; +} +inline bool TestUnion::Union3::Builder::isU3f0s32() { + return which() == TestUnion::Union3::U3F0S32; +} +inline ::int32_t TestUnion::Union3::Reader::getU3f0s32() const { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union3::Builder::getU3f0s32() { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s32( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S32); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<11>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s64() const { + return which() == TestUnion::Union3::U3F0S64; +} +inline bool TestUnion::Union3::Builder::isU3f0s64() { + return which() == TestUnion::Union3::U3F0S64; +} +inline ::int64_t TestUnion::Union3::Reader::getU3f0s64() const { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<7>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union3::Builder::getU3f0s64() { + KJ_IREQUIRE((which() == TestUnion::Union3::U3F0S64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<7>() * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s64( ::int64_t value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S64); + _builder.setDataField< ::int64_t>( + ::capnp::bounded<7>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Which TestUnnamedUnion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Which TestUnnamedUnion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline bool TestUnnamedUnion::Reader::hasBefore() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnnamedUnion::Builder::hasBefore() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnnamedUnion::Reader::getBefore() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::getBefore() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestUnnamedUnion::Builder::setBefore( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::initBefore(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestUnnamedUnion::Builder::adoptBefore( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnnamedUnion::Builder::disownBefore() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestUnnamedUnion::Reader::isFoo() const { + return which() == TestUnnamedUnion::FOO; +} +inline bool TestUnnamedUnion::Builder::isFoo() { + return which() == TestUnnamedUnion::FOO; +} +inline ::uint16_t TestUnnamedUnion::Reader::getFoo() const { + KJ_IREQUIRE((which() == TestUnnamedUnion::FOO), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestUnnamedUnion::Builder::getFoo() { + KJ_IREQUIRE((which() == TestUnnamedUnion::FOO), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setFoo( ::uint16_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnnamedUnion::FOO); + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TestUnnamedUnion::Reader::getMiddle() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestUnnamedUnion::Builder::getMiddle() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setMiddle( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnnamedUnion::Reader::isBar() const { + return which() == TestUnnamedUnion::BAR; +} +inline bool TestUnnamedUnion::Builder::isBar() { + return which() == TestUnnamedUnion::BAR; +} +inline ::uint32_t TestUnnamedUnion::Reader::getBar() const { + KJ_IREQUIRE((which() == TestUnnamedUnion::BAR), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestUnnamedUnion::Builder::getBar() { + KJ_IREQUIRE((which() == TestUnnamedUnion::BAR), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setBar( ::uint32_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnnamedUnion::BAR); + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnnamedUnion::Reader::hasAfter() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnnamedUnion::Builder::hasAfter() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnnamedUnion::Reader::getAfter() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::getAfter() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUnnamedUnion::Builder::setAfter( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::initAfter(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestUnnamedUnion::Builder::adoptAfter( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnnamedUnion::Builder::disownAfter() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline typename TestUnionInUnion::Outer::Reader TestUnionInUnion::Reader::getOuter() const { + return typename TestUnionInUnion::Outer::Reader(_reader); +} +inline typename TestUnionInUnion::Outer::Builder TestUnionInUnion::Builder::getOuter() { + return typename TestUnionInUnion::Outer::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestUnionInUnion::Outer::Pipeline TestUnionInUnion::Pipeline::getOuter() { + return typename TestUnionInUnion::Outer::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestUnionInUnion::Outer::Builder TestUnionInUnion::Builder::initOuter() { + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0); + return typename TestUnionInUnion::Outer::Builder(_builder); +} +inline ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Which TestUnionInUnion::Outer::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Which TestUnionInUnion::Outer::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Reader::isInner() const { + return which() == TestUnionInUnion::Outer::INNER; +} +inline bool TestUnionInUnion::Outer::Builder::isInner() { + return which() == TestUnionInUnion::Outer::INNER; +} +inline typename TestUnionInUnion::Outer::Inner::Reader TestUnionInUnion::Outer::Reader::getInner() const { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::INNER), + "Must check which() before get()ing a union member."); + return typename TestUnionInUnion::Outer::Inner::Reader(_reader); +} +inline typename TestUnionInUnion::Outer::Inner::Builder TestUnionInUnion::Outer::Builder::getInner() { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::INNER), + "Must check which() before get()ing a union member."); + return typename TestUnionInUnion::Outer::Inner::Builder(_builder); +} +inline typename TestUnionInUnion::Outer::Inner::Builder TestUnionInUnion::Outer::Builder::initInner() { + _builder.setDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, TestUnionInUnion::Outer::INNER); + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + return typename TestUnionInUnion::Outer::Inner::Builder(_builder); +} +inline bool TestUnionInUnion::Outer::Reader::isBaz() const { + return which() == TestUnionInUnion::Outer::BAZ; +} +inline bool TestUnionInUnion::Outer::Builder::isBaz() { + return which() == TestUnionInUnion::Outer::BAZ; +} +inline ::int32_t TestUnionInUnion::Outer::Reader::getBaz() const { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::BAZ), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Builder::getBaz() { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::BAZ), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Builder::setBaz( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, TestUnionInUnion::Outer::BAZ); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Inner::Which TestUnionInUnion::Outer::Inner::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Inner::Which TestUnionInUnion::Outer::Inner::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Inner::Reader::isFoo() const { + return which() == TestUnionInUnion::Outer::Inner::FOO; +} +inline bool TestUnionInUnion::Outer::Inner::Builder::isFoo() { + return which() == TestUnionInUnion::Outer::Inner::FOO; +} +inline ::int32_t TestUnionInUnion::Outer::Inner::Reader::getFoo() const { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::Inner::FOO), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Inner::Builder::getFoo() { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::Inner::FOO), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Inner::Builder::setFoo( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnionInUnion::Outer::Inner::FOO); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestUnionInUnion::Outer::Inner::Reader::isBar() const { + return which() == TestUnionInUnion::Outer::Inner::BAR; +} +inline bool TestUnionInUnion::Outer::Inner::Builder::isBar() { + return which() == TestUnionInUnion::Outer::Inner::BAR; +} +inline ::int32_t TestUnionInUnion::Outer::Inner::Reader::getBar() const { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::Inner::BAR), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Inner::Builder::getBar() { + KJ_IREQUIRE((which() == TestUnionInUnion::Outer::Inner::BAR), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Inner::Builder::setBar( ::int32_t value) { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestUnionInUnion::Outer::Inner::BAR); + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline typename TestGroups::Groups::Reader TestGroups::Reader::getGroups() const { + return typename TestGroups::Groups::Reader(_reader); +} +inline typename TestGroups::Groups::Builder TestGroups::Builder::getGroups() { + return typename TestGroups::Groups::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestGroups::Groups::Pipeline TestGroups::Pipeline::getGroups() { + return typename TestGroups::Groups::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestGroups::Groups::Builder TestGroups::Builder::initGroups() { + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); + return typename TestGroups::Groups::Builder(_builder); +} +inline ::capnproto_test::capnp::test::TestGroups::Groups::Which TestGroups::Groups::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestGroups::Groups::Which TestGroups::Groups::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Reader::isFoo() const { + return which() == TestGroups::Groups::FOO; +} +inline bool TestGroups::Groups::Builder::isFoo() { + return which() == TestGroups::Groups::FOO; +} +inline typename TestGroups::Groups::Foo::Reader TestGroups::Groups::Reader::getFoo() const { + KJ_IREQUIRE((which() == TestGroups::Groups::FOO), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Foo::Reader(_reader); +} +inline typename TestGroups::Groups::Foo::Builder TestGroups::Groups::Builder::getFoo() { + KJ_IREQUIRE((which() == TestGroups::Groups::FOO), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Foo::Builder(_builder); +} +inline typename TestGroups::Groups::Foo::Builder TestGroups::Groups::Builder::initFoo() { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestGroups::Groups::FOO); + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + return typename TestGroups::Groups::Foo::Builder(_builder); +} +inline bool TestGroups::Groups::Reader::isBaz() const { + return which() == TestGroups::Groups::BAZ; +} +inline bool TestGroups::Groups::Builder::isBaz() { + return which() == TestGroups::Groups::BAZ; +} +inline typename TestGroups::Groups::Baz::Reader TestGroups::Groups::Reader::getBaz() const { + KJ_IREQUIRE((which() == TestGroups::Groups::BAZ), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Baz::Reader(_reader); +} +inline typename TestGroups::Groups::Baz::Builder TestGroups::Groups::Builder::getBaz() { + KJ_IREQUIRE((which() == TestGroups::Groups::BAZ), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Baz::Builder(_builder); +} +inline typename TestGroups::Groups::Baz::Builder TestGroups::Groups::Builder::initBaz() { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestGroups::Groups::BAZ); + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); + return typename TestGroups::Groups::Baz::Builder(_builder); +} +inline bool TestGroups::Groups::Reader::isBar() const { + return which() == TestGroups::Groups::BAR; +} +inline bool TestGroups::Groups::Builder::isBar() { + return which() == TestGroups::Groups::BAR; +} +inline typename TestGroups::Groups::Bar::Reader TestGroups::Groups::Reader::getBar() const { + KJ_IREQUIRE((which() == TestGroups::Groups::BAR), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Bar::Reader(_reader); +} +inline typename TestGroups::Groups::Bar::Builder TestGroups::Groups::Builder::getBar() { + KJ_IREQUIRE((which() == TestGroups::Groups::BAR), + "Must check which() before get()ing a union member."); + return typename TestGroups::Groups::Bar::Builder(_builder); +} +inline typename TestGroups::Groups::Bar::Builder TestGroups::Groups::Builder::initBar() { + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, TestGroups::Groups::BAR); + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + return typename TestGroups::Groups::Bar::Builder(_builder); +} +inline ::int32_t TestGroups::Groups::Foo::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Foo::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Foo::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::int64_t TestGroups::Groups::Foo::Reader::getGrault() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestGroups::Groups::Foo::Builder::getGrault() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Foo::Builder::setGrault( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Foo::Reader::hasGarply() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Foo::Builder::hasGarply() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Foo::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Foo::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Foo::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Foo::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Foo::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Foo::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::int32_t TestGroups::Groups::Baz::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Baz::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Baz::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Baz::Reader::hasGrault() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Baz::Builder::hasGrault() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Baz::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Baz::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Baz::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Baz::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestGroups::Groups::Baz::Reader::hasGarply() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Baz::Builder::hasGarply() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Baz::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Baz::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Baz::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Baz::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::int32_t TestGroups::Groups::Bar::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Bar::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Bar::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Bar::Reader::hasGrault() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Bar::Builder::hasGrault() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Bar::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Bar::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Bar::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Bar::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Bar::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Bar::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::int64_t TestGroups::Groups::Bar::Reader::getGarply() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestGroups::Groups::Bar::Builder::getGarply() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Bar::Builder::setGarply( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline typename TestInterleavedGroups::Group1::Reader TestInterleavedGroups::Reader::getGroup1() const { + return typename TestInterleavedGroups::Group1::Reader(_reader); +} +inline typename TestInterleavedGroups::Group1::Builder TestInterleavedGroups::Builder::getGroup1() { + return typename TestInterleavedGroups::Group1::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestInterleavedGroups::Group1::Pipeline TestInterleavedGroups::Pipeline::getGroup1() { + return typename TestInterleavedGroups::Group1::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestInterleavedGroups::Group1::Builder TestInterleavedGroups::Builder::initGroup1() { + _builder.setDataField< ::uint32_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<12>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<14>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS).clear(); + return typename TestInterleavedGroups::Group1::Builder(_builder); +} +inline typename TestInterleavedGroups::Group2::Reader TestInterleavedGroups::Reader::getGroup2() const { + return typename TestInterleavedGroups::Group2::Reader(_reader); +} +inline typename TestInterleavedGroups::Group2::Builder TestInterleavedGroups::Builder::getGroup2() { + return typename TestInterleavedGroups::Group2::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestInterleavedGroups::Group2::Pipeline TestInterleavedGroups::Pipeline::getGroup2() { + return typename TestInterleavedGroups::Group2::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestInterleavedGroups::Group2::Builder TestInterleavedGroups::Builder::initGroup2() { + _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<13>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<15>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear(); + return typename TestInterleavedGroups::Group2::Builder(_builder); +} +inline ::capnproto_test::capnp::test::TestInterleavedGroups::Group1::Which TestInterleavedGroups::Group1::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestInterleavedGroups::Group1::Which TestInterleavedGroups::Group1::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group1::Reader::getFoo() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group1::Builder::getFoo() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setFoo( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Reader::getBar() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Builder::getBar() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setBar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Reader::isQux() const { + return which() == TestInterleavedGroups::Group1::QUX; +} +inline bool TestInterleavedGroups::Group1::Builder::isQux() { + return which() == TestInterleavedGroups::Group1::QUX; +} +inline ::uint16_t TestInterleavedGroups::Group1::Reader::getQux() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::QUX), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group1::Builder::getQux() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::QUX), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setQux( ::uint16_t value) { + _builder.setDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::QUX); + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Reader::isCorge() const { + return which() == TestInterleavedGroups::Group1::CORGE; +} +inline bool TestInterleavedGroups::Group1::Builder::isCorge() { + return which() == TestInterleavedGroups::Group1::CORGE; +} +inline typename TestInterleavedGroups::Group1::Corge::Reader TestInterleavedGroups::Group1::Reader::getCorge() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::CORGE), + "Must check which() before get()ing a union member."); + return typename TestInterleavedGroups::Group1::Corge::Reader(_reader); +} +inline typename TestInterleavedGroups::Group1::Corge::Builder TestInterleavedGroups::Group1::Builder::getCorge() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::CORGE), + "Must check which() before get()ing a union member."); + return typename TestInterleavedGroups::Group1::Corge::Builder(_builder); +} +inline typename TestInterleavedGroups::Group1::Corge::Builder TestInterleavedGroups::Group1::Builder::initCorge() { + _builder.setDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::CORGE); + _builder.setDataField< ::uint16_t>(::capnp::bounded<12>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS).clear(); + return typename TestInterleavedGroups::Group1::Corge::Builder(_builder); +} +inline bool TestInterleavedGroups::Group1::Reader::hasWaldo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Builder::hasWaldo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group1::Reader::isFred() const { + return which() == TestInterleavedGroups::Group1::FRED; +} +inline bool TestInterleavedGroups::Group1::Builder::isFred() { + return which() == TestInterleavedGroups::Group1::FRED; +} +inline bool TestInterleavedGroups::Group1::Reader::hasFred() const { + if (which() != TestInterleavedGroups::Group1::FRED) return false; + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Builder::hasFred() { + if (which() != TestInterleavedGroups::Group1::FRED) return false; + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Reader::getFred() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::getFred() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Builder::setFred( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::initFred(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Builder::adoptFred( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<14>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Builder::disownFred() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group1::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Corge::Reader::getGrault() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Corge::Builder::getGrault() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setGrault( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TestInterleavedGroups::Group1::Corge::Reader::getGarply() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group1::Corge::Builder::getGarply() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setGarply( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<12>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasPlugh() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasPlugh() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Corge::Reader::getPlugh() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::getPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setPlugh( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::initPlugh(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::adoptPlugh( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Corge::Builder::disownPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasXyzzy() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasXyzzy() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Corge::Reader::getXyzzy() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::getXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setXyzzy( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::initXyzzy(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::adoptXyzzy( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Corge::Builder::disownXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestInterleavedGroups::Group2::Which TestInterleavedGroups::Group2::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestInterleavedGroups::Group2::Which TestInterleavedGroups::Group2::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group2::Reader::getFoo() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group2::Builder::getFoo() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setFoo( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Reader::getBar() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Builder::getBar() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setBar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Reader::isQux() const { + return which() == TestInterleavedGroups::Group2::QUX; +} +inline bool TestInterleavedGroups::Group2::Builder::isQux() { + return which() == TestInterleavedGroups::Group2::QUX; +} +inline ::uint16_t TestInterleavedGroups::Group2::Reader::getQux() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::QUX), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group2::Builder::getQux() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::QUX), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setQux( ::uint16_t value) { + _builder.setDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::QUX); + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Reader::isCorge() const { + return which() == TestInterleavedGroups::Group2::CORGE; +} +inline bool TestInterleavedGroups::Group2::Builder::isCorge() { + return which() == TestInterleavedGroups::Group2::CORGE; +} +inline typename TestInterleavedGroups::Group2::Corge::Reader TestInterleavedGroups::Group2::Reader::getCorge() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::CORGE), + "Must check which() before get()ing a union member."); + return typename TestInterleavedGroups::Group2::Corge::Reader(_reader); +} +inline typename TestInterleavedGroups::Group2::Corge::Builder TestInterleavedGroups::Group2::Builder::getCorge() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::CORGE), + "Must check which() before get()ing a union member."); + return typename TestInterleavedGroups::Group2::Corge::Builder(_builder); +} +inline typename TestInterleavedGroups::Group2::Corge::Builder TestInterleavedGroups::Group2::Builder::initCorge() { + _builder.setDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::CORGE); + _builder.setDataField< ::uint16_t>(::capnp::bounded<13>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear(); + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear(); + return typename TestInterleavedGroups::Group2::Corge::Builder(_builder); +} +inline bool TestInterleavedGroups::Group2::Reader::hasWaldo() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Builder::hasWaldo() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group2::Reader::isFred() const { + return which() == TestInterleavedGroups::Group2::FRED; +} +inline bool TestInterleavedGroups::Group2::Builder::isFred() { + return which() == TestInterleavedGroups::Group2::FRED; +} +inline bool TestInterleavedGroups::Group2::Reader::hasFred() const { + if (which() != TestInterleavedGroups::Group2::FRED) return false; + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Builder::hasFred() { + if (which() != TestInterleavedGroups::Group2::FRED) return false; + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Reader::getFred() const { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::getFred() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Builder::setFred( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::initFred(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Builder::adoptFred( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<15>() * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Builder::disownFred() { + KJ_IREQUIRE((which() == TestInterleavedGroups::Group2::FRED), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Corge::Reader::getGrault() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Corge::Builder::getGrault() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setGrault( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TestInterleavedGroups::Group2::Corge::Reader::getGarply() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group2::Corge::Builder::getGarply() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setGarply( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<13>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasPlugh() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasPlugh() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Corge::Reader::getPlugh() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::getPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setPlugh( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::initPlugh(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::adoptPlugh( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Corge::Builder::disownPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasXyzzy() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasXyzzy() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Corge::Reader::getXyzzy() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::getXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setXyzzy( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::initXyzzy(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::adoptXyzzy( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Corge::Builder::disownXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasS16s8s64s8Set() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasS16s8s64s8Set() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnion::Reader TestUnionDefaults::Reader::getS16s8s64s8Set() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 54); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::getS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 54); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestUnion::Pipeline TestUnionDefaults::Pipeline::getS16s8s64s8Set() { + return ::capnproto_test::capnp::test::TestUnion::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestUnionDefaults::Builder::setS16s8s64s8Set( ::capnproto_test::capnp::test::TestUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::initS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptS16s8s64s8Set( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> TestUnionDefaults::Builder::disownS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasS0sps1s32Set() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasS0sps1s32Set() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnion::Reader TestUnionDefaults::Reader::getS0sps1s32Set() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 73); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::getS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 73); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestUnion::Pipeline TestUnionDefaults::Pipeline::getS0sps1s32Set() { + return ::capnproto_test::capnp::test::TestUnion::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestUnionDefaults::Builder::setS0sps1s32Set( ::capnproto_test::capnp::test::TestUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::initS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptS0sps1s32Set( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> TestUnionDefaults::Builder::disownS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasUnnamed1() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasUnnamed1() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader TestUnionDefaults::Reader::getUnnamed1() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 93); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::getUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 93); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline TestUnionDefaults::Pipeline::getUnnamed1() { + return ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void TestUnionDefaults::Builder::setUnnamed1( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::initUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptUnnamed1( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> TestUnionDefaults::Builder::disownUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasUnnamed2() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasUnnamed2() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader TestUnionDefaults::Reader::getUnnamed2() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 106); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::getUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), + ::capnp::schemas::bp_94f7e0b103b4b718 + 106); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline TestUnionDefaults::Pipeline::getUnnamed2() { + return ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void TestUnionDefaults::Builder::setUnnamed2( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::initUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptUnnamed2( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> TestUnionDefaults::Builder::disownUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestNestedTypes::Reader::hasNestedStruct() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestNestedTypes::Builder::hasNestedStruct() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader TestNestedTypes::Reader::getNestedStruct() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder TestNestedTypes::Builder::getNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline TestNestedTypes::Pipeline::getNestedStruct() { + return ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestNestedTypes::Builder::setNestedStruct( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder TestNestedTypes::Builder::initNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestNestedTypes::Builder::adoptNestedStruct( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct> TestNestedTypes::Builder::disownNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1u); +} +inline void TestNestedTypes::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 2u); +} +inline void TestNestedTypes::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::NestedStruct::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::NestedStruct::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1u); +} +inline void TestNestedTypes::NestedStruct::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::NestedStruct::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::NestedStruct::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 2u); +} +inline void TestNestedTypes::NestedStruct::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestUsing::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestUsing::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 2u); +} +inline void TestUsing::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestUsing::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestUsing::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 1u); +} +inline void TestUsing::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 1u); +} + +inline bool TestLists::Reader::hasList0() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList0() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList0() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList0() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList0( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList0(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList0( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList0() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList1() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList1() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList1() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList1() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList1( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList1(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList1( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList1() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList8() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList8() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList8() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList8( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList8(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList8( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList16() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList16() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList16() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList16( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList16(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList16( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList32() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList32() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList32() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList32( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList32(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList32( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList64() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList64() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getList64() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getList64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList64( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initList64(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList64( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>> TestLists::Builder::disownList64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasListP() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasListP() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Reader TestLists::Reader::getListP() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::getListP() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setListP( ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>::Builder TestLists::Builder::initListP(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptListP( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>> TestLists::Builder::disownListP() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasInt32ListList() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasInt32ListList() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader TestLists::Reader::getInt32ListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder TestLists::Builder::getInt32ListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setInt32ListList( ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setInt32ListList(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder TestLists::Builder::initInt32ListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptInt32ListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> TestLists::Builder::disownInt32ListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasTextListList() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasTextListList() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader TestLists::Reader::getTextListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder TestLists::Builder::getTextListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setTextListList( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setTextListList(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder TestLists::Builder::initTextListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptTextListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> TestLists::Builder::disownTextListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasStructListList() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasStructListList() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader TestLists::Reader::getStructListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder TestLists::Builder::getStructListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setStructListList( ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setStructListList(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>::Builder TestLists::Builder::initStructListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptStructListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>> TestLists::Builder::disownStructListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Kind::STRUCT>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline ::capnp::Void TestLists::Struct0::Reader::getF() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestLists::Struct0::Builder::getF() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct0::Builder::setF( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct1::Reader::getF() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1::Builder::getF() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct1::Builder::setF(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint8_t TestLists::Struct8::Reader::getF() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestLists::Struct8::Builder::getF() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct8::Builder::setF( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TestLists::Struct16::Reader::getF() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestLists::Struct16::Builder::getF() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct16::Builder::setF( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t TestLists::Struct32::Reader::getF() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestLists::Struct32::Builder::getF() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct32::Builder::setF( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t TestLists::Struct64::Reader::getF() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::Struct64::Builder::getF() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct64::Builder::setF( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::StructP::Reader::hasF() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::StructP::Builder::hasF() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::StructP::Reader::getF() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::StructP::Builder::getF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::StructP::Builder::setF( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::StructP::Builder::initF(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::StructP::Builder::adoptF( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::StructP::Builder::disownF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnp::Void TestLists::Struct0c::Reader::getF() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestLists::Struct0c::Builder::getF() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct0c::Builder::setF( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct0c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct0c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct0c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct0c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct0c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct0c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct0c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct0c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct1c::Reader::getF() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1c::Builder::getF() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct1c::Builder::setF(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct1c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct1c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct1c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct1c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct1c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct1c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct1c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct1c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint8_t TestLists::Struct8c::Reader::getF() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestLists::Struct8c::Builder::getF() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct8c::Builder::setF( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct8c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct8c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct8c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct8c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct8c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct8c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct8c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct8c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint16_t TestLists::Struct16c::Reader::getF() const { + return _reader.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestLists::Struct16c::Builder::getF() { + return _builder.getDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct16c::Builder::setF( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct16c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct16c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct16c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct16c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct16c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct16c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct16c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct16c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint32_t TestLists::Struct32c::Reader::getF() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestLists::Struct32c::Builder::getF() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct32c::Builder::setF( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct32c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct32c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct32c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct32c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct32c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct32c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct32c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct32c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint64_t TestLists::Struct64c::Reader::getF() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::Struct64c::Builder::getF() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::Struct64c::Builder::setF( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct64c::Reader::hasPad() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct64c::Builder::hasPad() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct64c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct64c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::Struct64c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct64c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::Struct64c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct64c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestLists::StructPc::Reader::hasF() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::StructPc::Builder::hasF() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::StructPc::Reader::getF() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::StructPc::Builder::getF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLists::StructPc::Builder::setF( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::StructPc::Builder::initF(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLists::StructPc::Builder::adoptF( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::StructPc::Builder::disownF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint64_t TestLists::StructPc::Reader::getPad() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::StructPc::Builder::getPad() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLists::StructPc::Builder::setPad( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestFieldZeroIsBit::Reader::getBit() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestFieldZeroIsBit::Builder::getBit() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestFieldZeroIsBit::Builder::setBit(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestFieldZeroIsBit::Reader::getSecondBit() const { + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, true); +} + +inline bool TestFieldZeroIsBit::Builder::getSecondBit() { + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, true); +} +inline void TestFieldZeroIsBit::Builder::setSecondBit(bool value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, true); +} + +inline ::uint8_t TestFieldZeroIsBit::Reader::getThirdField() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 123u); +} + +inline ::uint8_t TestFieldZeroIsBit::Builder::getThirdField() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 123u); +} +inline void TestFieldZeroIsBit::Builder::setThirdField( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 123u); +} + +inline bool TestListDefaults::Reader::hasLists() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestListDefaults::Builder::hasLists() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestLists::Reader TestListDefaults::Reader::getLists() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_a851ad32cbc2ffea + 32); +} +inline ::capnproto_test::capnp::test::TestLists::Builder TestListDefaults::Builder::getLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), + ::capnp::schemas::bp_a851ad32cbc2ffea + 32); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestLists::Pipeline TestListDefaults::Pipeline::getLists() { + return ::capnproto_test::capnp::test::TestLists::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestListDefaults::Builder::setLists( ::capnproto_test::capnp::test::TestLists::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestLists::Builder TestListDefaults::Builder::initLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestListDefaults::Builder::adoptLists( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists> TestListDefaults::Builder::disownLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::int32_t TestLateUnion::Reader::getFoo() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestLateUnion::Builder::getFoo() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestLateUnion::Builder::setFoo( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestLateUnion::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::Reader::getBar() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::Builder::getBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestLateUnion::Builder::setBar( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestLateUnion::Builder::adoptBar( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::Builder::disownBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::int16_t TestLateUnion::Reader::getBaz() const { + return _reader.getDataField< ::int16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::int16_t TestLateUnion::Builder::getBaz() { + return _builder.getDataField< ::int16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestLateUnion::Builder::setBaz( ::int16_t value) { + _builder.setDataField< ::int16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline typename TestLateUnion::TheUnion::Reader TestLateUnion::Reader::getTheUnion() const { + return typename TestLateUnion::TheUnion::Reader(_reader); +} +inline typename TestLateUnion::TheUnion::Builder TestLateUnion::Builder::getTheUnion() { + return typename TestLateUnion::TheUnion::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestLateUnion::TheUnion::Pipeline TestLateUnion::Pipeline::getTheUnion() { + return typename TestLateUnion::TheUnion::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestLateUnion::TheUnion::Builder TestLateUnion::Builder::initTheUnion() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<3>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); + return typename TestLateUnion::TheUnion::Builder(_builder); +} +inline typename TestLateUnion::AnotherUnion::Reader TestLateUnion::Reader::getAnotherUnion() const { + return typename TestLateUnion::AnotherUnion::Reader(_reader); +} +inline typename TestLateUnion::AnotherUnion::Builder TestLateUnion::Builder::getAnotherUnion() { + return typename TestLateUnion::AnotherUnion::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestLateUnion::AnotherUnion::Pipeline TestLateUnion::Pipeline::getAnotherUnion() { + return typename TestLateUnion::AnotherUnion::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestLateUnion::AnotherUnion::Builder TestLateUnion::Builder::initAnotherUnion() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS).clear(); + return typename TestLateUnion::AnotherUnion::Builder(_builder); +} +inline ::capnproto_test::capnp::test::TestLateUnion::TheUnion::Which TestLateUnion::TheUnion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestLateUnion::TheUnion::Which TestLateUnion::TheUnion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::TheUnion::Reader::isQux() const { + return which() == TestLateUnion::TheUnion::QUX; +} +inline bool TestLateUnion::TheUnion::Builder::isQux() { + return which() == TestLateUnion::TheUnion::QUX; +} +inline bool TestLateUnion::TheUnion::Reader::hasQux() const { + if (which() != TestLateUnion::TheUnion::QUX) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::TheUnion::Builder::hasQux() { + if (which() != TestLateUnion::TheUnion::QUX) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::TheUnion::Reader::getQux() const { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::TheUnion::Builder::getQux() { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestLateUnion::TheUnion::Builder::setQux( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::TheUnion::Builder::initQux(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestLateUnion::TheUnion::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::TheUnion::Builder::disownQux() { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::TheUnion::Reader::isCorge() const { + return which() == TestLateUnion::TheUnion::CORGE; +} +inline bool TestLateUnion::TheUnion::Builder::isCorge() { + return which() == TestLateUnion::TheUnion::CORGE; +} +inline bool TestLateUnion::TheUnion::Reader::hasCorge() const { + if (which() != TestLateUnion::TheUnion::CORGE) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::TheUnion::Builder::hasCorge() { + if (which() != TestLateUnion::TheUnion::CORGE) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader TestLateUnion::TheUnion::Reader::getCorge() const { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestLateUnion::TheUnion::Builder::getCorge() { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestLateUnion::TheUnion::Builder::setCorge( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void TestLateUnion::TheUnion::Builder::setCorge(::kj::ArrayPtr value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestLateUnion::TheUnion::Builder::initCorge(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestLateUnion::TheUnion::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> TestLateUnion::TheUnion::Builder::disownCorge() { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::TheUnion::Reader::isGrault() const { + return which() == TestLateUnion::TheUnion::GRAULT; +} +inline bool TestLateUnion::TheUnion::Builder::isGrault() { + return which() == TestLateUnion::TheUnion::GRAULT; +} +inline float TestLateUnion::TheUnion::Reader::getGrault() const { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::GRAULT), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline float TestLateUnion::TheUnion::Builder::getGrault() { + KJ_IREQUIRE((which() == TestLateUnion::TheUnion::GRAULT), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestLateUnion::TheUnion::Builder::setGrault(float value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, TestLateUnion::TheUnion::GRAULT); + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestLateUnion::AnotherUnion::Which TestLateUnion::AnotherUnion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestLateUnion::AnotherUnion::Which TestLateUnion::AnotherUnion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isQux() const { + return which() == TestLateUnion::AnotherUnion::QUX; +} +inline bool TestLateUnion::AnotherUnion::Builder::isQux() { + return which() == TestLateUnion::AnotherUnion::QUX; +} +inline bool TestLateUnion::AnotherUnion::Reader::hasQux() const { + if (which() != TestLateUnion::AnotherUnion::QUX) return false; + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::AnotherUnion::Builder::hasQux() { + if (which() != TestLateUnion::AnotherUnion::QUX) return false; + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::AnotherUnion::Reader::getQux() const { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::AnotherUnion::Builder::getQux() { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestLateUnion::AnotherUnion::Builder::setQux( ::capnp::Text::Reader value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::AnotherUnion::Builder::initQux(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestLateUnion::AnotherUnion::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::AnotherUnion::Builder::disownQux() { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isCorge() const { + return which() == TestLateUnion::AnotherUnion::CORGE; +} +inline bool TestLateUnion::AnotherUnion::Builder::isCorge() { + return which() == TestLateUnion::AnotherUnion::CORGE; +} +inline bool TestLateUnion::AnotherUnion::Reader::hasCorge() const { + if (which() != TestLateUnion::AnotherUnion::CORGE) return false; + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::AnotherUnion::Builder::hasCorge() { + if (which() != TestLateUnion::AnotherUnion::CORGE) return false; + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader TestLateUnion::AnotherUnion::Reader::getCorge() const { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestLateUnion::AnotherUnion::Builder::getCorge() { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestLateUnion::AnotherUnion::Builder::setCorge( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void TestLateUnion::AnotherUnion::Builder::setCorge(::kj::ArrayPtr value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder TestLateUnion::AnotherUnion::Builder::initCorge(unsigned int size) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestLateUnion::AnotherUnion::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> TestLateUnion::AnotherUnion::Builder::disownCorge() { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::CORGE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isGrault() const { + return which() == TestLateUnion::AnotherUnion::GRAULT; +} +inline bool TestLateUnion::AnotherUnion::Builder::isGrault() { + return which() == TestLateUnion::AnotherUnion::GRAULT; +} +inline float TestLateUnion::AnotherUnion::Reader::getGrault() const { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::GRAULT), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline float TestLateUnion::AnotherUnion::Builder::getGrault() { + KJ_IREQUIRE((which() == TestLateUnion::AnotherUnion::GRAULT), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline void TestLateUnion::AnotherUnion::Builder::setGrault(float value) { + _builder.setDataField( + ::capnp::bounded<6>() * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::GRAULT); + _builder.setDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); +} + +inline ::int64_t TestOldVersion::Reader::getOld1() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestOldVersion::Builder::getOld1() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestOldVersion::Builder::setOld1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestOldVersion::Reader::hasOld2() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOldVersion::Builder::hasOld2() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOldVersion::Reader::getOld2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOldVersion::Builder::getOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestOldVersion::Builder::setOld2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOldVersion::Builder::initOld2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestOldVersion::Builder::adoptOld2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOldVersion::Builder::disownOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestOldVersion::Reader::hasOld3() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestOldVersion::Builder::hasOld3() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Reader TestOldVersion::Reader::getOld3() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Builder TestOldVersion::Builder::getOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestOldVersion::Pipeline TestOldVersion::Pipeline::getOld3() { + return ::capnproto_test::capnp::test::TestOldVersion::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestOldVersion::Builder::setOld3( ::capnproto_test::capnp::test::TestOldVersion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Builder TestOldVersion::Builder::initOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestOldVersion::Builder::adoptOld3( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion> TestOldVersion::Builder::disownOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::int64_t TestNewVersion::Reader::getOld1() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int64_t TestNewVersion::Builder::getOld1() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestNewVersion::Builder::setOld1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestNewVersion::Reader::hasOld2() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasOld2() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestNewVersion::Reader::getOld2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::getOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestNewVersion::Builder::setOld2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::initOld2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestNewVersion::Builder::adoptOld2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestNewVersion::Builder::disownOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestNewVersion::Reader::hasOld3() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasOld3() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Reader TestNewVersion::Reader::getOld3() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Builder TestNewVersion::Builder::getOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestNewVersion::Pipeline TestNewVersion::Pipeline::getOld3() { + return ::capnproto_test::capnp::test::TestNewVersion::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestNewVersion::Builder::setOld3( ::capnproto_test::capnp::test::TestNewVersion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Builder TestNewVersion::Builder::initOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestNewVersion::Builder::adoptOld3( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion> TestNewVersion::Builder::disownOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::int64_t TestNewVersion::Reader::getNew1() const { + return _reader.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 987ll); +} + +inline ::int64_t TestNewVersion::Builder::getNew1() { + return _builder.getDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 987ll); +} +inline void TestNewVersion::Builder::setNew1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 987ll); +} + +inline bool TestNewVersion::Reader::hasNew2() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasNew2() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestNewVersion::Reader::getNew2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_8ed75a7469f04ce3 + 93, 3); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::getNew2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), + ::capnp::schemas::bp_8ed75a7469f04ce3 + 93, 3); +} +inline void TestNewVersion::Builder::setNew2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::initNew2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestNewVersion::Builder::adoptNew2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestNewVersion::Builder::disownNew2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestOldUnionVersion::Which TestOldUnionVersion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestOldUnionVersion::Which TestOldUnionVersion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestOldUnionVersion::Reader::isA() const { + return which() == TestOldUnionVersion::A; +} +inline bool TestOldUnionVersion::Builder::isA() { + return which() == TestOldUnionVersion::A; +} +inline ::capnp::Void TestOldUnionVersion::Reader::getA() const { + KJ_IREQUIRE((which() == TestOldUnionVersion::A), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestOldUnionVersion::Builder::getA() { + KJ_IREQUIRE((which() == TestOldUnionVersion::A), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestOldUnionVersion::Builder::setA( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestOldUnionVersion::A); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestOldUnionVersion::Reader::isB() const { + return which() == TestOldUnionVersion::B; +} +inline bool TestOldUnionVersion::Builder::isB() { + return which() == TestOldUnionVersion::B; +} +inline ::uint64_t TestOldUnionVersion::Reader::getB() const { + KJ_IREQUIRE((which() == TestOldUnionVersion::B), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestOldUnionVersion::Builder::getB() { + KJ_IREQUIRE((which() == TestOldUnionVersion::B), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestOldUnionVersion::Builder::setB( ::uint64_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestOldUnionVersion::B); + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestNewUnionVersion::Which TestNewUnionVersion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNewUnionVersion::Which TestNewUnionVersion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestNewUnionVersion::Reader::isA() const { + return which() == TestNewUnionVersion::A; +} +inline bool TestNewUnionVersion::Builder::isA() { + return which() == TestNewUnionVersion::A; +} +inline typename TestNewUnionVersion::A::Reader TestNewUnionVersion::Reader::getA() const { + KJ_IREQUIRE((which() == TestNewUnionVersion::A), + "Must check which() before get()ing a union member."); + return typename TestNewUnionVersion::A::Reader(_reader); +} +inline typename TestNewUnionVersion::A::Builder TestNewUnionVersion::Builder::getA() { + KJ_IREQUIRE((which() == TestNewUnionVersion::A), + "Must check which() before get()ing a union member."); + return typename TestNewUnionVersion::A::Builder(_builder); +} +inline typename TestNewUnionVersion::A::Builder TestNewUnionVersion::Builder::initA() { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestNewUnionVersion::A); + _builder.setDataField< ::uint16_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0); + return typename TestNewUnionVersion::A::Builder(_builder); +} +inline bool TestNewUnionVersion::Reader::isB() const { + return which() == TestNewUnionVersion::B; +} +inline bool TestNewUnionVersion::Builder::isB() { + return which() == TestNewUnionVersion::B; +} +inline ::uint64_t TestNewUnionVersion::Reader::getB() const { + KJ_IREQUIRE((which() == TestNewUnionVersion::B), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestNewUnionVersion::Builder::getB() { + KJ_IREQUIRE((which() == TestNewUnionVersion::B), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TestNewUnionVersion::Builder::setB( ::uint64_t value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestNewUnionVersion::B); + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::TestNewUnionVersion::A::Which TestNewUnionVersion::A::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNewUnionVersion::A::Which TestNewUnionVersion::A::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS); +} + +inline bool TestNewUnionVersion::A::Reader::isA0() const { + return which() == TestNewUnionVersion::A::A0; +} +inline bool TestNewUnionVersion::A::Builder::isA0() { + return which() == TestNewUnionVersion::A::A0; +} +inline ::capnp::Void TestNewUnionVersion::A::Reader::getA0() const { + KJ_IREQUIRE((which() == TestNewUnionVersion::A::A0), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestNewUnionVersion::A::Builder::getA0() { + KJ_IREQUIRE((which() == TestNewUnionVersion::A::A0), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestNewUnionVersion::A::Builder::setA0( ::capnp::Void value) { + _builder.setDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, TestNewUnionVersion::A::A0); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestNewUnionVersion::A::Reader::isA1() const { + return which() == TestNewUnionVersion::A::A1; +} +inline bool TestNewUnionVersion::A::Builder::isA1() { + return which() == TestNewUnionVersion::A::A1; +} +inline ::uint64_t TestNewUnionVersion::A::Reader::getA1() const { + KJ_IREQUIRE((which() == TestNewUnionVersion::A::A1), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestNewUnionVersion::A::Builder::getA1() { + KJ_IREQUIRE((which() == TestNewUnionVersion::A::A1), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TestNewUnionVersion::A::Builder::setA1( ::uint64_t value) { + _builder.setDataField( + ::capnp::bounded<4>() * ::capnp::ELEMENTS, TestNewUnionVersion::A::A1); + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline typename TestStructUnion::Un::Reader TestStructUnion::Reader::getUn() const { + return typename TestStructUnion::Un::Reader(_reader); +} +inline typename TestStructUnion::Un::Builder TestStructUnion::Builder::getUn() { + return typename TestStructUnion::Un::Builder(_builder); +} +#if !CAPNP_LITE +inline typename TestStructUnion::Un::Pipeline TestStructUnion::Pipeline::getUn() { + return typename TestStructUnion::Un::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename TestStructUnion::Un::Builder TestStructUnion::Builder::initUn() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + return typename TestStructUnion::Un::Builder(_builder); +} +inline bool TestStructUnion::SomeStruct::Reader::hasSomeText() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::SomeStruct::Builder::hasSomeText() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestStructUnion::SomeStruct::Reader::getSomeText() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestStructUnion::SomeStruct::Builder::getSomeText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::SomeStruct::Builder::setSomeText( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestStructUnion::SomeStruct::Builder::initSomeText(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestStructUnion::SomeStruct::Builder::adoptSomeText( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestStructUnion::SomeStruct::Builder::disownSomeText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestStructUnion::SomeStruct::Reader::hasMoreText() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::SomeStruct::Builder::hasMoreText() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestStructUnion::SomeStruct::Reader::getMoreText() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestStructUnion::SomeStruct::Builder::getMoreText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::SomeStruct::Builder::setMoreText( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestStructUnion::SomeStruct::Builder::initMoreText(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestStructUnion::SomeStruct::Builder::adoptMoreText( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestStructUnion::SomeStruct::Builder::disownMoreText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestStructUnion::Un::Which TestStructUnion::Un::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestStructUnion::Un::Which TestStructUnion::Un::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestStructUnion::Un::Reader::isStruct() const { + return which() == TestStructUnion::Un::STRUCT; +} +inline bool TestStructUnion::Un::Builder::isStruct() { + return which() == TestStructUnion::Un::STRUCT; +} +inline bool TestStructUnion::Un::Reader::hasStruct() const { + if (which() != TestStructUnion::Un::STRUCT) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::Un::Builder::hasStruct() { + if (which() != TestStructUnion::Un::STRUCT) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Reader TestStructUnion::Un::Reader::getStruct() const { + KJ_IREQUIRE((which() == TestStructUnion::Un::STRUCT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Builder TestStructUnion::Un::Builder::getStruct() { + KJ_IREQUIRE((which() == TestStructUnion::Un::STRUCT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::setStruct( ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Reader value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::STRUCT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestStructUnion::SomeStruct::Builder TestStructUnion::Un::Builder::initStruct() { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::STRUCT); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::adoptStruct( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>&& value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::STRUCT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct> TestStructUnion::Un::Builder::disownStruct() { + KJ_IREQUIRE((which() == TestStructUnion::Un::STRUCT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestStructUnion::SomeStruct>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestStructUnion::Un::Reader::isObject() const { + return which() == TestStructUnion::Un::OBJECT; +} +inline bool TestStructUnion::Un::Builder::isObject() { + return which() == TestStructUnion::Un::OBJECT; +} +inline bool TestStructUnion::Un::Reader::hasObject() const { + if (which() != TestStructUnion::Un::OBJECT) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::Un::Builder::hasObject() { + if (which() != TestStructUnion::Un::OBJECT) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAnyPointer::Reader TestStructUnion::Un::Reader::getObject() const { + KJ_IREQUIRE((which() == TestStructUnion::Un::OBJECT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAnyPointer::Builder TestStructUnion::Un::Builder::getObject() { + KJ_IREQUIRE((which() == TestStructUnion::Un::OBJECT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::setObject( ::capnproto_test::capnp::test::TestAnyPointer::Reader value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAnyPointer::Builder TestStructUnion::Un::Builder::initObject() { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::adoptObject( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAnyPointer>&& value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAnyPointer> TestStructUnion::Un::Builder::disownObject() { + KJ_IREQUIRE((which() == TestStructUnion::Un::OBJECT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAnyPointer>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestPrintInlineStructs::Reader::hasSomeText() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPrintInlineStructs::Builder::hasSomeText() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestPrintInlineStructs::Reader::getSomeText() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestPrintInlineStructs::Builder::getSomeText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestPrintInlineStructs::Builder::setSomeText( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestPrintInlineStructs::Builder::initSomeText(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestPrintInlineStructs::Builder::adoptSomeText( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestPrintInlineStructs::Builder::disownSomeText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestPrintInlineStructs::Reader::hasStructList() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPrintInlineStructs::Builder::hasStructList() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Reader TestPrintInlineStructs::Reader::getStructList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Builder TestPrintInlineStructs::Builder::getStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestPrintInlineStructs::Builder::setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>::Builder TestPrintInlineStructs::Builder::initStructList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestPrintInlineStructs::Builder::adoptStructList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>> TestPrintInlineStructs::Builder::disownStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestPrintInlineStructs::InlineStruct, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::int32_t TestPrintInlineStructs::InlineStruct::Reader::getInt32Field() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestPrintInlineStructs::InlineStruct::Builder::getInt32Field() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestPrintInlineStructs::InlineStruct::Builder::setInt32Field( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestPrintInlineStructs::InlineStruct::Reader::hasTextField() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPrintInlineStructs::InlineStruct::Builder::hasTextField() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestPrintInlineStructs::InlineStruct::Reader::getTextField() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestPrintInlineStructs::InlineStruct::Builder::getTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestPrintInlineStructs::InlineStruct::Builder::setTextField( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestPrintInlineStructs::InlineStruct::Builder::initTextField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestPrintInlineStructs::InlineStruct::Builder::adoptTextField( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestPrintInlineStructs::InlineStruct::Builder::disownTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline float TestWholeFloatDefault::Reader::getField() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1123418112u); +} + +inline float TestWholeFloatDefault::Builder::getField() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 1123418112u); +} +inline void TestWholeFloatDefault::Builder::setField(float value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, 1123418112u); +} + +inline float TestWholeFloatDefault::Reader::getBigField() const { + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 1909060298u); +} + +inline float TestWholeFloatDefault::Builder::getBigField() { + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 1909060298u); +} +inline void TestWholeFloatDefault::Builder::setBigField(float value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 1909060298u); +} + +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Which TestGenerics::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Which TestGenerics::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +template +inline bool TestGenerics::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenerics::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestGenerics::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenerics::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenerics::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::Reader::hasRev() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::Builder::hasRev() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Reader TestGenerics::Reader::getRev() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Builder TestGenerics::Builder::getRev() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Pipeline TestGenerics::Pipeline::getRev() { + return typename ::capnproto_test::capnp::test::TestGenerics::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::Builder::setRev(typename ::capnproto_test::capnp::test::TestGenerics::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Builder TestGenerics::Builder::initRev() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::Builder::adoptRev( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics> TestGenerics::Builder::disownRev() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::Reader::isUv() const { + return which() == TestGenerics::UV; +} +template +inline bool TestGenerics::Builder::isUv() { + return which() == TestGenerics::UV; +} +template +inline ::capnp::Void TestGenerics::Reader::getUv() const { + KJ_IREQUIRE((which() == TestGenerics::UV), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +template +inline ::capnp::Void TestGenerics::Builder::getUv() { + KJ_IREQUIRE((which() == TestGenerics::UV), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +template +inline void TestGenerics::Builder::setUv( ::capnp::Void value) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenerics::UV); + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +template +inline bool TestGenerics::Reader::isUg() const { + return which() == TestGenerics::UG; +} +template +inline bool TestGenerics::Builder::isUg() { + return which() == TestGenerics::UG; +} +template +inline typename TestGenerics::Ug::Reader TestGenerics::Reader::getUg() const { + KJ_IREQUIRE((which() == TestGenerics::UG), + "Must check which() before get()ing a union member."); + return typename TestGenerics::Ug::Reader(_reader); +} +template +inline typename TestGenerics::Ug::Builder TestGenerics::Builder::getUg() { + KJ_IREQUIRE((which() == TestGenerics::UG), + "Must check which() before get()ing a union member."); + return typename TestGenerics::Ug::Builder(_builder); +} +template +inline typename TestGenerics::Ug::Builder TestGenerics::Builder::initUg() { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenerics::UG); + _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + return typename TestGenerics::Ug::Builder(_builder); +} +template +inline bool TestGenerics::Reader::hasList() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::Builder::hasList() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Reader TestGenerics::Reader::getList() const { + return ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Builder TestGenerics::Builder::getList() { + return ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::Builder::setList(typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnp::List::Inner, ::capnp::Kind::STRUCT>::Builder TestGenerics::Builder::initList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::Builder::adoptList( + ::capnp::Orphan< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan< ::capnp::List::Inner, ::capnp::Kind::STRUCT>> TestGenerics::Builder::disownList() { + return ::capnp::_::PointerHelpers< ::capnp::List::Inner, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::Inner::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::Inner::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenerics::Inner::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestGenerics::Inner::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::Inner::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::Inner::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenerics::Inner::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::Inner::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::Inner::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenerics::Inner::Reader::getBar() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::getBar() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestGenerics::Inner::Pipeline::getBar() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::Inner::Builder::setBar( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::initBar() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::Inner::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::Inner::Builder::adoptBar( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenerics::Inner::Builder::disownBar() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +// TestGenerics::Inner +template +constexpr uint16_t TestGenerics::Inner::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenerics::Inner::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenerics::Inner::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_f6a841117e19ac73, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +template +template +inline bool TestGenerics::Inner2::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Inner2::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::Reader::getBar() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::getBar() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::Pipeline::getBar() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Inner2::Builder::setBar( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::initBar() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +template +inline void TestGenerics::Inner2::Builder::adoptBar( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan TestGenerics::Inner2::Builder::disownBar() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +template +inline bool TestGenerics::Inner2::Reader::hasBaz() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Inner2::Builder::hasBaz() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::Reader::getBaz() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::getBaz() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::Pipeline::getBaz() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Inner2::Builder::setBaz( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::initBaz() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::Builder::initBaz(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +template +template +inline void TestGenerics::Inner2::Builder::adoptBaz( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan TestGenerics::Inner2::Builder::disownBaz() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +template +template +inline bool TestGenerics::Inner2::Reader::hasInnerBound() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Inner2::Builder::hasInnerBound() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader TestGenerics::Inner2::Reader::getInnerBound() const { + return ::capnp::_::PointerHelpers::Inner>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder TestGenerics::Inner2::Builder::getInnerBound() { + return ::capnp::_::PointerHelpers::Inner>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline TestGenerics::Inner2::Pipeline::getInnerBound() { + return typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Inner2::Builder::setInnerBound(typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader value) { + ::capnp::_::PointerHelpers::Inner>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder TestGenerics::Inner2::Builder::initInnerBound() { + return ::capnp::_::PointerHelpers::Inner>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +template +inline void TestGenerics::Inner2::Builder::adoptInnerBound( + ::capnp::Orphan::Inner>&& value) { + ::capnp::_::PointerHelpers::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan::Inner> TestGenerics::Inner2::Builder::disownInnerBound() { + return ::capnp::_::PointerHelpers::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +template +template +inline bool TestGenerics::Inner2::Reader::hasInnerUnbound() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Inner2::Builder::hasInnerUnbound() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Reader TestGenerics::Inner2::Reader::getInnerUnbound() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Builder TestGenerics::Inner2::Builder::getInnerUnbound() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Pipeline TestGenerics::Inner2::Pipeline::getInnerUnbound() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Inner2::Builder::setInnerUnbound( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner::Builder TestGenerics::Inner2::Builder::initInnerUnbound() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +template +inline void TestGenerics::Inner2::Builder::adoptInnerUnbound( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner> TestGenerics::Inner2::Builder::disownInnerUnbound() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::DeepNest::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::DeepNest::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +template +inline ::capnp::Orphan TestGenerics::Inner2::DeepNest::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::DeepNest::Reader::getBar() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::getBar() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::DeepNest::Pipeline::getBar() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::setBar( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initBar() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::adoptBar( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +template +inline ::capnp::Orphan TestGenerics::Inner2::DeepNest::Builder::disownBar() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Reader::hasBaz() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Builder::hasBaz() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::DeepNest::Reader::getBaz() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::getBaz() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::DeepNest::Pipeline::getBaz() { + return ::capnp::PipelineFor(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::setBaz( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initBaz() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initBaz(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::adoptBaz( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +template +inline ::capnp::Orphan TestGenerics::Inner2::DeepNest::Builder::disownBaz() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Reader::hasQux() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline bool TestGenerics::Inner2::DeepNest::Builder::hasQux() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +template +template +inline ::capnp::ReaderFor TestGenerics::Inner2::DeepNest::Reader::getQux() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::getQux() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +template +inline ::capnp::PipelineFor TestGenerics::Inner2::DeepNest::Pipeline::getQux() { + return ::capnp::PipelineFor(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::setQux( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initQux() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +template +template +inline ::capnp::BuilderFor TestGenerics::Inner2::DeepNest::Builder::initQux(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +template +template +template +inline void TestGenerics::Inner2::DeepNest::Builder::adoptQux( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +template +inline ::capnp::Orphan TestGenerics::Inner2::DeepNest::Builder::disownQux() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +template +template +template +template +inline TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +template +template +template +template +inline TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +template +template +template +template +inline TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +template +template +template +template +inline TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +template +template +template +template +inline TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +template +template +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::Client& TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +template +template +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::Client& TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +// TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams +template +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::dataWordSize; +template +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +template +template +constexpr ::capnp::Kind TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::kind; +template +template +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::schema; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::brandScopes[] = { + { 0x8839ed86c9794287, brandBindings + 0, 1, false}, + { 0x9d5b8cd8de9922eb, brandBindings + 1, 2, false}, + { 0xa9ab42b118d6d435, brandBindings + 3, 1, false}, + { 0xb6a0829c762b06f3, brandBindings + 4, 1, false}, +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner2::DeepNest::DeepNestInterface::CallParams::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_b84eecc799437049, brandScopes, nullptr, + 4, 0, nullptr +}; +#endif // !CAPNP_LITE + +// TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults +template +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::dataWordSize; +template +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +template +template +constexpr ::capnp::Kind TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::kind; +template +template +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::schema; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::brandScopes[] = { + { 0x8839ed86c9794287, brandBindings + 0, 1, false}, + { 0x9d5b8cd8de9922eb, brandBindings + 1, 2, false}, + { 0xa9ab42b118d6d435, brandBindings + 3, 1, false}, + { 0xb6a0829c762b06f3, brandBindings + 4, 1, false}, +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner2::DeepNest::DeepNestInterface::CallResults::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_e080f0fc54614f6f, brandScopes, nullptr, + 4, 0, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +template +template +template +CAPNP_AUTO_IF_MSVC(::capnp::Request::template Inner2::template DeepNest::template DeepNestInterface::CallParams, typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults>) +TestGenerics::Inner2::DeepNest::DeepNestInterface::Client::callRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall::template Inner2::template DeepNest::template DeepNestInterface::CallParams, typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults>( + 0x8839ed86c9794287ull, 0, sizeHint); +} +template +template +template +template +::kj::Promise TestGenerics::Inner2::DeepNest::DeepNestInterface::Server::call(CallContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestGenerics.Inner2.DeepNest.DeepNestInterface", "call", + 0x8839ed86c9794287ull, 0); +} +template +template +template +template +::kj::Promise TestGenerics::Inner2::DeepNest::DeepNestInterface::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0x8839ed86c9794287ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestGenerics.Inner2.DeepNest.DeepNestInterface", interfaceId); + } +} +template +template +template +template +::kj::Promise TestGenerics::Inner2::DeepNest::DeepNestInterface::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return call(::capnp::Capability::Server::internalGetTypedContext< + typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallParams, typename ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestGenerics.Inner2.DeepNest.DeepNestInterface", + 0x8839ed86c9794287ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestGenerics::Inner2::DeepNest::DeepNestInterface +#if !CAPNP_LITE +template +template +template +template +constexpr ::capnp::Kind TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::kind; +template +template +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::schema; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::brandScopes[] = { + { 0x8839ed86c9794287, brandBindings + 0, 1, false}, + { 0x9d5b8cd8de9922eb, brandBindings + 1, 2, false}, + { 0xa9ab42b118d6d435, brandBindings + 3, 1, false}, + { 0xb6a0829c762b06f3, brandBindings + 4, 1, false}, +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::brandDependencies[] = { + { 33554432, ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallParams::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics::template Inner2::template DeepNest::template DeepNestInterface::CallResults::_capnpPrivate::brand() }, +}; +template +template +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner2::DeepNest::DeepNestInterface::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_8839ed86c9794287, brandScopes, brandDependencies, + 4, 2, nullptr +}; +#endif // !CAPNP_LITE + +// TestGenerics::Inner2::DeepNest +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::_capnpPrivate::dataWordSize; +template +template +template +constexpr uint16_t TestGenerics::Inner2::DeepNest::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +template +constexpr ::capnp::Kind TestGenerics::Inner2::DeepNest::_capnpPrivate::kind; +template +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner2::DeepNest::_capnpPrivate::schema; +template +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner2::DeepNest::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, + { 0xa9ab42b118d6d435, brandBindings + 2, 1, false}, + { 0xb6a0829c762b06f3, brandBindings + 3, 1, false}, +}; +template +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner2::DeepNest::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner2::DeepNest::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_b6a0829c762b06f3, brandScopes, nullptr, + 3, 0, nullptr +}; +#endif // !CAPNP_LITE + +// TestGenerics::Inner2 +template +template +constexpr uint16_t TestGenerics::Inner2::_capnpPrivate::dataWordSize; +template +template +constexpr uint16_t TestGenerics::Inner2::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +constexpr ::capnp::Kind TestGenerics::Inner2::_capnpPrivate::kind; +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Inner2::_capnpPrivate::schema; +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Inner2::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, + { 0xa9ab42b118d6d435, brandBindings + 2, 1, false}, +}; +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Inner2::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::Inner2::_capnpPrivate::brandDependencies[] = { + { 16777218, ::capnproto_test::capnp::test::TestGenerics::Inner::_capnpPrivate::brand() }, +}; +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Inner2::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_a9ab42b118d6d435, brandScopes, brandDependencies, + 2, 1, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +template +inline TestGenerics::Interface::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +template +template +inline TestGenerics::Interface::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +template +template +inline TestGenerics::Interface::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +template +template +inline TestGenerics::Interface::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +template +template +inline TestGenerics::Interface::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Interface::Client& TestGenerics::Interface::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +template +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Interface::Client& TestGenerics::Interface::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +template +template +inline bool TestGenerics::Interface::CallResults::Reader::hasQux() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Interface::CallResults::Builder::hasQux() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnp::ReaderFor TestGenerics::Interface::CallResults::Reader::getQux() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Interface::CallResults::Builder::getQux() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnp::PipelineFor TestGenerics::Interface::CallResults::Pipeline::getQux() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Interface::CallResults::Builder::setQux( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Interface::CallResults::Builder::initQux() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestGenerics::Interface::CallResults::Builder::initQux(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +template +inline void TestGenerics::Interface::CallResults::Builder::adoptQux( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan TestGenerics::Interface::CallResults::Builder::disownQux() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +template +inline bool TestGenerics::Interface::CallResults::Reader::hasGen() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestGenerics::Interface::CallResults::Builder::hasGen() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader TestGenerics::Interface::CallResults::Reader::getGen() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestGenerics::Interface::CallResults::Builder::getGen() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline TestGenerics::Interface::CallResults::Pipeline::getGen() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +template +inline void TestGenerics::Interface::CallResults::Builder::setGen( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestGenerics::Interface::CallResults::Builder::initGen() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline void TestGenerics::Interface::CallResults::Builder::adoptGen( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> TestGenerics::Interface::CallResults::Builder::disownGen() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +// TestGenerics::Interface::CallResults +template +template +constexpr uint16_t TestGenerics::Interface::CallResults::_capnpPrivate::dataWordSize; +template +template +constexpr uint16_t TestGenerics::Interface::CallResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +constexpr ::capnp::Kind TestGenerics::Interface::CallResults::_capnpPrivate::kind; +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Interface::CallResults::_capnpPrivate::schema; +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Interface::CallResults::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, + { 0xc9e749e8dd54da5c, brandBindings + 2, 1, false}, +}; +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Interface::CallResults::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::Interface::CallResults::_capnpPrivate::brandDependencies[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::_capnpPrivate::brand() }, +}; +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Interface::CallResults::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_a5b46224e33581ad, brandScopes, brandDependencies, + 2, 1, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +template +CAPNP_AUTO_IF_MSVC(::capnp::Request::template Inner2< ::capnp::Text>, typename ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults>) +TestGenerics::Interface::Client::callRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall::template Inner2< ::capnp::Text>, typename ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults>( + 0xc9e749e8dd54da5cull, 0, sizeHint); +} +template +template +::kj::Promise TestGenerics::Interface::Server::call(CallContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestGenerics.Interface", "call", + 0xc9e749e8dd54da5cull, 0); +} +template +template +::kj::Promise TestGenerics::Interface::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xc9e749e8dd54da5cull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestGenerics.Interface", interfaceId); + } +} +template +template +::kj::Promise TestGenerics::Interface::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return call(::capnp::Capability::Server::internalGetTypedContext< + typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>, typename ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestGenerics.Interface", + 0xc9e749e8dd54da5cull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestGenerics::Interface +#if !CAPNP_LITE +template +template +constexpr ::capnp::Kind TestGenerics::Interface::_capnpPrivate::kind; +template +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Interface::_capnpPrivate::schema; +template +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Interface::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, + { 0xc9e749e8dd54da5c, brandBindings + 2, 1, false}, +}; +template +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Interface::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::Interface::_capnpPrivate::brandDependencies[] = { + { 33554432, ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics::template Interface::CallResults::_capnpPrivate::brand() }, +}; +template +template +const ::capnp::_::RawBrandedSchema TestGenerics::Interface::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_c9e749e8dd54da5c, brandScopes, brandDependencies, + 2, 2, nullptr +}; +#endif // !CAPNP_LITE + +template +inline bool TestGenerics::UseAliases::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenerics::UseAliases::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestGenerics::UseAliases::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::UseAliases::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenerics::UseAliases::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::UseAliases::Reader::hasInner() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasInner() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader TestGenerics::UseAliases::Reader::getInner() const { + return ::capnp::_::PointerHelpers::Inner>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder TestGenerics::UseAliases::Builder::getInner() { + return ::capnp::_::PointerHelpers::Inner>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline TestGenerics::UseAliases::Pipeline::getInner() { + return typename ::capnproto_test::capnp::test::TestGenerics::Inner::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setInner(typename ::capnproto_test::capnp::test::TestGenerics::Inner::Reader value) { + ::capnp::_::PointerHelpers::Inner>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Inner::Builder TestGenerics::UseAliases::Builder::initInner() { + return ::capnp::_::PointerHelpers::Inner>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::UseAliases::Builder::adoptInner( + ::capnp::Orphan::Inner>&& value) { + ::capnp::_::PointerHelpers::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan::Inner> TestGenerics::UseAliases::Builder::disownInner() { + return ::capnp::_::PointerHelpers::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenerics::UseAliases::Reader::hasInner2() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasInner2() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Reader TestGenerics::UseAliases::Reader::getInner2() const { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Builder TestGenerics::UseAliases::Builder::getInner2() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Pipeline TestGenerics::UseAliases::Pipeline::getInner2() { + return typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setInner2(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Reader value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::Builder TestGenerics::UseAliases::Builder::initInner2() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::UseAliases::Builder::adoptInner2( + ::capnp::Orphan::template Inner2< ::capnp::AnyPointer>>&& value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +#ifndef _MSC_VER +// Excluded under MSVC because bugs may make it unable to compile this method. +template +inline ::capnp::Orphan::template Inner2< ::capnp::AnyPointer>> TestGenerics::UseAliases::Builder::disownInner2() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::AnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#endif // !_MSC_VER + +template +inline bool TestGenerics::UseAliases::Reader::hasInner2Bind() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasInner2Bind() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader TestGenerics::UseAliases::Reader::getInner2Bind() const { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder TestGenerics::UseAliases::Builder::getInner2Bind() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline TestGenerics::UseAliases::Pipeline::getInner2Bind() { + return typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setInner2Bind(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder TestGenerics::UseAliases::Builder::initInner2Bind() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::UseAliases::Builder::adoptInner2Bind( + ::capnp::Orphan::template Inner2< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +#ifndef _MSC_VER +// Excluded under MSVC because bugs may make it unable to compile this method. +template +inline ::capnp::Orphan::template Inner2< ::capnp::Text>> TestGenerics::UseAliases::Builder::disownInner2Bind() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#endif // !_MSC_VER + +template +inline bool TestGenerics::UseAliases::Reader::hasInner2Text() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasInner2Text() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader TestGenerics::UseAliases::Reader::getInner2Text() const { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder TestGenerics::UseAliases::Builder::getInner2Text() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline TestGenerics::UseAliases::Pipeline::getInner2Text() { + return typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Pipeline(_typeless.getPointerField(4)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setInner2Text(typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::Builder TestGenerics::UseAliases::Builder::initInner2Text() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +template +inline void TestGenerics::UseAliases::Builder::adoptInner2Text( + ::capnp::Orphan::template Inner2< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +#ifndef _MSC_VER +// Excluded under MSVC because bugs may make it unable to compile this method. +template +inline ::capnp::Orphan::template Inner2< ::capnp::Text>> TestGenerics::UseAliases::Builder::disownInner2Text() { + return ::capnp::_::PointerHelpers::template Inner2< ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +#endif // !_MSC_VER + +template +inline bool TestGenerics::UseAliases::Reader::hasRevFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenerics::UseAliases::Builder::hasRevFoo() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenerics::UseAliases::Reader::getRevFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::getRevFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestGenerics::UseAliases::Pipeline::getRevFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +template +inline void TestGenerics::UseAliases::Builder::setRevFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::initRevFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenerics::UseAliases::Builder::initRevFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); +} +template +inline void TestGenerics::UseAliases::Builder::adoptRevFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenerics::UseAliases::Builder::disownRevFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +// TestGenerics::UseAliases +template +constexpr uint16_t TestGenerics::UseAliases::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenerics::UseAliases::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenerics::UseAliases::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenerics::UseAliases::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::UseAliases::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::UseAliases::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::UseAliases::_capnpPrivate::brandDependencies[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics::Inner::_capnpPrivate::brand() }, + { 16777218, ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::AnyPointer>::_capnpPrivate::brand() }, + { 16777219, ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::_capnpPrivate::brand() }, + { 16777220, ::capnproto_test::capnp::test::TestGenerics::template Inner2< ::capnp::Text>::_capnpPrivate::brand() }, +}; +template +const ::capnp::_::RawBrandedSchema TestGenerics::UseAliases::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_8e656edfb45ba6cf, brandScopes, brandDependencies, + 1, 4, nullptr +}; +#endif // !CAPNP_LITE + +template +inline ::int32_t TestGenerics::Ug::Reader::getUgfoo() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +template +inline ::int32_t TestGenerics::Ug::Builder::getUgfoo() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +template +inline void TestGenerics::Ug::Builder::setUgfoo( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +// TestGenerics::Ug +template +constexpr uint16_t TestGenerics::Ug::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenerics::Ug::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenerics::Ug::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenerics::Ug::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::Ug::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::Ug::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestGenerics::Ug::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_b46a779beaf3384e, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +// TestGenerics +template +constexpr uint16_t TestGenerics::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenerics::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenerics::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenerics::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenerics::_capnpPrivate::brandScopes[] = { + { 0x9d5b8cd8de9922eb, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenerics::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenerics::_capnpPrivate::brandDependencies[] = { + { 16777217, ::capnproto_test::capnp::test::TestGenerics::_capnpPrivate::brand() }, + { 16777219, ::capnproto_test::capnp::test::TestGenerics::Ug::_capnpPrivate::brand() }, + { 16777220, ::capnproto_test::capnp::test::TestGenerics::Inner::_capnpPrivate::brand() }, +}; +template +const ::capnp::_::RawBrandedSchema TestGenerics::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_9d5b8cd8de9922eb, brandScopes, brandDependencies, + 1, 3, nullptr +}; +#endif // !CAPNP_LITE + +template +inline bool TestGenericsWrapper::Reader::hasValue() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenericsWrapper::Builder::hasValue() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Reader TestGenericsWrapper::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Builder TestGenericsWrapper::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Pipeline TestGenericsWrapper::Pipeline::getValue() { + return typename ::capnproto_test::capnp::test::TestGenerics::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestGenericsWrapper::Builder::setValue(typename ::capnproto_test::capnp::test::TestGenerics::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline typename ::capnproto_test::capnp::test::TestGenerics::Builder TestGenericsWrapper::Builder::initValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline void TestGenericsWrapper::Builder::adoptValue( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics> TestGenericsWrapper::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +// TestGenericsWrapper +template +constexpr uint16_t TestGenericsWrapper::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenericsWrapper::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenericsWrapper::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenericsWrapper::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenericsWrapper::_capnpPrivate::brandScopes[] = { + { 0xa9b2b1f52dde845d, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenericsWrapper::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema::Dependency TestGenericsWrapper::_capnpPrivate::brandDependencies[] = { + { 16777216, ::capnproto_test::capnp::test::TestGenerics::_capnpPrivate::brand() }, +}; +template +const ::capnp::_::RawBrandedSchema TestGenericsWrapper::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_a9b2b1f52dde845d, brandScopes, brandDependencies, + 1, 1, nullptr +}; +#endif // !CAPNP_LITE + +inline bool TestGenericsWrapper2::Reader::hasValue() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestGenericsWrapper2::Builder::hasValue() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader TestGenericsWrapper2::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder TestGenericsWrapper2::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline TestGenericsWrapper2::Pipeline::getValue() { + return ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestGenericsWrapper2::Builder::setValue( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder TestGenericsWrapper2::Builder::initValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestGenericsWrapper2::Builder::adoptValue( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>> TestGenericsWrapper2::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +inline TestImplicitMethodParams::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestImplicitMethodParams::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestImplicitMethodParams::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestImplicitMethodParams::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestImplicitMethodParams::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestImplicitMethodParams::Client& TestImplicitMethodParams::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestImplicitMethodParams::Client& TestImplicitMethodParams::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +template +::capnp::Request< ::capnproto_test::capnp::test::TestImplicitMethodParams::CallParams, ::capnproto_test::capnp::test::TestGenerics> +TestImplicitMethodParams::Client::callRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall< ::capnproto_test::capnp::test::TestImplicitMethodParams::CallParams, ::capnproto_test::capnp::test::TestGenerics>( + 0x8b9717a3f8d85a9aull, 0, sizeHint); +} +#endif // !CAPNP_LITE +template +inline bool TestImplicitMethodParams::CallParams::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestImplicitMethodParams::CallParams::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestImplicitMethodParams::CallParams::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestImplicitMethodParams::CallParams::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestImplicitMethodParams::CallParams::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestImplicitMethodParams::CallParams::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestImplicitMethodParams::CallParams::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +inline bool TestImplicitMethodParams::CallParams::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestImplicitMethodParams::CallParams::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestImplicitMethodParams::CallParams::Reader::getBar() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::getBar() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestImplicitMethodParams::CallParams::Pipeline::getBar() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +inline void TestImplicitMethodParams::CallParams::Builder::setBar( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::initBar() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestImplicitMethodParams::CallParams::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +template +inline void TestImplicitMethodParams::CallParams::Builder::adoptBar( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestImplicitMethodParams::CallParams::Builder::disownBar() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +// TestImplicitMethodParams::CallParams +template +constexpr uint16_t TestImplicitMethodParams::CallParams::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestImplicitMethodParams::CallParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestImplicitMethodParams::CallParams::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestImplicitMethodParams::CallParams::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestImplicitMethodParams::CallParams::_capnpPrivate::brandScopes[] = { + { 0xf83f8caf54bdc486, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestImplicitMethodParams::CallParams::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestImplicitMethodParams::CallParams::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_f83f8caf54bdc486, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +inline TestImplicitMethodParamsInGeneric::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +template +inline TestImplicitMethodParamsInGeneric::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +template +inline TestImplicitMethodParamsInGeneric::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +template +inline TestImplicitMethodParamsInGeneric::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +template +inline TestImplicitMethodParamsInGeneric::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +template +inline typename ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::Client& TestImplicitMethodParamsInGeneric::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +template +inline typename ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::Client& TestImplicitMethodParamsInGeneric::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +template +template +CAPNP_AUTO_IF_MSVC(::capnp::Request::template CallParams, ::capnproto_test::capnp::test::TestGenerics>) +TestImplicitMethodParamsInGeneric::Client::callRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall::template CallParams, ::capnproto_test::capnp::test::TestGenerics>( + 0xdf9ccdeb81a704c9ull, 0, sizeHint); +} +#endif // !CAPNP_LITE +template +template +inline bool TestImplicitMethodParamsInGeneric::CallParams::Reader::hasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestImplicitMethodParamsInGeneric::CallParams::Builder::hasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnp::ReaderFor TestImplicitMethodParamsInGeneric::CallParams::Reader::getFoo() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::getFoo() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnp::PipelineFor TestImplicitMethodParamsInGeneric::CallParams::Pipeline::getFoo() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +template +inline void TestImplicitMethodParamsInGeneric::CallParams::Builder::setFoo( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::initFoo() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +template +inline void TestImplicitMethodParamsInGeneric::CallParams::Builder::adoptFoo( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan TestImplicitMethodParamsInGeneric::CallParams::Builder::disownFoo() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +template +inline bool TestImplicitMethodParamsInGeneric::CallParams::Reader::hasBar() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline bool TestImplicitMethodParamsInGeneric::CallParams::Builder::hasBar() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +template +template +inline ::capnp::ReaderFor TestImplicitMethodParamsInGeneric::CallParams::Reader::getBar() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::getBar() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +template +inline ::capnp::PipelineFor TestImplicitMethodParamsInGeneric::CallParams::Pipeline::getBar() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +template +template +inline void TestImplicitMethodParamsInGeneric::CallParams::Builder::setBar( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::initBar() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +template +template +inline ::capnp::BuilderFor TestImplicitMethodParamsInGeneric::CallParams::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +template +template +inline void TestImplicitMethodParamsInGeneric::CallParams::Builder::adoptBar( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +template +template +inline ::capnp::Orphan TestImplicitMethodParamsInGeneric::CallParams::Builder::disownBar() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +// TestImplicitMethodParamsInGeneric::CallParams +template +template +constexpr uint16_t TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::dataWordSize; +template +template +constexpr uint16_t TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +template +constexpr ::capnp::Kind TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::kind; +template +template +constexpr ::capnp::_::RawSchema const* TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::schema; +template +template +const ::capnp::_::RawBrandedSchema::Scope TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::brandScopes[] = { + { 0x9aab8e25c808d71e, brandBindings + 0, 2, false}, + { 0xdf9ccdeb81a704c9, brandBindings + 2, 1, false}, +}; +template +template +const ::capnp::_::RawBrandedSchema::Binding TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +template +const ::capnp::_::RawBrandedSchema TestImplicitMethodParamsInGeneric::CallParams::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_9aab8e25c808d71e, brandScopes, nullptr, + 2, 0, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +::kj::Promise TestImplicitMethodParamsInGeneric::Server::call(CallContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestImplicitMethodParamsInGeneric", "call", + 0xdf9ccdeb81a704c9ull, 0); +} +template +::kj::Promise TestImplicitMethodParamsInGeneric::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xdf9ccdeb81a704c9ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestImplicitMethodParamsInGeneric", interfaceId); + } +} +template +::kj::Promise TestImplicitMethodParamsInGeneric::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return call(::capnp::Capability::Server::internalGetTypedContext< + typename ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::template CallParams<>, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestImplicitMethodParamsInGeneric", + 0xdf9ccdeb81a704c9ull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestImplicitMethodParamsInGeneric +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestImplicitMethodParamsInGeneric::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestImplicitMethodParamsInGeneric::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestImplicitMethodParamsInGeneric::_capnpPrivate::brandScopes[] = { + { 0xdf9ccdeb81a704c9, brandBindings + 0, 1, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestImplicitMethodParamsInGeneric::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema::Dependency TestImplicitMethodParamsInGeneric::_capnpPrivate::brandDependencies[] = { + { 33554432, ::capnproto_test::capnp::test::TestImplicitMethodParamsInGeneric::template CallParams<>::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::_capnpPrivate::brand() }, +}; +template +const ::capnp::_::RawBrandedSchema TestImplicitMethodParamsInGeneric::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_df9ccdeb81a704c9, brandScopes, brandDependencies, + 1, 2, nullptr +}; +#endif // !CAPNP_LITE + +template +inline typename ::capnproto_test::capnp::test::TestGenericsUnion::Which TestGenericsUnion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +template +inline typename ::capnproto_test::capnp::test::TestGenericsUnion::Which TestGenericsUnion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +template +inline bool TestGenericsUnion::Reader::isFoo() const { + return which() == TestGenericsUnion::FOO; +} +template +inline bool TestGenericsUnion::Builder::isFoo() { + return which() == TestGenericsUnion::FOO; +} +template +inline bool TestGenericsUnion::Reader::hasFoo() const { + if (which() != TestGenericsUnion::FOO) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenericsUnion::Builder::hasFoo() { + if (which() != TestGenericsUnion::FOO) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenericsUnion::Reader::getFoo() const { + KJ_IREQUIRE((which() == TestGenericsUnion::FOO), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::getFoo() { + KJ_IREQUIRE((which() == TestGenericsUnion::FOO), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline void TestGenericsUnion::Builder::setFoo( ::capnp::ReaderFor value) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::FOO); + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::initFoo() { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::FOO); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::initFoo(unsigned int size) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::FOO); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestGenericsUnion::Builder::adoptFoo( + ::capnp::Orphan&& value) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::FOO); + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenericsUnion::Builder::disownFoo() { + KJ_IREQUIRE((which() == TestGenericsUnion::FOO), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +template +inline bool TestGenericsUnion::Reader::isBar() const { + return which() == TestGenericsUnion::BAR; +} +template +inline bool TestGenericsUnion::Builder::isBar() { + return which() == TestGenericsUnion::BAR; +} +template +inline bool TestGenericsUnion::Reader::hasBar() const { + if (which() != TestGenericsUnion::BAR) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestGenericsUnion::Builder::hasBar() { + if (which() != TestGenericsUnion::BAR) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestGenericsUnion::Reader::getBar() const { + KJ_IREQUIRE((which() == TestGenericsUnion::BAR), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::getBar() { + KJ_IREQUIRE((which() == TestGenericsUnion::BAR), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline void TestGenericsUnion::Builder::setBar( ::capnp::ReaderFor value) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::BAR); + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::initBar() { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::BAR); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestGenericsUnion::Builder::initBar(unsigned int size) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::BAR); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestGenericsUnion::Builder::adoptBar( + ::capnp::Orphan&& value) { + _builder.setDataField::Which>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, TestGenericsUnion::BAR); + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestGenericsUnion::Builder::disownBar() { + KJ_IREQUIRE((which() == TestGenericsUnion::BAR), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +// TestGenericsUnion +template +constexpr uint16_t TestGenericsUnion::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestGenericsUnion::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestGenericsUnion::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestGenericsUnion::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestGenericsUnion::_capnpPrivate::brandScopes[] = { + { 0xa54870440e919063, brandBindings + 0, 2, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestGenericsUnion::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestGenericsUnion::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_a54870440e919063, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +inline bool TestUseGenerics::Reader::hasBasic() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasBasic() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader TestUseGenerics::Reader::getBasic() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestUseGenerics::Builder::getBasic() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline TestUseGenerics::Pipeline::getBasic() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setBasic( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestUseGenerics::Builder::initBasic() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptBasic( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> TestUseGenerics::Builder::disownBasic() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasInner() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasInner() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader TestUseGenerics::Reader::getInner() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder TestUseGenerics::Builder::getInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline TestUseGenerics::Pipeline::getInner() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder TestUseGenerics::Builder::initInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptInner( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner> TestUseGenerics::Builder::disownInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasInner2() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasInner2() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader TestUseGenerics::Reader::getInner2() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::getInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline TestUseGenerics::Pipeline::getInner2() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setInner2( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::initInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptInner2( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>> TestUseGenerics::Builder::disownInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasUnspecified() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasUnspecified() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Reader TestUseGenerics::Reader::getUnspecified() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Builder TestUseGenerics::Builder::getUnspecified() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Pipeline TestUseGenerics::Pipeline::getUnspecified() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setUnspecified( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Builder TestUseGenerics::Builder::initUnspecified() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptUnspecified( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>> TestUseGenerics::Builder::disownUnspecified() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasUnspecifiedInner() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasUnspecifiedInner() { + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Reader TestUseGenerics::Reader::getUnspecifiedInner() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::getUnspecifiedInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Pipeline TestUseGenerics::Pipeline::getUnspecifiedInner() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Pipeline(_typeless.getPointerField(4)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setUnspecifiedInner( ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::initUnspecifiedInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptUnspecifiedInner( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>> TestUseGenerics::Builder::disownUnspecifiedInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnp::AnyPointer, ::capnp::AnyPointer>::Inner2< ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasDefault() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasDefault() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Reader TestUseGenerics::Reader::getDefault() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 328); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Builder TestUseGenerics::Builder::getDefault() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 328); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Pipeline TestUseGenerics::Pipeline::getDefault() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Pipeline(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setDefault( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Builder TestUseGenerics::Builder::initDefault() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptDefault( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>> TestUseGenerics::Builder::disownDefault() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasDefaultInner() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasDefaultInner() { + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Reader TestUseGenerics::Reader::getDefaultInner() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 420); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Builder TestUseGenerics::Builder::getDefaultInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 420); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Pipeline TestUseGenerics::Pipeline::getDefaultInner() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Pipeline(_typeless.getPointerField(6)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setDefaultInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner::Builder TestUseGenerics::Builder::initDefaultInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptDefaultInner( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner> TestUseGenerics::Builder::disownDefaultInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::Text>::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasDefaultUser() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasDefaultUser() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUseGenerics::Reader TestUseGenerics::Reader::getDefaultUser() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 458); +} +inline ::capnproto_test::capnp::test::TestUseGenerics::Builder TestUseGenerics::Builder::getDefaultUser() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 458); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestUseGenerics::Pipeline TestUseGenerics::Pipeline::getDefaultUser() { + return ::capnproto_test::capnp::test::TestUseGenerics::Pipeline(_typeless.getPointerField(7)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setDefaultUser( ::capnproto_test::capnp::test::TestUseGenerics::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUseGenerics::Builder TestUseGenerics::Builder::initDefaultUser() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptDefaultUser( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUseGenerics>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUseGenerics> TestUseGenerics::Builder::disownDefaultUser() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUseGenerics>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasWrapper() const { + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasWrapper() { + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader TestUseGenerics::Reader::getWrapper() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestUseGenerics::Builder::getWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline TestUseGenerics::Pipeline::getWrapper() { + return ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Pipeline(_typeless.getPointerField(8)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setWrapper( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Builder TestUseGenerics::Builder::initWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptWrapper( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>> TestUseGenerics::Builder::disownWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasDefaultWrapper() const { + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasDefaultWrapper() { + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader TestUseGenerics::Reader::getDefaultWrapper() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 561); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder TestUseGenerics::Builder::getDefaultWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 561); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline TestUseGenerics::Pipeline::getDefaultWrapper() { + return ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Pipeline(_typeless.getPointerField(9)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setDefaultWrapper( ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>::Builder TestUseGenerics::Builder::initDefaultWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptDefaultWrapper( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>> TestUseGenerics::Builder::disownDefaultWrapper() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper< ::capnp::Text, ::capnproto_test::capnp::test::TestAllTypes>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasDefaultWrapper2() const { + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasDefaultWrapper2() { + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Reader TestUseGenerics::Reader::getDefaultWrapper2() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 606); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Builder TestUseGenerics::Builder::getDefaultWrapper2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 606); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Pipeline TestUseGenerics::Pipeline::getDefaultWrapper2() { + return ::capnproto_test::capnp::test::TestGenericsWrapper2::Pipeline(_typeless.getPointerField(10)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setDefaultWrapper2( ::capnproto_test::capnp::test::TestGenericsWrapper2::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenericsWrapper2::Builder TestUseGenerics::Builder::initDefaultWrapper2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptDefaultWrapper2( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper2>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenericsWrapper2> TestUseGenerics::Builder::disownDefaultWrapper2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenericsWrapper2>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasFoo() const { + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasFoo() { + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestUseGenerics::Reader::getAliasFoo() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 652); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestUseGenerics::Builder::getAliasFoo() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 652); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestUseGenerics::Pipeline::getAliasFoo() { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(11)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setAliasFoo( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestUseGenerics::Builder::initAliasFoo() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptAliasFoo( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestUseGenerics::Builder::disownAliasFoo() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasInner() const { + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasInner() { + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader TestUseGenerics::Reader::getAliasInner() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 705); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder TestUseGenerics::Builder::getAliasInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 705); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline TestUseGenerics::Pipeline::getAliasInner() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Pipeline(_typeless.getPointerField(12)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setAliasInner( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner::Builder TestUseGenerics::Builder::initAliasInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptAliasInner( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner> TestUseGenerics::Builder::disownAliasInner() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasInner2() const { + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasInner2() { + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Reader TestUseGenerics::Reader::getAliasInner2() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 760); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Builder TestUseGenerics::Builder::getAliasInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 760); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Pipeline TestUseGenerics::Pipeline::getAliasInner2() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Pipeline(_typeless.getPointerField(13)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setAliasInner2( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>::Builder TestUseGenerics::Builder::initAliasInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptAliasInner2( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>> TestUseGenerics::Builder::disownAliasInner2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::AnyPointer>>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasInner2Bind() const { + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasInner2Bind() { + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Reader TestUseGenerics::Reader::getAliasInner2Bind() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 833); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Builder TestUseGenerics::Builder::getAliasInner2Bind() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 833); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Pipeline TestUseGenerics::Pipeline::getAliasInner2Bind() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Pipeline(_typeless.getPointerField(14)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setAliasInner2Bind( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Builder TestUseGenerics::Builder::initAliasInner2Bind() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptAliasInner2Bind( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>> TestUseGenerics::Builder::disownAliasInner2Bind() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasInner2Text() const { + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasInner2Text() { + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader TestUseGenerics::Reader::getAliasInner2Text() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 903); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::getAliasInner2Text() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 903); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline TestUseGenerics::Pipeline::getAliasInner2Text() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Pipeline(_typeless.getPointerField(15)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setAliasInner2Text( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>::Builder TestUseGenerics::Builder::initAliasInner2Text() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptAliasInner2Text( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>> TestUseGenerics::Builder::disownAliasInner2Text() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnproto_test::capnp::test::TestAnyPointer>::Inner2< ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasAliasRev() const { + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasAliasRev() { + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUseGenerics::Reader::getAliasRev() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 946, 4); +} +inline ::capnp::Text::Builder TestUseGenerics::Builder::getAliasRev() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 946, 4); +} +inline void TestUseGenerics::Builder::setAliasRev( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUseGenerics::Builder::initAliasRev(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); +} +inline void TestUseGenerics::Builder::adoptAliasRev( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUseGenerics::Builder::disownAliasRev() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasUseAliases() const { + return !_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasUseAliases() { + return !_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Reader TestUseGenerics::Reader::getUseAliases() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::get(_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 977); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Builder TestUseGenerics::Builder::getUseAliases() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::get(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9427b2a71030338f + 977); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Pipeline TestUseGenerics::Pipeline::getUseAliases() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Pipeline(_typeless.getPointerField(17)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setUseAliases( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases::Builder TestUseGenerics::Builder::initUseAliases() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::init(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptUseAliases( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::adopt(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases> TestUseGenerics::Builder::disownUseAliases() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::UseAliases>::disown(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline bool TestUseGenerics::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Reader TestUseGenerics::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::get(_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Builder TestUseGenerics::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::get(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Pipeline TestUseGenerics::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Pipeline(_typeless.getPointerField(18)); +} +#endif // !CAPNP_LITE +inline void TestUseGenerics::Builder::setCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>::Builder TestUseGenerics::Builder::initCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::init(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline void TestUseGenerics::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::adopt(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>> TestUseGenerics::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestInterface, ::capnp::Text>>::disown(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestUseGenerics::Reader::hasGenericCap() const { + return !_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline bool TestUseGenerics::Builder::hasGenericCap() { + return !_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client TestUseGenerics::Reader::getGenericCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::get(_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client TestUseGenerics::Builder::getGenericCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::get(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client TestUseGenerics::Pipeline::getGenericCap() { + return ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client(_typeless.getPointerField(19).asCap()); +} +inline void TestUseGenerics::Builder::setGenericCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestUseGenerics::Builder::setGenericCap( ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), cap); +} +inline void TestUseGenerics::Builder::adoptGenericCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::adopt(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>> TestUseGenerics::Builder::disownGenericCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestGenerics< ::capnproto_test::capnp::test::TestAllTypes, ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::Interface< ::capnp::Data>>::disown(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestAnyPointerConstants::Reader::hasAnyKindAsStruct() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyPointerConstants::Builder::hasAnyKindAsStruct() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyPointer::Reader TestAnyPointerConstants::Reader::getAnyKindAsStruct() const { + return ::capnp::AnyPointer::Reader(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointerConstants::Builder::getAnyKindAsStruct() { + return ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointerConstants::Builder::initAnyKindAsStruct() { + auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestAnyPointerConstants::Reader::hasAnyStructAsStruct() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyPointerConstants::Builder::hasAnyStructAsStruct() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyStruct::Reader TestAnyPointerConstants::Reader::getAnyStructAsStruct() const { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyStruct::Builder TestAnyPointerConstants::Builder::getAnyStructAsStruct() { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnp::AnyStruct::Pipeline TestAnyPointerConstants::Pipeline::getAnyStructAsStruct() { + return ::capnp::AnyStruct::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestAnyPointerConstants::Builder::setAnyStructAsStruct( ::capnp::AnyStruct::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestAnyPointerConstants::Builder::initAnyStructAsStructAs() { + static_assert(::capnp::kind() == ::capnp::Kind::STRUCT, + "anyStructAsStruct must be a struct"); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestAnyPointerConstants::Builder::adoptAnyStructAsStruct( + ::capnp::Orphan< ::capnp::AnyStruct>&& value) { + ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::AnyStruct> TestAnyPointerConstants::Builder::disownAnyStructAsStruct() { + return ::capnp::_::PointerHelpers< ::capnp::AnyStruct>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestAnyPointerConstants::Reader::hasAnyKindAsList() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyPointerConstants::Builder::hasAnyKindAsList() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyPointer::Reader TestAnyPointerConstants::Reader::getAnyKindAsList() const { + return ::capnp::AnyPointer::Reader(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointerConstants::Builder::getAnyKindAsList() { + return ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestAnyPointerConstants::Builder::initAnyKindAsList() { + auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestAnyPointerConstants::Reader::hasAnyListAsList() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool TestAnyPointerConstants::Builder::hasAnyListAsList() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyList::Reader TestAnyPointerConstants::Reader::getAnyListAsList() const { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyList::Builder TestAnyPointerConstants::Builder::getAnyListAsList() { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void TestAnyPointerConstants::Builder::setAnyListAsList( ::capnp::AnyList::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::AnyList>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestAnyPointerConstants::Builder::initAnyListAsListAs(unsigned int size) { + static_assert(::capnp::kind() == ::capnp::Kind::LIST, + "anyListAsList must be a list"); + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void TestAnyPointerConstants::Builder::adoptAnyListAsList( + ::capnp::Orphan< ::capnp::AnyList>&& value) { + ::capnp::_::PointerHelpers< ::capnp::AnyList>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::AnyList> TestAnyPointerConstants::Builder::disownAnyListAsList() { + return ::capnp::_::PointerHelpers< ::capnp::AnyList>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +inline TestInterface::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestInterface::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestInterface::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestInterface::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestInterface::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestInterface::Client& TestInterface::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestInterface::Client& TestInterface::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline ::uint32_t TestInterface::FooParams::Reader::getI() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterface::FooParams::Builder::getI() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestInterface::FooParams::Builder::setI( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterface::FooParams::Reader::getJ() const { + return _reader.getDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS); +} + +inline bool TestInterface::FooParams::Builder::getJ() { + return _builder.getDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS); +} +inline void TestInterface::FooParams::Builder::setJ(bool value) { + _builder.setDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS, value); +} + +inline bool TestInterface::FooResults::Reader::hasX() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterface::FooResults::Builder::hasX() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterface::FooResults::Reader::getX() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterface::FooResults::Builder::getX() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestInterface::FooResults::Builder::setX( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterface::FooResults::Builder::initX(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestInterface::FooResults::Builder::adoptX( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterface::FooResults::Builder::disownX() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestInterface::BazParams::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestInterface::BazParams::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestInterface::BazParams::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestInterface::BazParams::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestInterface::BazParams::Pipeline::getS() { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestInterface::BazParams::Builder::setS( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestInterface::BazParams::Builder::initS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestInterface::BazParams::Builder::adoptS( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestInterface::BazParams::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +inline TestExtends::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestExtends::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestExtends::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestExtends::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestExtends::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestExtends::Client& TestExtends::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestExtends::Client& TestExtends::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +#if !CAPNP_LITE +inline TestExtends2::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestExtends2::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestExtends2::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestExtends2::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestExtends2::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestExtends2::Client& TestExtends2::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestExtends2::Client& TestExtends2::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +#if !CAPNP_LITE +inline TestPipeline::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestPipeline::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestPipeline::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestPipeline::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestPipeline::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestPipeline::Client& TestPipeline::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestPipeline::Client& TestPipeline::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline bool TestPipeline::Box::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::Box::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::Box::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::Box::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestPipeline::Box::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::Box::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestPipeline::AnyBox::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::AnyBox::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnp::Capability::Client TestPipeline::AnyBox::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestPipeline::AnyBox::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestPipeline::AnyBox::Pipeline::getCap() { + return ::capnp::Capability::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::AnyBox::Builder::setCap( ::capnp::Capability::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::AnyBox::Builder::setCap( ::capnp::Capability::Client& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestPipeline::AnyBox::Builder::adoptCap( + ::capnp::Orphan< ::capnp::Capability>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Capability> TestPipeline::AnyBox::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline ::uint32_t TestPipeline::GetCapParams::Reader::getN() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestPipeline::GetCapParams::Builder::getN() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestPipeline::GetCapParams::Builder::setN( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestPipeline::GetCapParams::Reader::hasInCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapParams::Builder::hasInCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Reader::getInCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Builder::getInCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Pipeline::getInCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::GetCapParams::Builder::setInCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::GetCapParams::Builder::setInCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestPipeline::GetCapParams::Builder::adoptInCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::GetCapParams::Builder::disownInCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestPipeline::GetCapResults::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapResults::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestPipeline::GetCapResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestPipeline::GetCapResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestPipeline::GetCapResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestPipeline::GetCapResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestPipeline::GetCapResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestPipeline::GetCapResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestPipeline::GetCapResults::Reader::hasOutBox() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapResults::Builder::hasOutBox() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Reader TestPipeline::GetCapResults::Reader::getOutBox() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder TestPipeline::GetCapResults::Builder::getOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline TestPipeline::GetCapResults::Pipeline::getOutBox() { + return ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestPipeline::GetCapResults::Builder::setOutBox( ::capnproto_test::capnp::test::TestPipeline::Box::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder TestPipeline::GetCapResults::Builder::initOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestPipeline::GetCapResults::Builder::adoptOutBox( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box> TestPipeline::GetCapResults::Builder::disownOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestPipeline::TestPointersParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::TestPointersParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::TestPointersParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestPipeline::TestPointersParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::TestPointersParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestPipeline::TestPointersParams::Reader::hasObj() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasObj() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyPointer::Reader TestPipeline::TestPointersParams::Reader::getObj() const { + return ::capnp::AnyPointer::Reader(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestPipeline::TestPointersParams::Builder::getObj() { + return ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestPipeline::TestPointersParams::Builder::initObj() { + auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestPipeline::TestPointersParams::Reader::hasList() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasList() { + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Reader TestPipeline::TestPointersParams::Reader::getList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Builder TestPipeline::TestPointersParams::Builder::getList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void TestPipeline::TestPointersParams::Builder::setList( ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>::Builder TestPipeline::TestPointersParams::Builder::initList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); +} +inline void TestPipeline::TestPointersParams::Builder::adoptList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>> TestPipeline::TestPointersParams::Builder::disownList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface, ::capnp::Kind::INTERFACE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline ::uint32_t TestPipeline::GetAnyCapParams::Reader::getN() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestPipeline::GetAnyCapParams::Builder::getN() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestPipeline::GetAnyCapParams::Builder::setN( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestPipeline::GetAnyCapParams::Reader::hasInCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetAnyCapParams::Builder::hasInCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnp::Capability::Client TestPipeline::GetAnyCapParams::Reader::getInCap() const { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestPipeline::GetAnyCapParams::Builder::getInCap() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Capability::Client TestPipeline::GetAnyCapParams::Pipeline::getInCap() { + return ::capnp::Capability::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::GetAnyCapParams::Builder::setInCap( ::capnp::Capability::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::GetAnyCapParams::Builder::setInCap( ::capnp::Capability::Client& cap) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestPipeline::GetAnyCapParams::Builder::adoptInCap( + ::capnp::Orphan< ::capnp::Capability>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Capability>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Capability> TestPipeline::GetAnyCapParams::Builder::disownInCap() { + return ::capnp::_::PointerHelpers< ::capnp::Capability>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestPipeline::GetAnyCapResults::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetAnyCapResults::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestPipeline::GetAnyCapResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestPipeline::GetAnyCapResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestPipeline::GetAnyCapResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestPipeline::GetAnyCapResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestPipeline::GetAnyCapResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestPipeline::GetAnyCapResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestPipeline::GetAnyCapResults::Reader::hasOutBox() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetAnyCapResults::Builder::hasOutBox() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Reader TestPipeline::GetAnyCapResults::Reader::getOutBox() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Builder TestPipeline::GetAnyCapResults::Builder::getOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Pipeline TestPipeline::GetAnyCapResults::Pipeline::getOutBox() { + return ::capnproto_test::capnp::test::TestPipeline::AnyBox::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void TestPipeline::GetAnyCapResults::Builder::setOutBox( ::capnproto_test::capnp::test::TestPipeline::AnyBox::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestPipeline::AnyBox::Builder TestPipeline::GetAnyCapResults::Builder::initOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestPipeline::GetAnyCapResults::Builder::adoptOutBox( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::AnyBox>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::AnyBox> TestPipeline::GetAnyCapResults::Builder::disownOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::AnyBox>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +inline TestCallOrder::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestCallOrder::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestCallOrder::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestCallOrder::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestCallOrder::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestCallOrder::Client& TestCallOrder::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client& TestCallOrder::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline ::uint32_t TestCallOrder::GetCallSequenceParams::Reader::getExpected() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestCallOrder::GetCallSequenceParams::Builder::getExpected() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestCallOrder::GetCallSequenceParams::Builder::setExpected( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint32_t TestCallOrder::GetCallSequenceResults::Reader::getN() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestCallOrder::GetCallSequenceResults::Builder::getN() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestCallOrder::GetCallSequenceResults::Builder::setN( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +#if !CAPNP_LITE +inline TestTailCallee::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestTailCallee::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestTailCallee::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestTailCallee::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestTailCallee::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestTailCallee::Client& TestTailCallee::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestTailCallee::Client& TestTailCallee::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline ::uint32_t TestTailCallee::TailResult::Reader::getI() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestTailCallee::TailResult::Builder::getI() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestTailCallee::TailResult::Builder::setI( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestTailCallee::TailResult::Reader::hasT() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTailCallee::TailResult::Builder::hasT() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestTailCallee::TailResult::Reader::getT() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestTailCallee::TailResult::Builder::getT() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestTailCallee::TailResult::Builder::setT( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestTailCallee::TailResult::Builder::initT(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestTailCallee::TailResult::Builder::adoptT( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestTailCallee::TailResult::Builder::disownT() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestTailCallee::TailResult::Reader::hasC() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTailCallee::TailResult::Builder::hasC() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestTailCallee::TailResult::Reader::getC() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestTailCallee::TailResult::Builder::getC() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestTailCallee::TailResult::Pipeline::getC() { + return ::capnproto_test::capnp::test::TestCallOrder::Client(_typeless.getPointerField(1).asCap()); +} +inline void TestTailCallee::TailResult::Builder::setC( ::capnproto_test::capnp::test::TestCallOrder::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestTailCallee::TailResult::Builder::setC( ::capnproto_test::capnp::test::TestCallOrder::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), cap); +} +inline void TestTailCallee::TailResult::Builder::adoptC( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> TestTailCallee::TailResult::Builder::disownC() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline ::int32_t TestTailCallee::FooParams::Reader::getI() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestTailCallee::FooParams::Builder::getI() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestTailCallee::FooParams::Builder::setI( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestTailCallee::FooParams::Reader::hasT() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTailCallee::FooParams::Builder::hasT() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestTailCallee::FooParams::Reader::getT() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestTailCallee::FooParams::Builder::getT() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestTailCallee::FooParams::Builder::setT( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestTailCallee::FooParams::Builder::initT(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestTailCallee::FooParams::Builder::adoptT( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestTailCallee::FooParams::Builder::disownT() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +#if !CAPNP_LITE +inline TestTailCaller::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestTailCaller::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestTailCaller::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestTailCaller::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestTailCaller::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestTailCaller::Client& TestTailCaller::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestTailCaller::Client& TestTailCaller::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline ::int32_t TestTailCaller::FooParams::Reader::getI() const { + return _reader.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int32_t TestTailCaller::FooParams::Builder::getI() { + return _builder.getDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestTailCaller::FooParams::Builder::setI( ::int32_t value) { + _builder.setDataField< ::int32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestTailCaller::FooParams::Reader::hasCallee() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTailCaller::FooParams::Builder::hasCallee() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestTailCallee::Client TestTailCaller::FooParams::Reader::getCallee() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestTailCallee::Client TestTailCaller::FooParams::Builder::getCallee() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestTailCallee::Client TestTailCaller::FooParams::Pipeline::getCallee() { + return ::capnproto_test::capnp::test::TestTailCallee::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestTailCaller::FooParams::Builder::setCallee( ::capnproto_test::capnp::test::TestTailCallee::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestTailCaller::FooParams::Builder::setCallee( ::capnproto_test::capnp::test::TestTailCallee::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestTailCaller::FooParams::Builder::adoptCallee( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestTailCallee>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestTailCallee> TestTailCaller::FooParams::Builder::disownCallee() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestTailCallee>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +inline TestHandle::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestHandle::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestHandle::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestHandle::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestHandle::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestHandle::Client& TestHandle::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestHandle::Client& TestHandle::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +#if !CAPNP_LITE +inline TestMoreStuff::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestMoreStuff::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestMoreStuff::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestMoreStuff::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestMoreStuff::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestMoreStuff::Client& TestMoreStuff::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestMoreStuff::Client& TestMoreStuff::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline bool TestMoreStuff::CallFooParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::CallFooParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::CallFooParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::CallFooParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::CallFooParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::CallFooParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::CallFooResults::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::CallFooResults::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::CallFooResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::CallFooResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::CallFooResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::CallFooResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::CallFooResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::CallFooResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::CallFooWhenResolvedParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::CallFooWhenResolvedParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooWhenResolvedParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooWhenResolvedParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::CallFooWhenResolvedParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::CallFooWhenResolvedParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::CallFooWhenResolvedParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::CallFooWhenResolvedParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::CallFooWhenResolvedParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::CallFooWhenResolvedResults::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::CallFooWhenResolvedResults::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::CallFooWhenResolvedResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::CallFooWhenResolvedResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::CallFooWhenResolvedResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::CallFooWhenResolvedResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::CallFooWhenResolvedResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::CallFooWhenResolvedResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::NeverReturnParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::NeverReturnParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::NeverReturnParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::NeverReturnParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::NeverReturnParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::NeverReturnParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::NeverReturnResults::Reader::hasCapCopy() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::NeverReturnResults::Builder::hasCapCopy() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnResults::Reader::getCapCopy() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnResults::Builder::getCapCopy() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::NeverReturnResults::Pipeline::getCapCopy() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::NeverReturnResults::Builder::setCapCopy( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::NeverReturnResults::Builder::setCapCopy( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::NeverReturnResults::Builder::adoptCapCopy( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::NeverReturnResults::Builder::disownCapCopy() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::HoldParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::HoldParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::HoldParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::HoldParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::HoldParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::HoldParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::HoldParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::HoldParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::HoldParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::CallHeldResults::Reader::hasS() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::CallHeldResults::Builder::hasS() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::CallHeldResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::CallHeldResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::CallHeldResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::CallHeldResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::CallHeldResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::CallHeldResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::GetHeldResults::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::GetHeldResults::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::GetHeldResults::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::GetHeldResults::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::GetHeldResults::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::GetHeldResults::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::GetHeldResults::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::GetHeldResults::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::GetHeldResults::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::EchoParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::EchoParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestCallOrder::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::EchoParams::Builder::setCap( ::capnproto_test::capnp::test::TestCallOrder::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::EchoParams::Builder::setCap( ::capnproto_test::capnp::test::TestCallOrder::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::EchoParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> TestMoreStuff::EchoParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::EchoResults::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::EchoResults::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoResults::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoResults::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestCallOrder::Client TestMoreStuff::EchoResults::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestCallOrder::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::EchoResults::Builder::setCap( ::capnproto_test::capnp::test::TestCallOrder::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::EchoResults::Builder::setCap( ::capnproto_test::capnp::test::TestCallOrder::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::EchoResults::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestCallOrder> TestMoreStuff::EchoResults::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestCallOrder>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::ExpectCancelParams::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::ExpectCancelParams::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::ExpectCancelParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::ExpectCancelParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::ExpectCancelParams::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::ExpectCancelParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::ExpectCancelParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::ExpectCancelParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::ExpectCancelParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::MethodWithDefaultsParams::Reader::hasA() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithDefaultsParams::Builder::hasA() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::MethodWithDefaultsParams::Reader::getA() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsParams::Builder::getA() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::MethodWithDefaultsParams::Builder::setA( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsParams::Builder::initA(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::MethodWithDefaultsParams::Builder::adoptA( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::MethodWithDefaultsParams::Builder::disownA() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint32_t TestMoreStuff::MethodWithDefaultsParams::Reader::getB() const { + return _reader.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 123u); +} + +inline ::uint32_t TestMoreStuff::MethodWithDefaultsParams::Builder::getB() { + return _builder.getDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 123u); +} +inline void TestMoreStuff::MethodWithDefaultsParams::Builder::setB( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value, 123u); +} + +inline bool TestMoreStuff::MethodWithDefaultsParams::Reader::hasC() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithDefaultsParams::Builder::hasC() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::MethodWithDefaultsParams::Reader::getC() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_99160a25fa50fbf1 + 65, 3); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsParams::Builder::getC() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_99160a25fa50fbf1 + 65, 3); +} +inline void TestMoreStuff::MethodWithDefaultsParams::Builder::setC( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsParams::Builder::initC(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::MethodWithDefaultsParams::Builder::adoptC( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::MethodWithDefaultsParams::Builder::disownC() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::MethodWithDefaultsResults::Reader::hasD() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithDefaultsResults::Builder::hasD() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::MethodWithDefaultsResults::Reader::getD() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsResults::Builder::getD() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::MethodWithDefaultsResults::Builder::setD( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsResults::Builder::initD(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::MethodWithDefaultsResults::Builder::adoptD( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::MethodWithDefaultsResults::Builder::disownD() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::MethodWithDefaultsResults::Reader::hasE() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithDefaultsResults::Builder::hasE() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::MethodWithDefaultsResults::Reader::getE() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9c7e066f845a6c56 + 50, 3); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsResults::Builder::getE() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), + ::capnp::schemas::bp_9c7e066f845a6c56 + 50, 3); +} +inline void TestMoreStuff::MethodWithDefaultsResults::Builder::setE( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithDefaultsResults::Builder::initE(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::MethodWithDefaultsResults::Builder::adoptE( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::MethodWithDefaultsResults::Builder::disownE() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::GetHandleResults::Reader::hasHandle() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::GetHandleResults::Builder::hasHandle() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestHandle::Client TestMoreStuff::GetHandleResults::Reader::getHandle() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestHandle::Client TestMoreStuff::GetHandleResults::Builder::getHandle() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestHandle::Client TestMoreStuff::GetHandleResults::Pipeline::getHandle() { + return ::capnproto_test::capnp::test::TestHandle::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::GetHandleResults::Builder::setHandle( ::capnproto_test::capnp::test::TestHandle::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::GetHandleResults::Builder::setHandle( ::capnproto_test::capnp::test::TestHandle::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::GetHandleResults::Builder::adoptHandle( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestHandle>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestHandle> TestMoreStuff::GetHandleResults::Builder::disownHandle() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestHandle>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::GetNullResults::Reader::hasNullCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::GetNullResults::Builder::hasNullCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMoreStuff::Client TestMoreStuff::GetNullResults::Reader::getNullCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMoreStuff::Client TestMoreStuff::GetNullResults::Builder::getNullCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMoreStuff::Client TestMoreStuff::GetNullResults::Pipeline::getNullCap() { + return ::capnproto_test::capnp::test::TestMoreStuff::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMoreStuff::GetNullResults::Builder::setNullCap( ::capnproto_test::capnp::test::TestMoreStuff::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::GetNullResults::Builder::setNullCap( ::capnproto_test::capnp::test::TestMoreStuff::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::GetNullResults::Builder::adoptNullCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMoreStuff>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMoreStuff> TestMoreStuff::GetNullResults::Builder::disownNullCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMoreStuff>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMoreStuff::GetEnormousStringResults::Reader::hasStr() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::GetEnormousStringResults::Builder::hasStr() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::GetEnormousStringResults::Reader::getStr() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::GetEnormousStringResults::Builder::getStr() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::GetEnormousStringResults::Builder::setStr( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::GetEnormousStringResults::Builder::initStr(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::GetEnormousStringResults::Builder::adoptStr( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::GetEnormousStringResults::Builder::disownStr() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::MethodWithNullDefaultParams::Reader::hasA() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithNullDefaultParams::Builder::hasA() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMoreStuff::MethodWithNullDefaultParams::Reader::getA() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithNullDefaultParams::Builder::getA() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMoreStuff::MethodWithNullDefaultParams::Builder::setA( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMoreStuff::MethodWithNullDefaultParams::Builder::initA(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMoreStuff::MethodWithNullDefaultParams::Builder::adoptA( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMoreStuff::MethodWithNullDefaultParams::Builder::disownA() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMoreStuff::MethodWithNullDefaultParams::Reader::hasB() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMoreStuff::MethodWithNullDefaultParams::Builder::hasB() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::MethodWithNullDefaultParams::Reader::getB() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::MethodWithNullDefaultParams::Builder::getB() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestMoreStuff::MethodWithNullDefaultParams::Pipeline::getB() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(1).asCap()); +} +inline void TestMoreStuff::MethodWithNullDefaultParams::Builder::setB( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMoreStuff::MethodWithNullDefaultParams::Builder::setB( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), cap); +} +inline void TestMoreStuff::MethodWithNullDefaultParams::Builder::adoptB( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestMoreStuff::MethodWithNullDefaultParams::Builder::disownB() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +inline TestMembrane::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestMembrane::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestMembrane::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestMembrane::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestMembrane::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestMembrane::Client& TestMembrane::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestMembrane::Client& TestMembrane::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +#if !CAPNP_LITE +inline TestMembrane::Thing::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestMembrane::Thing::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestMembrane::Thing::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestMembrane::Thing::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestMembrane::Thing::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client& TestMembrane::Thing::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client& TestMembrane::Thing::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline bool TestMembrane::Result::Reader::hasText() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::Result::Builder::hasText() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestMembrane::Result::Reader::getText() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestMembrane::Result::Builder::getText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestMembrane::Result::Builder::setText( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestMembrane::Result::Builder::initText(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestMembrane::Result::Builder::adoptText( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestMembrane::Result::Builder::disownText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestMembrane::MakeThingResults::Reader::hasThing() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::MakeThingResults::Builder::hasThing() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::MakeThingResults::Reader::getThing() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::MakeThingResults::Builder::getThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::MakeThingResults::Pipeline::getThing() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMembrane::MakeThingResults::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMembrane::MakeThingResults::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMembrane::MakeThingResults::Builder::adoptThing( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestMembrane::MakeThingResults::Builder::disownThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMembrane::CallPassThroughParams::Reader::hasThing() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::CallPassThroughParams::Builder::hasThing() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallPassThroughParams::Reader::getThing() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallPassThroughParams::Builder::getThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallPassThroughParams::Pipeline::getThing() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMembrane::CallPassThroughParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMembrane::CallPassThroughParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMembrane::CallPassThroughParams::Builder::adoptThing( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestMembrane::CallPassThroughParams::Builder::disownThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMembrane::CallPassThroughParams::Reader::getTailCall() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestMembrane::CallPassThroughParams::Builder::getTailCall() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestMembrane::CallPassThroughParams::Builder::setTailCall(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestMembrane::CallInterceptParams::Reader::hasThing() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::CallInterceptParams::Builder::hasThing() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallInterceptParams::Reader::getThing() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallInterceptParams::Builder::getThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::CallInterceptParams::Pipeline::getThing() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMembrane::CallInterceptParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMembrane::CallInterceptParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMembrane::CallInterceptParams::Builder::adoptThing( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestMembrane::CallInterceptParams::Builder::disownThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMembrane::CallInterceptParams::Reader::getTailCall() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool TestMembrane::CallInterceptParams::Builder::getTailCall() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestMembrane::CallInterceptParams::Builder::setTailCall(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool TestMembrane::LoopbackParams::Reader::hasThing() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::LoopbackParams::Builder::hasThing() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackParams::Reader::getThing() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackParams::Builder::getThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackParams::Pipeline::getThing() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMembrane::LoopbackParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMembrane::LoopbackParams::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMembrane::LoopbackParams::Builder::adoptThing( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestMembrane::LoopbackParams::Builder::disownThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestMembrane::LoopbackResults::Reader::hasThing() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestMembrane::LoopbackResults::Builder::hasThing() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackResults::Reader::getThing() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackResults::Builder::getThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestMembrane::LoopbackResults::Pipeline::getThing() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestMembrane::LoopbackResults::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestMembrane::LoopbackResults::Builder::setThing( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestMembrane::LoopbackResults::Builder::adoptThing( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestMembrane::LoopbackResults::Builder::disownThing() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestContainMembrane::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestContainMembrane::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestContainMembrane::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestContainMembrane::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestMembrane::Thing::Client TestContainMembrane::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestMembrane::Thing::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestContainMembrane::Builder::setCap( ::capnproto_test::capnp::test::TestMembrane::Thing::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestContainMembrane::Builder::setCap( ::capnproto_test::capnp::test::TestMembrane::Thing::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), cap); +} +inline void TestContainMembrane::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestMembrane::Thing> TestContainMembrane::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestMembrane::Thing>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestContainMembrane::Reader::hasList() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestContainMembrane::Builder::hasList() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Reader TestContainMembrane::Reader::getList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Builder TestContainMembrane::Builder::getList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void TestContainMembrane::Builder::setList( ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>::Builder TestContainMembrane::Builder::initList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void TestContainMembrane::Builder::adoptList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>> TestContainMembrane::Builder::disownList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestMembrane::Thing, ::capnp::Kind::INTERFACE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +inline bool TestTransferCap::Reader::hasList() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTransferCap::Builder::hasList() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Reader TestTransferCap::Reader::getList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Builder TestTransferCap::Builder::getList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestTransferCap::Builder::setList( ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>::Builder TestTransferCap::Builder::initList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestTransferCap::Builder::adoptList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>> TestTransferCap::Builder::disownList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestTransferCap::Element, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestTransferCap::Element::Reader::hasText() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTransferCap::Element::Builder::hasText() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestTransferCap::Element::Reader::getText() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestTransferCap::Element::Builder::getText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestTransferCap::Element::Builder::setText( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestTransferCap::Element::Builder::initText(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestTransferCap::Element::Builder::adoptText( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestTransferCap::Element::Builder::disownText() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestTransferCap::Element::Reader::hasCap() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestTransferCap::Element::Builder::hasCap() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestInterface::Client TestTransferCap::Element::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestTransferCap::Element::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestTransferCap::Element::Pipeline::getCap() { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(1).asCap()); +} +inline void TestTransferCap::Element::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestTransferCap::Element::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), cap); +} +inline void TestTransferCap::Element::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestTransferCap::Element::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +inline TestKeywordMethods::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline TestKeywordMethods::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline TestKeywordMethods::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline TestKeywordMethods::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline TestKeywordMethods::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::TestKeywordMethods::Client& TestKeywordMethods::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::TestKeywordMethods::Client& TestKeywordMethods::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +#if !CAPNP_LITE +template +inline TestAuthenticatedBootstrap::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +template +inline TestAuthenticatedBootstrap::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +template +inline TestAuthenticatedBootstrap::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +template +inline TestAuthenticatedBootstrap::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +template +inline TestAuthenticatedBootstrap::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +template +inline typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::Client& TestAuthenticatedBootstrap::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +template +inline typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::Client& TestAuthenticatedBootstrap::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +// TestAuthenticatedBootstrap::GetCallerIdParams +template +constexpr uint16_t TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::brandScopes[] = { + { 0xea72cc77253798cd, brandBindings + 0, 1, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_8ec30e2451f1cffe, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +template +inline bool TestAuthenticatedBootstrap::GetCallerIdResults::Reader::hasCaller() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline bool TestAuthenticatedBootstrap::GetCallerIdResults::Builder::hasCaller() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +template +inline ::capnp::ReaderFor TestAuthenticatedBootstrap::GetCallerIdResults::Reader::getCaller() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestAuthenticatedBootstrap::GetCallerIdResults::Builder::getCaller() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +template +inline ::capnp::PipelineFor TestAuthenticatedBootstrap::GetCallerIdResults::Pipeline::getCaller() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +template +inline void TestAuthenticatedBootstrap::GetCallerIdResults::Builder::setCaller( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +template +inline ::capnp::BuilderFor TestAuthenticatedBootstrap::GetCallerIdResults::Builder::initCaller() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +template +inline ::capnp::BuilderFor TestAuthenticatedBootstrap::GetCallerIdResults::Builder::initCaller(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +template +inline void TestAuthenticatedBootstrap::GetCallerIdResults::Builder::adoptCaller( + ::capnp::Orphan&& value) { + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +template +inline ::capnp::Orphan TestAuthenticatedBootstrap::GetCallerIdResults::Builder::disownCaller() { + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +// TestAuthenticatedBootstrap::GetCallerIdResults +template +constexpr uint16_t TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::dataWordSize; +template +constexpr uint16_t TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::pointerCount; +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::brandScopes[] = { + { 0xea72cc77253798cd, brandBindings + 0, 1, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_c71cf776034a3e67, brandScopes, nullptr, + 1, 0, nullptr +}; +#endif // !CAPNP_LITE + +#if !CAPNP_LITE +template +CAPNP_AUTO_IF_MSVC(::capnp::Request::GetCallerIdParams, typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults>) +TestAuthenticatedBootstrap::Client::getCallerIdRequest(::kj::Maybe< ::capnp::MessageSize> sizeHint) { + return newCall::GetCallerIdParams, typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults>( + 0xea72cc77253798cdull, 0, sizeHint); +} +template +::kj::Promise TestAuthenticatedBootstrap::Server::getCallerId(GetCallerIdContext) { + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestAuthenticatedBootstrap", "getCallerId", + 0xea72cc77253798cdull, 0); +} +template +::kj::Promise TestAuthenticatedBootstrap::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (interfaceId) { + case 0xea72cc77253798cdull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("test.capnp:TestAuthenticatedBootstrap", interfaceId); + } +} +template +::kj::Promise TestAuthenticatedBootstrap::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { + switch (methodId) { + case 0: + return getCallerId(::capnp::Capability::Server::internalGetTypedContext< + typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdParams, typename ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults>(context)); + default: + (void)context; + return ::capnp::Capability::Server::internalUnimplemented( + "test.capnp:TestAuthenticatedBootstrap", + 0xea72cc77253798cdull, methodId); + } +} +#endif // !CAPNP_LITE + +// TestAuthenticatedBootstrap +#if !CAPNP_LITE +template +constexpr ::capnp::Kind TestAuthenticatedBootstrap::_capnpPrivate::kind; +template +constexpr ::capnp::_::RawSchema const* TestAuthenticatedBootstrap::_capnpPrivate::schema; +template +const ::capnp::_::RawBrandedSchema::Scope TestAuthenticatedBootstrap::_capnpPrivate::brandScopes[] = { + { 0xea72cc77253798cd, brandBindings + 0, 1, false}, +}; +template +const ::capnp::_::RawBrandedSchema::Binding TestAuthenticatedBootstrap::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), +}; +template +const ::capnp::_::RawBrandedSchema::Dependency TestAuthenticatedBootstrap::_capnpPrivate::brandDependencies[] = { + { 33554432, ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdParams::_capnpPrivate::brand() }, + { 50331648, ::capnproto_test::capnp::test::TestAuthenticatedBootstrap::GetCallerIdResults::_capnpPrivate::brand() }, +}; +template +const ::capnp::_::RawBrandedSchema TestAuthenticatedBootstrap::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_ea72cc77253798cd, brandScopes, brandDependencies, + 1, 2, nullptr +}; +#endif // !CAPNP_LITE + +inline bool TestSturdyRef::Reader::hasHostId() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestSturdyRef::Builder::hasHostId() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Reader TestSturdyRef::Reader::getHostId() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Builder TestSturdyRef::Builder::getHostId() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Pipeline TestSturdyRef::Pipeline::getHostId() { + return ::capnproto_test::capnp::test::TestSturdyRefHostId::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void TestSturdyRef::Builder::setHostId( ::capnproto_test::capnp::test::TestSturdyRefHostId::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestSturdyRefHostId::Builder TestSturdyRef::Builder::initHostId() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestSturdyRef::Builder::adoptHostId( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestSturdyRefHostId>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestSturdyRefHostId> TestSturdyRef::Builder::disownHostId() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestSturdyRefHostId>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool TestSturdyRef::Reader::hasObjectId() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool TestSturdyRef::Builder::hasObjectId() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::AnyPointer::Reader TestSturdyRef::Reader::getObjectId() const { + return ::capnp::AnyPointer::Reader(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestSturdyRef::Builder::getObjectId() { + return ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::AnyPointer::Builder TestSturdyRef::Builder::initObjectId() { + auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestSturdyRefHostId::Reader::hasHost() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool TestSturdyRefHostId::Builder::hasHost() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestSturdyRefHostId::Reader::getHost() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestSturdyRefHostId::Builder::getHost() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void TestSturdyRefHostId::Builder::setHost( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestSturdyRefHostId::Builder::initHost(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); +} +inline void TestSturdyRefHostId::Builder::adoptHost( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestSturdyRefHostId::Builder::disownHost() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag TestSturdyRefObjectId::Reader::getTag() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag TestSturdyRefObjectId::Builder::getTag() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TestSturdyRefObjectId::Builder::setTag( ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::RenamedStruct::Which RenamedStruct::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::RenamedStruct::Which RenamedStruct::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline bool RenamedStruct::Reader::isGoodFieldName() const { + return which() == RenamedStruct::GOOD_FIELD_NAME; +} +inline bool RenamedStruct::Builder::isGoodFieldName() { + return which() == RenamedStruct::GOOD_FIELD_NAME; +} +inline bool RenamedStruct::Reader::getGoodFieldName() const { + KJ_IREQUIRE((which() == RenamedStruct::GOOD_FIELD_NAME), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool RenamedStruct::Builder::getGoodFieldName() { + KJ_IREQUIRE((which() == RenamedStruct::GOOD_FIELD_NAME), + "Must check which() before get()ing a union member."); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::Builder::setGoodFieldName(bool value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, RenamedStruct::GOOD_FIELD_NAME); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool RenamedStruct::Reader::isBar() const { + return which() == RenamedStruct::BAR; +} +inline bool RenamedStruct::Builder::isBar() { + return which() == RenamedStruct::BAR; +} +inline ::int8_t RenamedStruct::Reader::getBar() const { + KJ_IREQUIRE((which() == RenamedStruct::BAR), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::int8_t RenamedStruct::Builder::getBar() { + KJ_IREQUIRE((which() == RenamedStruct::BAR), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::Builder::setBar( ::int8_t value) { + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, RenamedStruct::BAR); + _builder.setDataField< ::int8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum RenamedStruct::Reader::getAnotherGoodFieldName() const { + return _reader.getDataField< ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum RenamedStruct::Builder::getAnotherGoodFieldName() { + return _builder.getDataField< ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::Builder::setAnotherGoodFieldName( ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::RenamedStruct::RenamedEnum>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline typename RenamedStruct::RenamedUnion::Reader RenamedStruct::Reader::getRenamedUnion() const { + return typename RenamedStruct::RenamedUnion::Reader(_reader); +} +inline typename RenamedStruct::RenamedUnion::Builder RenamedStruct::Builder::getRenamedUnion() { + return typename RenamedStruct::RenamedUnion::Builder(_builder); +} +#if !CAPNP_LITE +inline typename RenamedStruct::RenamedUnion::Pipeline RenamedStruct::Pipeline::getRenamedUnion() { + return typename RenamedStruct::RenamedUnion::Pipeline(_typeless.noop()); +} +#endif // !CAPNP_LITE +inline typename RenamedStruct::RenamedUnion::Builder RenamedStruct::Builder::initRenamedUnion() { + _builder.setDataField< ::uint16_t>(::capnp::bounded<3>() * ::capnp::ELEMENTS, 0); + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear(); + return typename RenamedStruct::RenamedUnion::Builder(_builder); +} +inline bool RenamedStruct::RenamedNestedStruct::Reader::getGoodNestedFieldName() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline bool RenamedStruct::RenamedNestedStruct::Builder::getGoodNestedFieldName() { + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::RenamedNestedStruct::Builder::setGoodNestedFieldName(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline bool RenamedStruct::RenamedNestedStruct::Reader::hasAnotherGoodNestedFieldName() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool RenamedStruct::RenamedNestedStruct::Builder::hasAnotherGoodNestedFieldName() { + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader RenamedStruct::RenamedNestedStruct::Reader::getAnotherGoodNestedFieldName() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder RenamedStruct::RenamedNestedStruct::Builder::getAnotherGoodNestedFieldName() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Pipeline RenamedStruct::RenamedNestedStruct::Pipeline::getAnotherGoodNestedFieldName() { + return ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void RenamedStruct::RenamedNestedStruct::Builder::setAnotherGoodNestedFieldName( ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder RenamedStruct::RenamedNestedStruct::Builder::initAnotherGoodNestedFieldName() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void RenamedStruct::RenamedNestedStruct::Builder::adoptAnotherGoodNestedFieldName( + ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct> RenamedStruct::RenamedNestedStruct::Builder::disownAnotherGoodNestedFieldName() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedUnion::Which RenamedStruct::RenamedUnion::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedUnion::Which RenamedStruct::RenamedUnion::Builder::which() { + return _builder.getDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS); +} + +inline bool RenamedStruct::RenamedUnion::Reader::isRenamedGroup() const { + return which() == RenamedStruct::RenamedUnion::RENAMED_GROUP; +} +inline bool RenamedStruct::RenamedUnion::Builder::isRenamedGroup() { + return which() == RenamedStruct::RenamedUnion::RENAMED_GROUP; +} +inline typename RenamedStruct::RenamedUnion::RenamedGroup::Reader RenamedStruct::RenamedUnion::Reader::getRenamedGroup() const { + KJ_IREQUIRE((which() == RenamedStruct::RenamedUnion::RENAMED_GROUP), + "Must check which() before get()ing a union member."); + return typename RenamedStruct::RenamedUnion::RenamedGroup::Reader(_reader); +} +inline typename RenamedStruct::RenamedUnion::RenamedGroup::Builder RenamedStruct::RenamedUnion::Builder::getRenamedGroup() { + KJ_IREQUIRE((which() == RenamedStruct::RenamedUnion::RENAMED_GROUP), + "Must check which() before get()ing a union member."); + return typename RenamedStruct::RenamedUnion::RenamedGroup::Builder(_builder); +} +inline typename RenamedStruct::RenamedUnion::RenamedGroup::Builder RenamedStruct::RenamedUnion::Builder::initRenamedGroup() { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, RenamedStruct::RenamedUnion::RENAMED_GROUP); + return typename RenamedStruct::RenamedUnion::RenamedGroup::Builder(_builder); +} +inline bool RenamedStruct::RenamedUnion::Reader::isQux() const { + return which() == RenamedStruct::RenamedUnion::QUX; +} +inline bool RenamedStruct::RenamedUnion::Builder::isQux() { + return which() == RenamedStruct::RenamedUnion::QUX; +} +inline bool RenamedStruct::RenamedUnion::Reader::hasQux() const { + if (which() != RenamedStruct::RenamedUnion::QUX) return false; + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline bool RenamedStruct::RenamedUnion::Builder::hasQux() { + if (which() != RenamedStruct::RenamedUnion::QUX) return false; + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader RenamedStruct::RenamedUnion::Reader::getQux() const { + KJ_IREQUIRE((which() == RenamedStruct::RenamedUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder RenamedStruct::RenamedUnion::Builder::getQux() { + KJ_IREQUIRE((which() == RenamedStruct::RenamedUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void RenamedStruct::RenamedUnion::Builder::setQux( ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Reader value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, RenamedStruct::RenamedUnion::QUX); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct::Builder RenamedStruct::RenamedUnion::Builder::initQux() { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, RenamedStruct::RenamedUnion::QUX); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void RenamedStruct::RenamedUnion::Builder::adoptQux( + ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>&& value) { + _builder.setDataField( + ::capnp::bounded<3>() * ::capnp::ELEMENTS, RenamedStruct::RenamedUnion::QUX); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct> RenamedStruct::RenamedUnion::Builder::disownQux() { + KJ_IREQUIRE((which() == RenamedStruct::RenamedUnion::QUX), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::RenamedStruct::RenamedNestedStruct>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::capnp::Void RenamedStruct::RenamedUnion::RenamedGroup::Reader::getFoo() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void RenamedStruct::RenamedUnion::RenamedGroup::Builder::getFoo() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::RenamedUnion::RenamedGroup::Builder::setFoo( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::capnp::Void RenamedStruct::RenamedUnion::RenamedGroup::Reader::getBar() const { + return _reader.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::capnp::Void RenamedStruct::RenamedUnion::RenamedGroup::Builder::getBar() { + return _builder.getDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedStruct::RenamedUnion::RenamedGroup::Builder::setBar( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +#if !CAPNP_LITE +inline RenamedInterface::Client::Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} +inline RenamedInterface::Client::Client( + ::kj::Own< ::capnp::ClientHook>&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} +template +inline RenamedInterface::Client::Client(::kj::Own<_t>&& server) + : ::capnp::Capability::Client(::kj::mv(server)) {} +template +inline RenamedInterface::Client::Client(::kj::Promise<_t>&& promise) + : ::capnp::Capability::Client(::kj::mv(promise)) {} +inline RenamedInterface::Client::Client(::kj::Exception&& exception) + : ::capnp::Capability::Client(::kj::mv(exception)) {} +inline ::capnproto_test::capnp::test::RenamedInterface::Client& RenamedInterface::Client::operator=(Client& other) { + ::capnp::Capability::Client::operator=(other); + return *this; +} +inline ::capnproto_test::capnp::test::RenamedInterface::Client& RenamedInterface::Client::operator=(Client&& other) { + ::capnp::Capability::Client::operator=(kj::mv(other)); + return *this; +} + +#endif // !CAPNP_LITE +inline ::uint8_t RenamedInterface::RenamedMethodParams::Reader::getRenamedParam() const { + return _reader.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint8_t RenamedInterface::RenamedMethodParams::Builder::getRenamedParam() { + return _builder.getDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void RenamedInterface::RenamedMethodParams::Builder::setRenamedParam( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +} // namespace +} // namespace +} // namespace + diff --git a/CapnpCompatTest/testdata/annotated-json.binary b/CapnpCompatTest/testdata/annotated-json.binary new file mode 100644 index 0000000..6c54755 Binary files /dev/null and b/CapnpCompatTest/testdata/annotated-json.binary differ diff --git a/CapnpCompatTest/testdata/annotated.json b/CapnpCompatTest/testdata/annotated.json new file mode 100644 index 0000000..bb51400 --- /dev/null +++ b/CapnpCompatTest/testdata/annotated.json @@ -0,0 +1,22 @@ +{ "names-can_contain!anything Really": "foo", + "flatFoo": 123, + "flatBar": "abc", + "renamed-flatBaz": {"hello": true}, + "flatQux": "cba", + "pfx.foo": "this is a long string in order to force multi-line pretty printing", + "pfx.renamed-bar": 321, + "pfx.baz": {"hello": true}, + "pfx.xfp.qux": "fed", + "union-type": "renamed-bar", + "barMember": 789, + "multiMember": "ghi", + "dependency": {"renamed-foo": "corge"}, + "simpleGroup": {"renamed-grault": "garply"}, + "enums": ["qux", "renamed-bar", "foo", "renamed-baz"], + "innerJson": [123, "hello", {"object": true}], + "testBase64": "ZnJlZA==", + "testHex": "706c756768", + "bUnion": "renamed-bar", + "bValue": 678, + "externalUnion": {"type": "bar", "value": "cba"}, + "unionWithVoid": {"type": "voidValue"} } diff --git a/CapnpCompatTest/testdata/binary b/CapnpCompatTest/testdata/binary new file mode 100644 index 0000000..ea39763 Binary files /dev/null and b/CapnpCompatTest/testdata/binary differ diff --git a/CapnpCompatTest/testdata/errors.capnp.nobuild b/CapnpCompatTest/testdata/errors.capnp.nobuild new file mode 100644 index 0000000..a909e97 --- /dev/null +++ b/CapnpCompatTest/testdata/errors.capnp.nobuild @@ -0,0 +1,161 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +# This file is intended to test that various error cases are detected as errors. The error +# output is matched against a golden file. The file name has the .nobuild extension to make +# sure that a build system which automatically builds .capnp files does not try to build this one. + +# + +@0xccd0890aa4926a9b; +# Can't really test the missing-ID error because the output is intentionally unpredictable. + +const notType :Int32 = 123; +annotation notFieldAnnotation(struct) :Int32; +annotation fieldAnnotation(field) :Int32; + +struct Foo { + dupName @0 :Int32; + dupName @1 :Int32; + dupNumber1 @2 :Int32; + dupNumber2 @2 :Int32; + + missingNumber @4 :Int32; + next @5 :Int32; + + emptyUnion :union {} + emptyGroup :group {} + + singletonUnion :union { + field @6 :Int32; + } + + union { + dupName @7 :Int32; + f8 @8 :Int32; + } + union { + f9 @9 :Int32; + f10 @10 :Int32; + } + + struct wrongTypeStyle {} + WrongFieldStyle @11 :Int32; + under_score @12 :Int32; + + containsStruct :group { + f13 @13 :Int32; + struct CantNestHere {} + } + + retroUnion @16! :union { + f14 @14 :Int32; + f15 @15 :Int32; + } + + missingColonAndEclamation @18 union { + f19 @19 :Int32; + f20 @20 :Int32; + } + + missingExclamation @21 :union { + f22 @22 :Int32; + f23 @23 :Int32; + } + + missingColon @24! union { + f19 @25 :Int32; + f20 @26 :Int32; + } + + unnamedInNamed :union { + f27 @27 :Int32; + f28 @28 :Int32; + union { + # content is ignored + } + } + + listWithoutParam @31 :List; + listWithTooManyParams @32 :List(Int32, Int64); + listAnyPointer @33 :List(AnyPointer); + notAType @34 :notType; + noParams @35 :Foo(Int32); + + defaultOutOfRange @36 :Int16 = 1234567; + defaultOutOfRange2 @37 :UInt16 = -1; + defaultWrongType @38 :Text = 123; + defaultWrongType2 @39 :Text = [123]; + defaultWrongType3 @40 :Text = (foo = 123, bar = 456); + defaultTooBigToBeNegative @41 :Int64 = -0x8000000000000001; + defaultNotConstant @42 :Int32 = .Foo; + defaultConstantNotQualified @43 :Int32 = notType; + + notAnnotation @44 :Int32 $Foo(123); + badAnnotation @45 :Int32 $notFieldAnnotation(123); + notVoidAnnotation @46 :Int32 $fieldAnnotation; + + undefinedImport @17 :import "noshuchfile.capnp".Bar; + undefinedAbsolute @47 : .NoSuch; + undefinedRelative @29 :NoSuch; + undefinedMember @30 :Foo.NoSuch; +} + +struct Bar { + x @3 :Text; + someGroup :group { + defaultMissingFieldName @2 :Bar = (x = "abcd", 456); + defaultNoSuchField @0 :Bar = (nosuchfield = 123); + defaultGroupMismatch @1 :Bar = (someGroup = 123); + } +} + + +using Bar; + +enum DupEnumerants { + dupName @0; + dupName @1; + dupNumber1 @2; + dupNumber2 @2; +} + +const recursive: UInt32 = .recursive; + +struct Generic(T, U) { +} + +struct UseGeneric { + tooFew @0 :Generic(Text); + tooMany @1 :Generic(Text, Data, List(Int32)); + doubleBind @2 :Generic(Text, Data)(Data, Text); + primitiveBinding @3 :Generic(Text, Int32); +} + +const embedBadType :UInt32 = embed "binary"; +const embedNoSuchFile :Data = embed "no-such-file"; + +using Baz = import "nosuchfile-unused.capnp".Baz; +# Check that an import in an unused `using` still reports error. + +interface TestInterface { + foo @0 (a :UInt32 = null); +} diff --git a/CapnpCompatTest/testdata/errors.txt b/CapnpCompatTest/testdata/errors.txt new file mode 100644 index 0000000..ed238e4 --- /dev/null +++ b/CapnpCompatTest/testdata/errors.txt @@ -0,0 +1,60 @@ +file:74:30-32: error: As of Cap'n Proto v0.3, it is no longer necessary to assign numbers to unions. However, removing the number will break binary compatibility. If this is an old protocol and you need to retain compatibility, please add an exclamation point after the number to indicate that it is really needed, e.g. `foo @1! :union {`. If this is a new protocol or compatibility doesn't matter, just remove the @n entirely. Sorry for the inconvenience, and thanks for being an early adopter! :) +file:74:30-32: error: As of Cap'n Proto v0.3, the 'union' keyword should be prefixed with a colon for named unions, e.g. `foo :union {`. +file:79:23-25: error: As of Cap'n Proto v0.3, it is no longer necessary to assign numbers to unions. However, removing the number will break binary compatibility. If this is an old protocol and you need to retain compatibility, please add an exclamation point after the number to indicate that it is really needed, e.g. `foo @1! :union {`. If this is a new protocol or compatibility doesn't matter, just remove the @n entirely. Sorry for the inconvenience, and thanks for being an early adopter! :) +file:84:17-19: error: As of Cap'n Proto v0.3, the 'union' keyword should be prefixed with a colon for named unions, e.g. `foo :union {`. +file:132:7-10: error: 'using' declaration without '=' must specify a named declaration from a different scope. +file:37:3-10: error: 'dupName' is already defined in this scope. +file:36:3-10: error: 'dupName' previously defined here. +file:52:5-12: error: 'dupName' is already defined in this scope. +file:36:3-10: error: 'dupName' previously defined here. +file:55:3-8: error: An unnamed union is already defined in this scope. +file:51:3-8: error: Previously defined here. +file:60:10-24: error: Type names must begin with a capital letter. +file:61:3-18: error: Non-type names must begin with a lower-case letter. +file:62:3-14: error: Cap'n Proto declaration names should use camelCase and must not contain underscores. (Code generators may convert names to the appropriate style for the target language.) +file:66:5-27: error: This kind of declaration doesn't belong here. +file:44:3-23: error: Union must have at least two members. +file:45:3-23: error: Group must have at least one member. +file:47: error: Union must have at least two members. +file:92: error: Unions cannot contain unnamed unions. +file:39:15-16: error: Duplicate ordinal number. +file:38:15-16: error: Ordinal @2 originally used here. +file:41:18-19: error: Skipped ordinal @3. Ordinals must be sequential with no holes. +file:69:15-17: error: Union ordinal, if specified, must be greater than no more than one of its member ordinals (i.e. there can only be one field retroactively unionized). +file:116:31-50: error: Import failed: noshuchfile.capnp +file:118:26-32: error: Not defined: NoSuch +file:119:28-34: error: 'Foo' has no member named 'NoSuch' +file:97:25-29: error: 'List' requires exactly one parameter. +file:98:30-48: error: Too many generic parameters. +file:98:30-34: error: 'List' requires exactly one parameter. +file:99:23-39: error: 'List(AnyPointer)' is not supported. +file:100:17-24: error: 'notType' is not a type. +file:101:17-27: error: Declaration does not accept generic parameters. +file:103:34-41: error: Integer value out of range. +file:104:37-38: error: Integer value out of range. +file:105:32-35: error: Type mismatch; expected Text. +file:106:33-38: error: Type mismatch; expected Text. +file:107:33-55: error: Type mismatch; expected Text. +file:108:43-61: error: Integer is too big to be negative. +file:109:35-39: error: '.Foo' does not refer to a constant. +file:110:44-51: error: Constant names must be qualified to avoid confusion. Please replace 'notType' with '.notType', if that's what you intended. +file:117:28-34: error: Not defined: NoSuch +file:112:29-32: error: 'Foo' is not an annotation. +file:113:29-47: error: 'notFieldAnnotation' cannot be applied to this kind of declaration. +file:114:33-48: error: 'fieldAnnotation' requires a value. +file:126:35-46: error: Struct has no field named 'nosuchfield'. +file:127:49-52: error: Type mismatch; expected group. +file:125:52-55: error: Missing field name. +file:136:3-10: error: 'dupName' is already defined in this scope. +file:135:3-10: error: 'dupName' previously defined here. +file:138:15-16: error: Duplicate ordinal number. +file:137:15-16: error: Ordinal @2 originally used here. +file:141:7-16: error: Declaration recursively depends on itself. +file:147:14-27: error: Not enough generic parameters. +file:148:15-47: error: Too many generic parameters. +file:149:18-49: error: Double-application of generic parameters. +file:150:38-43: error: Sorry, only pointer types can be used as generic parameters. +file:153:30-44: error: Embeds can only be used when Text, Data, or a struct is expected. +file:154:37-51: error: Couldn't read file for embed: no-such-file +file:160:23-27: error: Only pointer parameters can declare their default as 'null'. +file:156:20-45: error: Import failed: nosuchfile-unused.capnp diff --git a/CapnpCompatTest/testdata/flat b/CapnpCompatTest/testdata/flat new file mode 100644 index 0000000..427fc31 Binary files /dev/null and b/CapnpCompatTest/testdata/flat differ diff --git a/CapnpCompatTest/testdata/lists.binary b/CapnpCompatTest/testdata/lists.binary new file mode 100644 index 0000000..30ae630 Binary files /dev/null and b/CapnpCompatTest/testdata/lists.binary differ diff --git a/CapnpCompatTest/testdata/packed b/CapnpCompatTest/testdata/packed new file mode 100644 index 0000000..8627833 Binary files /dev/null and b/CapnpCompatTest/testdata/packed differ diff --git a/CapnpCompatTest/testdata/packedflat b/CapnpCompatTest/testdata/packedflat new file mode 100644 index 0000000..7c304a9 Binary files /dev/null and b/CapnpCompatTest/testdata/packedflat differ diff --git a/CapnpCompatTest/testdata/pretty.json b/CapnpCompatTest/testdata/pretty.json new file mode 100644 index 0000000..abf82d6 --- /dev/null +++ b/CapnpCompatTest/testdata/pretty.json @@ -0,0 +1,88 @@ +{ "voidField": null, + "boolField": true, + "int8Field": -123, + "int16Field": -12345, + "int32Field": -12345678, + "int64Field": "-123456789012345", + "uInt8Field": 234, + "uInt16Field": 45678, + "uInt32Field": 3456789012, + "uInt64Field": "12345678901234567890", + "float32Field": 1234.5, + "float64Field": -1.23e47, + "textField": "foo", + "dataField": [98, 97, 114], + "structField": { + "voidField": null, + "boolField": true, + "int8Field": -12, + "int16Field": 3456, + "int32Field": -78901234, + "int64Field": "56789012345678", + "uInt8Field": 90, + "uInt16Field": 1234, + "uInt32Field": 56789012, + "uInt64Field": "345678901234567890", + "float32Field": -1.2499999646475857e-10, + "float64Field": 345, + "textField": "baz", + "dataField": [113, 117, 120], + "structField": { + "voidField": null, + "boolField": false, + "int8Field": 0, + "int16Field": 0, + "int32Field": 0, + "int64Field": "0", + "uInt8Field": 0, + "uInt16Field": 0, + "uInt32Field": 0, + "uInt64Field": "0", + "float32Field": 0, + "float64Field": 0, + "textField": "nested", + "structField": {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "really nested", "enumField": "foo", "interfaceField": null}, + "enumField": "foo", + "interfaceField": null }, + "enumField": "baz", + "interfaceField": null, + "voidList": [null, null, null], + "boolList": [false, true, false, true, true], + "int8List": [12, -34, -128, 127], + "int16List": [1234, -5678, -32768, 32767], + "int32List": [12345678, -90123456, -2147483648, 2147483647], + "int64List": ["123456789012345", "-678901234567890", "-9223372036854775808", "9223372036854775807"], + "uInt8List": [12, 34, 0, 255], + "uInt16List": [1234, 5678, 0, 65535], + "uInt32List": [12345678, 90123456, 0, 4294967295], + "uInt64List": ["123456789012345", "678901234567890", "0", "18446744073709551615"], + "float32List": [0, 1234567, 9.9999999338158125e36, -9.9999999338158125e36, 9.99999991097579e-38, -9.99999991097579e-38], + "float64List": [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + "textList": ["quux", "corge", "grault"], + "dataList": [[103, 97, 114, 112, 108, 121], [119, 97, 108, 100, 111], [102, 114, 101, 100]], + "structList": [ + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "x structlist 1", "enumField": "foo", "interfaceField": null}, + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "x structlist 2", "enumField": "foo", "interfaceField": null}, + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "x structlist 3", "enumField": "foo", "interfaceField": null} ], + "enumList": ["qux", "bar", "grault"] }, + "enumField": "corge", + "interfaceField": null, + "voidList": [null, null, null, null, null, null], + "boolList": [true, false, false, true], + "int8List": [111, -111], + "int16List": [11111, -11111], + "int32List": [111111111, -111111111], + "int64List": ["1111111111111111111", "-1111111111111111111"], + "uInt8List": [111, 222], + "uInt16List": [33333, 44444], + "uInt32List": [3333333333], + "uInt64List": ["11111111111111111111"], + "float32List": [5555.5, "Infinity", "-Infinity", "NaN"], + "float64List": [7777.75, "Infinity", "-Infinity", "NaN"], + "textList": ["plugh", "xyzzy", "thud"], + "dataList": [[111, 111, 112, 115], [101, 120, 104, 97, 117, 115, 116, 101, 100], [114, 102, 99, 51, 48, 57, 50]], + "structList": [ + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "structlist 1", "enumField": "foo", "interfaceField": null}, + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "structlist 2", "enumField": "foo", "interfaceField": null}, + {"voidField": null, "boolField": false, "int8Field": 0, "int16Field": 0, "int32Field": 0, "int64Field": "0", "uInt8Field": 0, "uInt16Field": 0, "uInt32Field": 0, "uInt64Field": "0", "float32Field": 0, "float64Field": 0, "textField": "structlist 3", "enumField": "foo", "interfaceField": null} ], + "enumList": ["foo", "garply"] } diff --git a/CapnpCompatTest/testdata/pretty.txt b/CapnpCompatTest/testdata/pretty.txt new file mode 100644 index 0000000..079ff8d --- /dev/null +++ b/CapnpCompatTest/testdata/pretty.txt @@ -0,0 +1,187 @@ +( voidField = void, + boolField = true, + int8Field = -123, + int16Field = -12345, + int32Field = -12345678, + int64Field = -123456789012345, + uInt8Field = 234, + uInt16Field = 45678, + uInt32Field = 3456789012, + uInt64Field = 12345678901234567890, + float32Field = 1234.5, + float64Field = -1.23e47, + textField = "foo", + dataField = "bar", + structField = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "nested", + structField = ( + voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "really nested", + enumField = foo, + interfaceField = void ), + enumField = foo, + interfaceField = void ), + enumField = baz, + interfaceField = void, + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -128, 127], + int16List = [1234, -5678, -32768, 32767], + int32List = [12345678, -90123456, -2147483648, 2147483647], + int64List = [123456789012345, -678901234567890, -9223372036854775808, 9223372036854775807], + uInt8List = [12, 34, 0, 255], + uInt16List = [1234, 5678, 0, 65535], + uInt32List = [12345678, 90123456, 0, 4294967295], + uInt64List = [123456789012345, 678901234567890, 0, 18446744073709551615], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 1", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 2", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 3", + enumField = foo, + interfaceField = void ) ], + enumList = [qux, bar, grault] ), + enumField = corge, + interfaceField = void, + voidList = [void, void, void, void, void, void], + boolList = [true, false, false, true], + int8List = [111, -111], + int16List = [11111, -11111], + int32List = [111111111, -111111111], + int64List = [1111111111111111111, -1111111111111111111], + uInt8List = [111, 222], + uInt16List = [33333, 44444], + uInt32List = [3333333333], + uInt64List = [11111111111111111111], + float32List = [5555.5, inf, -inf, nan], + float64List = [7777.75, inf, -inf, nan], + textList = ["plugh", "xyzzy", "thud"], + dataList = ["oops", "exhausted", "rfc3092"], + structList = [ + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 1", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 2", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 3", + enumField = foo, + interfaceField = void ) ], + enumList = [foo, garply] ) diff --git a/CapnpCompatTest/testdata/segmented b/CapnpCompatTest/testdata/segmented new file mode 100644 index 0000000..c2840b4 Binary files /dev/null and b/CapnpCompatTest/testdata/segmented differ diff --git a/CapnpCompatTest/testdata/segmented-packed b/CapnpCompatTest/testdata/segmented-packed new file mode 100644 index 0000000..c4a968e Binary files /dev/null and b/CapnpCompatTest/testdata/segmented-packed differ diff --git a/CapnpCompatTest/testdata/short.json b/CapnpCompatTest/testdata/short.json new file mode 100644 index 0000000..26cbfd0 --- /dev/null +++ b/CapnpCompatTest/testdata/short.json @@ -0,0 +1 @@ +{"voidField":null,"boolField":true,"int8Field":-123,"int16Field":-12345,"int32Field":-12345678,"int64Field":"-123456789012345","uInt8Field":234,"uInt16Field":45678,"uInt32Field":3456789012,"uInt64Field":"12345678901234567890","float32Field":1234.5,"float64Field":-1.23e47,"textField":"foo","dataField":[98,97,114],"structField":{"voidField":null,"boolField":true,"int8Field":-12,"int16Field":3456,"int32Field":-78901234,"int64Field":"56789012345678","uInt8Field":90,"uInt16Field":1234,"uInt32Field":56789012,"uInt64Field":"345678901234567890","float32Field":-1.2499999646475857e-10,"float64Field":345,"textField":"baz","dataField":[113,117,120],"structField":{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"nested","structField":{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"really nested","enumField":"foo","interfaceField":null},"enumField":"foo","interfaceField":null},"enumField":"baz","interfaceField":null,"voidList":[null,null,null],"boolList":[false,true,false,true,true],"int8List":[12,-34,-128,127],"int16List":[1234,-5678,-32768,32767],"int32List":[12345678,-90123456,-2147483648,2147483647],"int64List":["123456789012345","-678901234567890","-9223372036854775808","9223372036854775807"],"uInt8List":[12,34,0,255],"uInt16List":[1234,5678,0,65535],"uInt32List":[12345678,90123456,0,4294967295],"uInt64List":["123456789012345","678901234567890","0","18446744073709551615"],"float32List":[0,1234567,9.9999999338158125e36,-9.9999999338158125e36,9.99999991097579e-38,-9.99999991097579e-38],"float64List":[0,123456789012345,1e306,-1e306,1e-306,-1e-306],"textList":["quux","corge","grault"],"dataList":[[103,97,114,112,108,121],[119,97,108,100,111],[102,114,101,100]],"structList":[{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"x structlist 1","enumField":"foo","interfaceField":null},{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"x structlist 2","enumField":"foo","interfaceField":null},{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"x structlist 3","enumField":"foo","interfaceField":null}],"enumList":["qux","bar","grault"]},"enumField":"corge","interfaceField":null,"voidList":[null,null,null,null,null,null],"boolList":[true,false,false,true],"int8List":[111,-111],"int16List":[11111,-11111],"int32List":[111111111,-111111111],"int64List":["1111111111111111111","-1111111111111111111"],"uInt8List":[111,222],"uInt16List":[33333,44444],"uInt32List":[3333333333],"uInt64List":["11111111111111111111"],"float32List":[5555.5,"Infinity","-Infinity","NaN"],"float64List":[7777.75,"Infinity","-Infinity","NaN"],"textList":["plugh","xyzzy","thud"],"dataList":[[111,111,112,115],[101,120,104,97,117,115,116,101,100],[114,102,99,51,48,57,50]],"structList":[{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"structlist 1","enumField":"foo","interfaceField":null},{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"structlist 2","enumField":"foo","interfaceField":null},{"voidField":null,"boolField":false,"int8Field":0,"int16Field":0,"int32Field":0,"int64Field":"0","uInt8Field":0,"uInt16Field":0,"uInt32Field":0,"uInt64Field":"0","float32Field":0,"float64Field":0,"textField":"structlist 3","enumField":"foo","interfaceField":null}],"enumList":["foo","garply"]} diff --git a/CapnpCompatTest/testdata/short.txt b/CapnpCompatTest/testdata/short.txt new file mode 100644 index 0000000..d738fb3 --- /dev/null +++ b/CapnpCompatTest/testdata/short.txt @@ -0,0 +1 @@ +(voidField = void, boolField = true, int8Field = -123, int16Field = -12345, int32Field = -12345678, int64Field = -123456789012345, uInt8Field = 234, uInt16Field = 45678, uInt32Field = 3456789012, uInt64Field = 12345678901234567890, float32Field = 1234.5, float64Field = -1.23e47, textField = "foo", dataField = "bar", structField = (voidField = void, boolField = true, int8Field = -12, int16Field = 3456, int32Field = -78901234, int64Field = 56789012345678, uInt8Field = 90, uInt16Field = 1234, uInt32Field = 56789012, uInt64Field = 345678901234567890, float32Field = -1.25e-10, float64Field = 345, textField = "baz", dataField = "qux", structField = (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "nested", structField = (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "really nested", enumField = foo, interfaceField = void), enumField = foo, interfaceField = void), enumField = baz, interfaceField = void, voidList = [void, void, void], boolList = [false, true, false, true, true], int8List = [12, -34, -128, 127], int16List = [1234, -5678, -32768, 32767], int32List = [12345678, -90123456, -2147483648, 2147483647], int64List = [123456789012345, -678901234567890, -9223372036854775808, 9223372036854775807], uInt8List = [12, 34, 0, 255], uInt16List = [1234, 5678, 0, 65535], uInt32List = [12345678, 90123456, 0, 4294967295], uInt64List = [123456789012345, 678901234567890, 0, 18446744073709551615], float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], textList = ["quux", "corge", "grault"], dataList = ["garply", "waldo", "fred"], structList = [(voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 1", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 2", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "x structlist 3", enumField = foo, interfaceField = void)], enumList = [qux, bar, grault]), enumField = corge, interfaceField = void, voidList = [void, void, void, void, void, void], boolList = [true, false, false, true], int8List = [111, -111], int16List = [11111, -11111], int32List = [111111111, -111111111], int64List = [1111111111111111111, -1111111111111111111], uInt8List = [111, 222], uInt16List = [33333, 44444], uInt32List = [3333333333], uInt64List = [11111111111111111111], float32List = [5555.5, inf, -inf, nan], float64List = [7777.75, inf, -inf, nan], textList = ["plugh", "xyzzy", "thud"], dataList = ["oops", "exhausted", "rfc3092"], structList = [(voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 1", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 2", enumField = foo, interfaceField = void), (voidField = void, boolField = false, int8Field = 0, int16Field = 0, int32Field = 0, int64Field = 0, uInt8Field = 0, uInt16Field = 0, uInt32Field = 0, uInt64Field = 0, float32Field = 0, float64Field = 0, textField = "structlist 3", enumField = foo, interfaceField = void)], enumList = [foo, garply]) diff --git a/capnpc-csharp/Generator/CodeGenerator.cs b/capnpc-csharp/Generator/CodeGenerator.cs new file mode 100644 index 0000000..785a50f --- /dev/null +++ b/capnpc-csharp/Generator/CodeGenerator.cs @@ -0,0 +1,189 @@ +namespace CapnpC.Generator +{ + using System; + using System.Collections.Generic; + using System.IO; + using System.Linq; + using System.Text; + using CapnpC.Model; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + using static SyntaxHelpers; + + class CodeGenerator + { + readonly SchemaModel _model; + readonly GenNames _names; + readonly CommonSnippetGen _commonGen; + readonly DomainClassSnippetGen _domClassGen; + readonly ReaderSnippetGen _readerGen; + readonly WriterSnippetGen _writerGen; + readonly InterfaceSnippetGen _interfaceGen; + + public CodeGenerator(SchemaModel model, GeneratorOptions options) + { + _model = model; + _names = new GenNames(options); + _commonGen = new CommonSnippetGen(_names); + _domClassGen = new DomainClassSnippetGen(_names); + _readerGen = new ReaderSnippetGen(_names); + _writerGen = new WriterSnippetGen(_names); + _interfaceGen = new InterfaceSnippetGen(_names); + } + + IEnumerable TransformEnum(TypeDefinition def) + { + yield return _commonGen.MakeEnum(def); + } + + IEnumerable MakeTypeParameters(TypeDefinition def) + { + foreach (string name in def.GenericParameters) + { + yield return TypeParameter(_names.GetGenericTypeParameter(name).Identifier); + } + } + + IEnumerable MakeTypeParameterConstraints(TypeDefinition def) + { + foreach (string name in def.GenericParameters) + { + yield return TypeParameterConstraintClause( + _names.GetGenericTypeParameter(name).IdentifierName) + .AddConstraints(ClassOrStructConstraint(SyntaxKind.ClassConstraint)); + } + } + + IEnumerable TransformStruct(TypeDefinition def) + { + var topDecl = ClassDeclaration(_names.MakeTypeName(def).Identifier) + .AddModifiers(Public) + .AddBaseListTypes(SimpleBaseType(Type())); + + if (def.GenericParameters.Count > 0) + { + topDecl = topDecl + .AddTypeParameterListParameters(MakeTypeParameters(def).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(def).ToArray()); + } + + if (def.UnionInfo != null) + { + topDecl = topDecl.AddMembers(_commonGen.MakeUnionSelectorEnum(def)); + } + + topDecl = topDecl.AddMembers(_domClassGen.MakeDomainClassMembers(def)); + topDecl = topDecl.AddMembers(_readerGen.MakeReaderStruct(def)); + topDecl = topDecl.AddMembers(_writerGen.MakeWriterStruct(def)); + + foreach (var nestedGroup in def.NestedGroups) + { + topDecl = topDecl.AddMembers(Transform(nestedGroup).ToArray()); + } + + foreach (var nestedDef in def.NestedTypes) + { + topDecl = topDecl.AddMembers(Transform(nestedDef).ToArray()); + } + + yield return topDecl; + } + + IEnumerable TransformInterface(TypeDefinition def) + { + yield return _interfaceGen.MakeInterface(def); + yield return _interfaceGen.MakeProxy(def); + yield return _interfaceGen.MakeSkeleton(def); + + if (_interfaceGen.RequiresPipeliningSupport(def)) + { + yield return _interfaceGen.MakePipeliningSupport(def); + } + + if (def.NestedTypes.Count > 0) + { + var ns = ClassDeclaration( + _names.MakeTypeName(def, NameUsage.Namespace).ToString()) + .AddModifiers(Public, Static); + + if (def.GenericParameters.Count > 0) + { + ns = ns + .AddTypeParameterListParameters(MakeTypeParameters(def).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(def).ToArray()); + } + + foreach (var nestedDef in def.NestedTypes) + { + ns = ns.AddMembers(Transform(nestedDef).ToArray()); + } + + yield return ns; + } + } + + IEnumerable Transform(TypeDefinition def) + { + switch (def.Tag) + { + case TypeTag.Enum: + return TransformEnum(def); + + case TypeTag.Group: + case TypeTag.Struct: + return TransformStruct(def); + + case TypeTag.Interface: + return TransformInterface(def); + + default: + throw new NotSupportedException($"Cannot declare type of kind {def.Tag} here"); + } + } + + string Transform(GenFile file) + { + if (file.Namespace != null) + { + _names.TopNamespace = IdentifierName(MakeCamel(file.Namespace[0])); + + foreach (string name in file.Namespace.Skip(1)) + { + var temp = IdentifierName(MakeCamel(name)); + _names.TopNamespace = QualifiedName(_names.TopNamespace, temp); + } + } + + var ns = NamespaceDeclaration(_names.TopNamespace); + + foreach (var def in file.NestedTypes) + { + ns = ns.AddMembers(Transform(def).ToArray()); + } + + var cu = CompilationUnit().AddUsings( + UsingDirective(ParseName("Capnp")), + UsingDirective(ParseName("Capnp.Rpc")), + UsingDirective(ParseName("System")), + UsingDirective(ParseName("System.Collections.Generic")), + UsingDirective(ParseName("System.Threading")), + UsingDirective(ParseName("System.Threading.Tasks"))); + + cu = cu.AddMembers(ns); + + return cu.NormalizeWhitespace().ToFullString(); + } + + public void Generate() + { + foreach (var file in _model.FilesToGenerate) + { + string content = Transform(file); + string path = Path.ChangeExtension(file.Name, ".cs"); + File.WriteAllText(path, content); + } + } + } +} diff --git a/capnpc-csharp/Generator/CommonSnippetGen.cs b/capnpc-csharp/Generator/CommonSnippetGen.cs new file mode 100644 index 0000000..2e1797d --- /dev/null +++ b/capnpc-csharp/Generator/CommonSnippetGen.cs @@ -0,0 +1,93 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using CapnpC.Model; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static CapnpC.Generator.SyntaxHelpers; + +namespace CapnpC.Generator +{ + class CommonSnippetGen + { + readonly GenNames _names; + + public CommonSnippetGen(GenNames names) + { + _names = names; + } + + public EnumDeclarationSyntax MakeUnionSelectorEnum(TypeDefinition def) + { + var whichEnum = EnumDeclaration(_names.UnionDiscriminatorEnum.ToString()) + .AddModifiers(Public) + .AddBaseListTypes(SimpleBaseType(Type())); + + var discFields = def.Fields.Where(f => f.DiscValue.HasValue); + + foreach (var discField in discFields) + { + whichEnum = whichEnum.AddMembers( + EnumMemberDeclaration(_names.GetCodeIdentifier(discField).Identifier) + .WithEqualsValue( + EqualsValueClause(LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(discField.DiscValue.Value))))); + } + + var ndecl = EnumMemberDeclaration(_names.UnionDiscriminatorUndefined.ToString()).WithEqualsValue( + EqualsValueClause( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(Schema.Field.Reader.NoDiscriminant)))); + + whichEnum = whichEnum.AddMembers(ndecl); + + return whichEnum; + } + + public EnumDeclarationSyntax MakeEnum(TypeDefinition def) + { + var decl = EnumDeclaration(def.Name) + .AddModifiers(Public) + .AddBaseListTypes(SimpleBaseType(Type())); + + foreach (var enumerant in def.Enumerants.OrderBy(e => e.CodeOrder)) + { + var mdecl = EnumMemberDeclaration(enumerant.Literal); + + if (enumerant.Ordinal.HasValue) + { + mdecl = mdecl.WithEqualsValue( + EqualsValueClause( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(enumerant.Ordinal.Value)))); + } + + decl = decl.AddMembers(mdecl); + } + + return decl; + } + + public static IEnumerable MakeCommaSeparatedList(IEnumerable expressions) + { + bool first = true; + + foreach (var expr in expressions) + { + if (first) + first = false; + else + yield return Token(SyntaxKind.CommaToken); + + yield return expr; + } + } + + } +} diff --git a/capnpc-csharp/Generator/DomainClassSnippetGen.cs b/capnpc-csharp/Generator/DomainClassSnippetGen.cs new file mode 100644 index 0000000..5b27495 --- /dev/null +++ b/capnpc-csharp/Generator/DomainClassSnippetGen.cs @@ -0,0 +1,972 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using CapnpC.Model; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static CapnpC.Generator.SyntaxHelpers; + +namespace CapnpC.Generator +{ + class DomainClassSnippetGen + { + readonly GenNames _names; + + public DomainClassSnippetGen(GenNames names) + { + _names = names; + } + + MemberDeclarationSyntax MakeUnionField(Field field) + { + var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.DomainClassNullable); + + switch (field.Type.Tag) + { + case TypeTag.Void: + return null; + + default: + return PropertyDeclaration(type, + _names.GetCodeIdentifier(field).Identifier) + .AddModifiers(Public).AddAccessorListAccessors( + AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) + .WithExpressionBody( + ArrowExpressionClause( + ConditionalExpression( + BinaryExpression( + SyntaxKind.EqualsExpression, + _names.UnionDiscriminatorField.IdentifierName, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName)), + CastExpression(type, + _names.UnionContentField.IdentifierName), + LiteralExpression( + SyntaxKind.NullLiteralExpression)))) + .WithSemicolonToken( + Token(SyntaxKind.SemicolonToken)), + AccessorDeclaration( + SyntaxKind.SetAccessorDeclaration) + .WithBody( + Block( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.UnionDiscriminatorField.IdentifierName, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName))), + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.UnionContentField.IdentifierName, + IdentifierName("value")))))); + } + } + + MemberDeclarationSyntax MakeStructField(Field field) + { + if (field.Type.Tag == TypeTag.Void) + { + return null; + } + + var prop = PropertyDeclaration(_names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.DomainClass), + _names.GetCodeIdentifier(field).Identifier) + .AddModifiers(Public).AddAccessorListAccessors( + AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)), + AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); + + if (field.DefaultValueIsExplicit && field.Type.IsValueType) + { + prop = prop.WithInitializer( + EqualsValueClause(MakeDefaultValue(field))) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + } + + return prop; + } + + MemberDeclarationSyntax MakeUnionDiscriminatorField() + { + return FieldDeclaration( + VariableDeclaration(_names.UnionDiscriminatorEnum.IdentifierName) + .AddVariables( + VariableDeclarator(_names.UnionDiscriminatorField.Identifier) + .WithInitializer( + EqualsValueClause( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.UnionDiscriminatorUndefined.IdentifierName))))) + .AddModifiers(Private); + } + + MemberDeclarationSyntax MakeUnionContentField() + { + return FieldDeclaration( + VariableDeclaration(SyntaxHelpers.Type()) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator(_names.UnionContentField.Identifier)))) + .AddModifiers(Private); + } + + IEnumerable MakeInitializerAssignments(Value structValue, TypeDefinition scope) + { + foreach (var fieldValue in structValue.Fields) + { + var valueExpr = MakeValue(fieldValue.Item2, scope); + if (valueExpr == null) + continue; + + yield return AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.GetCodeIdentifier(fieldValue.Item1).IdentifierName, + valueExpr); + } + } + + ExpressionSyntax MakeValue(Value value, TypeDefinition scope) + { + switch (value.Type.Tag) + { + case TypeTag.AnyEnum: + return LiteralExpression( + SyntaxKind.NumericLiteralExpression, Literal((ushort)value.ScalarValue)); + + case TypeTag.Bool: + + if ((bool)value.ScalarValue) + return LiteralExpression(SyntaxKind.TrueLiteralExpression); + else + return LiteralExpression(SyntaxKind.FalseLiteralExpression); + + case TypeTag.Data: + return ArrayCreationExpression(ArrayType( + PredefinedType(Token(SyntaxKind.ByteKeyword))) + .WithRankSpecifiers( + SingletonList( + ArrayRankSpecifier( + SingletonSeparatedList( + OmittedArraySizeExpression()))))) + .WithInitializer( + InitializerExpression( + SyntaxKind.ArrayInitializerExpression) + .AddExpressions(value.Items.Select(v => MakeValue(v, scope)).ToArray())); + + case TypeTag.Enum: + return MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + _names.MakeTypeSyntax(value.Type, scope, TypeUsage.NotRelevant), + IdentifierName(value.GetEnumerant().Literal)); + + case TypeTag.F32: + switch ((float)value.ScalarValue) + { + case float.NaN: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("float"), + IdentifierName(nameof(float.NaN))); + + case float.NegativeInfinity: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("float"), + IdentifierName(nameof(float.NegativeInfinity))); + + case float.PositiveInfinity: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("float"), + IdentifierName(nameof(float.PositiveInfinity))); + + default: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((float)value.ScalarValue)); + } + + case TypeTag.F64: + switch ((double)value.ScalarValue) + { + case double.NaN: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("double"), + IdentifierName(nameof(double.NaN))); + + case double.NegativeInfinity: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("double"), + IdentifierName(nameof(double.NegativeInfinity))); + + case double.PositiveInfinity: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("double"), + IdentifierName(nameof(double.PositiveInfinity))); + + default: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((double)value.ScalarValue)); + } + + case TypeTag.S8: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((sbyte)value.ScalarValue)); + + case TypeTag.S16: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((short)value.ScalarValue)); + + case TypeTag.S32: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((int)value.ScalarValue)); + + case TypeTag.S64: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((long)value.ScalarValue)); + + case TypeTag.U8: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((byte)value.ScalarValue)); + + case TypeTag.U16: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((ushort)value.ScalarValue)); + + case TypeTag.U32: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((uint)value.ScalarValue)); + + case TypeTag.U64: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((ulong)value.ScalarValue)); + + case TypeTag.Text: + value.Decode(); + return value.ScalarValue == null ? + LiteralExpression(SyntaxKind.NullLiteralExpression) : + LiteralExpression(SyntaxKind.StringLiteralExpression, + Literal((string)value.ScalarValue)); + + case TypeTag.Group: + case TypeTag.Struct: + value.Decode(); + + return ObjectCreationExpression( + _names.MakeTypeSyntax(value.Type, scope, TypeUsage.DomainClass)) + .WithArgumentList(ArgumentList()) + .WithInitializer( + InitializerExpression( + SyntaxKind.ObjectInitializerExpression) + .AddExpressions(MakeInitializerAssignments(value, scope).ToArray())); + + case TypeTag.ListPointer: + // TBD + return LiteralExpression(SyntaxKind.NullLiteralExpression); + + case TypeTag.List when value.Type.ElementType.Tag == TypeTag.Void: + value.Decode(); + + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal((int)value.VoidListCount)); + + case TypeTag.List: + value.Decode(); + + return ArrayCreationExpression(ArrayType( + _names.MakeTypeSyntax(value.Type.ElementType, scope, TypeUsage.DomainClass)) + .WithRankSpecifiers( + SingletonList( + ArrayRankSpecifier( + SingletonSeparatedList( + OmittedArraySizeExpression()))))) + .WithInitializer( + InitializerExpression( + SyntaxKind.ArrayInitializerExpression) + .AddExpressions(value.Items.Select(v => MakeValue(v, scope)).ToArray())); + + case TypeTag.AnyPointer: + case TypeTag.CapabilityPointer: + // TBD + return null; + + case TypeTag.Interface: + return null; + + default: + throw new NotImplementedException(); + } + } + + ExpressionSyntax MakeDefaultValue(Field field) + { + if (field.DefaultValueIsExplicit) + { + return MakeValue(field.DefaultValue, field.DeclaringType); + } + else + { + switch (field.Type.Tag) + { + case TypeTag.AnyEnum: + case TypeTag.S16: + case TypeTag.S32: + case TypeTag.S64: + case TypeTag.S8: + case TypeTag.U16: + case TypeTag.U32: + case TypeTag.U64: + case TypeTag.U8: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0)); + + case TypeTag.AnyPointer: + case TypeTag.CapabilityPointer: + case TypeTag.Data: + case TypeTag.Group: + case TypeTag.Interface: + case TypeTag.List: + case TypeTag.ListPointer: + case TypeTag.Struct: + case TypeTag.StructPointer: + case TypeTag.Text: + return LiteralExpression(SyntaxKind.NullLiteralExpression); + + case TypeTag.Bool: + return LiteralExpression(SyntaxKind.FalseLiteralExpression); + + case TypeTag.Enum: + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.NotRelevant), + _names.UnionDiscriminatorUndefined.IdentifierName); + + case TypeTag.F32: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0.0f)); + + case TypeTag.F64: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0.0)); + + default: + throw new NotImplementedException(); + } + } + } + + IEnumerable MakeUnionDiscriminatorSetter(TypeDefinition def) + { + var unionFields = def.Fields.Where(f => f.DiscValue.HasValue); + + foreach (var unionField in unionFields) + { + var section = SwitchSection() + .WithLabels( + SingletonList( + CaseSwitchLabel(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.GetCodeIdentifier(unionField).IdentifierName)))); + + if (unionField.Type.Tag != TypeTag.Void) + { + section = section.AddStatements( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.UnionContentField.IdentifierName, + MakeDefaultValue(unionField)))); + } + + section = section.AddStatements(BreakStatement()); + + yield return section; + } + } + + MemberDeclarationSyntax MakeUnionDiscriminatorProperty(TypeDefinition def) + { + return PropertyDeclaration(_names.UnionDiscriminatorEnum.IdentifierName, + _names.UnionDiscriminatorProp.Identifier) + .AddModifiers(Public).AddAccessorListAccessors( + AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) + .WithExpressionBody( + ArrowExpressionClause(_names.UnionDiscriminatorField.IdentifierName)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)), + AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) + .WithBody( + Block( + IfStatement( + BinaryExpression( + SyntaxKind.EqualsExpression, + IdentifierName("value"), + _names.UnionDiscriminatorField.IdentifierName), + ReturnStatement()), + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.UnionDiscriminatorField.IdentifierName, + IdentifierName("value"))), + SwitchStatement(IdentifierName("value")) + .WithOpenParenToken( + Token(SyntaxKind.OpenParenToken)) + .WithCloseParenToken( + Token(SyntaxKind.CloseParenToken)) + .AddSections(MakeUnionDiscriminatorSetter(def).ToArray())))); + } + + MemberDeclarationSyntax MakeField(Field field) + { + if (field.DiscValue.HasValue) + return MakeUnionField(field); + else + return MakeStructField(field); + } + + ExpressionSyntax MakeListSerializeParticle(Model.Type type, ExpressionSyntax writer, ExpressionSyntax domain) + { + string s = $"_s{type.GetRank().Item1}"; + string v = $"_v{type.GetRank().Item1}"; + + switch (type.ElementType?.Tag) + { + case TypeTag.List: + case TypeTag.ListPointer: + case TypeTag.Struct: + case TypeTag.Group: + case TypeTag.StructPointer: + case TypeTag.Data: + + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + writer, + IdentifierName(nameof(Capnp.ListOfPrimitivesSerializer.Init)))) + .AddArgumentListArguments( + Argument(domain), + Argument( + ParenthesizedLambdaExpression( + MakeComplexSerializeParticle( + type.ElementType, + IdentifierName(s), + IdentifierName(v))) + .AddParameterListParameters( + Parameter(Identifier(s)), + Parameter(Identifier(v))))); + + default: + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + writer, + IdentifierName(nameof(Capnp.ListOfPrimitivesSerializer.Init)))) + .AddArgumentListArguments(Argument(domain)); + } + } + + ExpressionSyntax MakeComplexSerializeParticle(Model.Type type, ExpressionSyntax writer, ExpressionSyntax domain) + { + switch (type.Tag) + { + case TypeTag.Data: + case TypeTag.List: + return MakeListSerializeParticle(type, writer, domain); + + case TypeTag.Struct: + case TypeTag.Group: + return ConditionalAccessExpression(domain, + InvocationExpression(MemberBindingExpression(_names.SerializeMethod.IdentifierName)) + .AddArgumentListArguments(Argument(writer))); + + default: + throw new NotImplementedException(); + } + } + + StatementSyntax MakeSerializeMethodFieldAssignment(Field field) + { + var writerProp = MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.WriterParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName); + + switch (field.Type.Tag) + { + case TypeTag.Bool: + case TypeTag.Enum: + case TypeTag.F32: + case TypeTag.F64: + case TypeTag.S16: + case TypeTag.S32: + case TypeTag.S64: + case TypeTag.S8: + case TypeTag.U16: + case TypeTag.U32: + case TypeTag.U64: + case TypeTag.U8: + case TypeTag.AnyEnum: + case TypeTag.List when field.Type.Tag == TypeTag.Void: + if (field.DiscValue.HasValue) + { + return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + writerProp, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.GetCodeIdentifier(field).IdentifierName, + IdentifierName(nameof(Nullable.Value))))); + } + else + { + return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + writerProp, + _names.GetCodeIdentifier(field).IdentifierName)); + } + + case TypeTag.AnyPointer: + case TypeTag.ListPointer: + case TypeTag.StructPointer: + return ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.WriterParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName), + IdentifierName(nameof(Capnp.DynamicSerializerState.SetObject)))) + .AddArgumentListArguments( + Argument(_names.GetCodeIdentifier(field).IdentifierName))); + + case TypeTag.CapabilityPointer: + case TypeTag.Interface: + return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + writerProp, + _names.GetCodeIdentifier(field).IdentifierName)); + + case TypeTag.Text: + return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + writerProp, + _names.GetCodeIdentifier(field).IdentifierName)); + + case TypeTag.Data: + case TypeTag.List: + case TypeTag.Struct: + case TypeTag.Group: + return ExpressionStatement( + MakeComplexSerializeParticle( + field.Type, + writerProp, + _names.GetCodeIdentifier(field).IdentifierName)); + + case TypeTag.Void: + return null; + + default: + throw new NotImplementedException(); + } + } + + StatementSyntax MakeApplyDefaultsMethodFieldAssignment(Field field) + { + var lhs = _names.GetCodeIdentifier(field).IdentifierName; + var rhs = MakeDefaultValue(field); + + if (rhs == null) + { + return null; + } + + return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + lhs, + BinaryExpression(SyntaxKind.CoalesceExpression, + lhs, rhs))); + } + + ExpressionSyntax MakeInnerStructListConversion(ExpressionSyntax context, TypeSyntax elementType) + { + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ReadOnlyListExtensions.ToReadOnlyList)))) + .AddArgumentListArguments(Argument( + SimpleLambdaExpression(Parameter(Identifier("_")), + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.CapnpSerializable)), + GenericName(nameof(Capnp.CapnpSerializable.Create)) + .AddTypeArgumentListArguments(elementType))) + .AddArgumentListArguments(Argument(IdentifierName("_")))))); + } + + ExpressionSyntax MakeStructListConversion(ExpressionSyntax context, TypeSyntax elementType, int rank) + { + if (rank == 1) + { + return MakeInnerStructListConversion(context, elementType); + } + + string lambdaVarName = $"_{rank}"; + + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ReadOnlyListExtensions.ToReadOnlyList)))) + .AddArgumentListArguments(Argument( + SimpleLambdaExpression( + Parameter(Identifier(lambdaVarName)), + MakeStructListConversion(IdentifierName(lambdaVarName), elementType, rank - 1)))); + } + + ExpressionSyntax MakeAnyListConversion(ExpressionSyntax context) + { + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ReadOnlyListExtensions.ToReadOnlyList)))) + .AddArgumentListArguments(Argument( + SimpleLambdaExpression( + Parameter(Identifier("_")), + CastExpression(Type(), IdentifierName("_"))))); + } + + ExpressionSyntax MakeDeserializeMethodRightHandSide(Field field) + { + switch (field.Type.Tag) + { + case TypeTag.Struct: + case TypeTag.Group: + case TypeTag.StructPointer: + case TypeTag.AnyPointer: + return InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.CapnpSerializable)), + GenericName(nameof(Capnp.CapnpSerializable.Create)) + .AddTypeArgumentListArguments( + _names.MakeTypeSyntax( + field.Type, + field.DeclaringType, + TypeUsage.DomainClass)))) + .AddArgumentListArguments(Argument(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName))); + + case TypeTag.Void: + return null; + + case TypeTag.List: + (var rank, var elementType) = field.Type.GetRank(); + if (elementType.Tag != TypeTag.Struct) + break; + + return MakeStructListConversion( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName), + _names.MakeTypeSyntax(elementType, field.DeclaringType, TypeUsage.DomainClass), + rank); + + case TypeTag.ListPointer: + return MakeAnyListConversion( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName)); + } + + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.GetCodeIdentifier(field).IdentifierName); + } + + IEnumerable MakeSerializeMethodSwitchSections(TypeDefinition def) + { + var unionFields = def.Fields.Where(f => f.DiscValue.HasValue); + + foreach (var unionField in unionFields) + { + var section = SwitchSection() + .AddLabels( + CaseSwitchLabel(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.GetCodeIdentifier(unionField).IdentifierName))); + + if (unionField.Type.Tag != TypeTag.Void) + { + ExpressionSyntax right = _names.GetCodeIdentifier(unionField).IdentifierName; + + var syntax = _names.MakeTypeSyntax(unionField.Type, unionField.DeclaringType, TypeUsage.DomainClassNullable); + + if (syntax is NullableTypeSyntax) + { + right = MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + right, + IdentifierName(nameof(Nullable.Value))); + } + + section = section.AddStatements(MakeSerializeMethodFieldAssignment(unionField)); + } + + section = section.AddStatements(BreakStatement()); + + yield return section; + } + } + + IEnumerable MakeDeserializeMethodSwitchSections(TypeDefinition def) + { + var unionFields = def.Fields.Where(f => f.DiscValue.HasValue); + + foreach (var unionField in unionFields) + { + var section = SwitchSection() + .AddLabels( + CaseSwitchLabel(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + _names.GetCodeIdentifier(unionField).IdentifierName))); + + switch (unionField.Type.Tag) + { + case TypeTag.Void: + section = section.AddStatements( + ExpressionStatement(AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.UnionDiscriminatorProp.IdentifierName, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.UnionDiscriminatorProp.IdentifierName)))); + break; + + default: + section = section.AddStatements( + ExpressionStatement(AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.GetCodeIdentifier(unionField).IdentifierName, + MakeDeserializeMethodRightHandSide(unionField)))); + break; + + } + + section = section.AddStatements(BreakStatement()); + + yield return section; + } + } + + IEnumerable MakeSerializeStatements(TypeDefinition def) + { + if (def.UnionInfo != null) + { + yield return ExpressionStatement(AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.WriterParameter.IdentifierName, + _names.UnionDiscriminatorProp.IdentifierName), + _names.UnionDiscriminatorProp.IdentifierName)); + + yield return SwitchStatement(_names.UnionDiscriminatorProp.IdentifierName) + .WithOpenParenToken(Token(SyntaxKind.OpenParenToken)) + .WithCloseParenToken(Token(SyntaxKind.CloseParenToken)) + .AddSections(MakeSerializeMethodSwitchSections(def).ToArray()); + } + + var nondiscFields = def.Fields.Where(f => !f.DiscValue.HasValue && f.Type.Tag != TypeTag.Void); + + foreach (var field in nondiscFields) + { + var asmt = MakeSerializeMethodFieldAssignment(field); + + if (asmt != null) + { + yield return asmt; + } + } + } + + IEnumerable MakeApplyDefaultsStatements(TypeDefinition def) + { + var relevantFields = def.Fields.Where( + f => !f.DiscValue.HasValue && + f.Type.Tag != TypeTag.Void && + f.DefaultValueIsExplicit && + !f.Type.IsValueType); + + foreach (var field in relevantFields) + { + var asmt = MakeApplyDefaultsMethodFieldAssignment(field); + + if (asmt != null) + { + yield return asmt; + } + } + } + + MemberDeclarationSyntax MakeSerializeMethod(TypeDefinition def) + { + return MethodDeclaration(PredefinedType( + Token(SyntaxKind.VoidKeyword)), + _names.SerializeMethod.Identifier) + .AddModifiers(Public) + .AddParameterListParameters( + Parameter(_names.WriterParameter.Identifier) + .WithType(_names.WriterStruct.IdentifierName)) + .AddBodyStatements(MakeSerializeStatements(def).ToArray()); + } + + MemberDeclarationSyntax MakeSerializeInterfaceMethod() + { + return MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), + Identifier(nameof(Capnp.ICapnpSerializable.Serialize))) + .WithExplicitInterfaceSpecifier( + ExplicitInterfaceSpecifier(IdentifierName(nameof(Capnp.ICapnpSerializable)))) + .AddParameterListParameters( + Parameter(_names.AnonymousParameter.Identifier) + .WithType(Type())) + .AddBodyStatements( + ExpressionStatement( + InvocationExpression(_names.SerializeMethod.IdentifierName) + .AddArgumentListArguments( + Argument( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.AnonymousParameter.IdentifierName, + GenericName(Identifier(nameof(Capnp.SerializerState.Rewrap))) + .AddTypeArgumentListArguments(_names.WriterStruct.IdentifierName))))))); + } + + MemberDeclarationSyntax MakeApplyDefaultsMethod(TypeDefinition def) + { + return MethodDeclaration(PredefinedType( + Token(SyntaxKind.VoidKeyword)), + _names.ApplyDefaultsMethod.Identifier) + .AddModifiers(Public) + .AddBodyStatements(MakeApplyDefaultsStatements(def).ToArray()); + } + + IEnumerable MakeDeserializeStatements(TypeDefinition def) + { + var relevantFields = def.Fields.Where( + f => !f.DiscValue.HasValue && + f.Type.Tag != TypeTag.Void); + + foreach (var field in relevantFields) + { + var rhs = MakeDeserializeMethodRightHandSide(field); + + if (rhs != null) + { + yield return ExpressionStatement(AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.GetCodeIdentifier(field).IdentifierName, + rhs)); + } + } + } + + MemberDeclarationSyntax MakeDeserializeMethod(TypeDefinition def) + { + var stmts = new List(); + + stmts.Add(LocalDeclarationStatement( + VariableDeclaration(IdentifierName("var")) + .AddVariables( + VariableDeclarator(_names.ReaderParameter.Identifier) + .WithInitializer( + EqualsValueClause( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderStruct.IdentifierName, + _names.ReaderCreateMethod.IdentifierName)) + .AddArgumentListArguments( + Argument(_names.AnonymousParameter.IdentifierName))))))); + + + if (def.UnionInfo != null) + { + stmts.Add(SwitchStatement( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.UnionDiscriminatorProp.IdentifierName)) + .WithOpenParenToken(Token(SyntaxKind.OpenParenToken)) + .WithCloseParenToken(Token(SyntaxKind.CloseParenToken)) + .AddSections(MakeDeserializeMethodSwitchSections(def).ToArray())); + } + + stmts.AddRange(MakeDeserializeStatements(def)); + stmts.Add(ExpressionStatement(InvocationExpression( + _names.ApplyDefaultsMethod.IdentifierName))); + + return MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), + Identifier(nameof(Capnp.ICapnpSerializable.Deserialize))) + .WithExplicitInterfaceSpecifier( + ExplicitInterfaceSpecifier(IdentifierName(nameof(Capnp.ICapnpSerializable)))) + .AddParameterListParameters( + Parameter(_names.AnonymousParameter.Identifier) + .WithType(Type())) + .AddBodyStatements(stmts.ToArray()); + } + + IEnumerable EnumerateDomainClassMembers(TypeDefinition def) + { + yield return MakeDeserializeMethod(def); + + if (def.UnionInfo != null) + { + yield return MakeUnionDiscriminatorField(); + yield return MakeUnionContentField(); + yield return MakeUnionDiscriminatorProperty(def); + } + + yield return MakeSerializeMethod(def); + yield return MakeSerializeInterfaceMethod(); + yield return MakeApplyDefaultsMethod(def); + + foreach (var field in def.Fields) + { + var decl = MakeField(field); + + if (decl != null) + yield return decl; + } + } + + public MemberDeclarationSyntax[] MakeDomainClassMembers(TypeDefinition def) + { + return EnumerateDomainClassMembers(def).ToArray(); + } + } +} diff --git a/capnpc-csharp/Generator/GenNames.cs b/capnpc-csharp/Generator/GenNames.cs new file mode 100644 index 0000000..f71a253 --- /dev/null +++ b/capnpc-csharp/Generator/GenNames.cs @@ -0,0 +1,602 @@ +using CapnpC.Model; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +namespace CapnpC.Generator +{ + enum NameUsage + { + Default, + Interface, + Proxy, + Skeleton, + Namespace + } + + enum TypeUsage + { + NotRelevant, + DomainClass, + DomainClassNullable, + Reader, + Writer + } + + class GenNames + { + readonly Dictionary _fieldNameMap = new Dictionary(); + + public NameSyntax TopNamespace { get; set; } + public Name ReaderStruct { get; } + public Name ReaderParameter { get; } + public Name WriterParameter { get; } + public Name WriterStruct { get; } + public Name ReaderCreateMethod { get; } + public Name ReaderContextField { get; } + public Name ContextParameter { get; } + public Name GroupReaderContextArg { get; } + public Name GroupWriterContextArg { get; } + public Name UnionDiscriminatorEnum { get; } + public Name UnionDiscriminatorProp { get; } + public Name UnionDiscriminatorUndefined { get; } + public Name UnionDiscriminatorField { get; } + public Name UnionContentField { get; } + public Name AnonymousParameter { get; } + public Name CancellationTokenParameter { get; } + public Name ParamsLocal { get; } + public Name DeserializerLocal { get; } + public Name SerializerLocal { get; } + public Name ResultLocal { get; } + public Name SerializeMethod { get; } + public Name ApplyDefaultsMethod { get; } + public Name InstLocalName { get; } + public string ParamsStructFormat { get; } + public string ResultStructFormat { get; } + public string PropertyNamedLikeTypeRenameFormat { get; } + public string GenericTypeParameterFormat { get; } + public Name PipeliningExtensionsClassName { get; } + public string MemberAccessPathNameFormat { get; } + public Name TaskParameter { get; } + public Name EagerMethod { get; } + + public GenNames(GeneratorOptions options) + { + TopNamespace = new Name(options.TopNamespaceName).IdentifierName; + ReaderStruct = new Name(options.ReaderStructName); + WriterStruct = new Name(options.WriterStructName); + ReaderParameter = new Name(options.ReaderParameterName); + WriterParameter = new Name(options.WriterParameterName); + ReaderCreateMethod = new Name(options.ReaderCreateMethodName); + ReaderContextField = new Name(options.ReaderContextFieldName); + ContextParameter = new Name(options.ContextParameterName); + GroupReaderContextArg = new Name(options.GroupReaderContextArgName); + GroupWriterContextArg = new Name(options.GroupWriterContextArgName); + UnionDiscriminatorEnum = new Name(options.UnionDisciminatorEnumName); + UnionDiscriminatorProp = new Name(options.UnionDiscriminatorPropName); + UnionDiscriminatorUndefined = new Name(options.UnionDisciminatorUndefinedName); + UnionDiscriminatorField = new Name(options.UnionDiscriminatorFieldName); + UnionContentField = new Name(options.UnionContentFieldName); + SerializeMethod = new Name(options.SerializeMethodName); + ApplyDefaultsMethod = new Name(options.ApplyDefaultsMethodName); + AnonymousParameter = new Name(options.AnonymousParameterName); + CancellationTokenParameter = new Name(options.CancellationTokenParameterName); + ParamsLocal = new Name(options.ParamsLocalName); + DeserializerLocal = new Name(options.DeserializerLocalName); + SerializerLocal = new Name(options.SerializerLocalName); + ResultLocal = new Name(options.ResultLocalName); + InstLocalName = new Name(options.InstLocalName); + ParamsStructFormat = options.ParamsStructFormat; + ResultStructFormat = options.ResultStructFormat; + PropertyNamedLikeTypeRenameFormat = options.PropertyNamedLikeTypeRenameFormat; + GenericTypeParameterFormat = options.GenericTypeParameterFormat; + PipeliningExtensionsClassName = new Name(options.PipeliningExtensionsClassName); + MemberAccessPathNameFormat = options.MemberAccessPathNameFormat; + TaskParameter = new Name(options.TaskParameterName); + EagerMethod = new Name(options.EagerMethodName); + } + + public Name MakeTypeName(TypeDefinition def, NameUsage usage = NameUsage.Default) + { + if (def.Tag == TypeTag.Group) + { + return new Name(SyntaxHelpers.MakeAllLower(def.Name)); + } + else + { + string name; + + switch (usage) + { + case NameUsage.Default: + if (def.Tag == TypeTag.Interface) + goto case NameUsage.Interface; + + switch (def.SpecialName) + { + case SpecialName.NothingSpecial: + name = def.Name; + break; + + case SpecialName.MethodParamsStruct: + name = MakeParamsStructName(def.UsingMethod); + break; + + case SpecialName.MethodResultStruct: + name = MakeResultStructName(def.UsingMethod); + break; + + default: + throw new NotImplementedException(); + } + break; + + case NameUsage.Namespace: + name = def.Name; + break; + + case NameUsage.Interface: + name = "I" + def.Name; + break; + + case NameUsage.Proxy: + name = def.Name + "Proxy"; + break; + + case NameUsage.Skeleton: + name = def.Name + "Skeleton"; + break; + + default: + throw new NotImplementedException(); + } + + return new Name(name); + } + } + + public SimpleNameSyntax MakeGenericTypeName(TypeDefinition def, NameUsage usage = NameUsage.Default) + { + var name = MakeTypeName(def, usage); + + if (def.GenericParameters.Count > 0) + { + return GenericName(name.Identifier) + .AddTypeArgumentListArguments(def + .GenericParameters + .Select(p => GetGenericTypeParameter(p).IdentifierName).ToArray()); + } + else + { + return name.IdentifierName; + } + } + + TypeSyntax ResolveGenericParameter(GenericParameter p, Model.Type boundType, TypeDefinition def) + { + var type = boundType.ResolveGenericParameter(p); + return MakeTypeSyntax(type, def, TypeUsage.DomainClass); + } + + public SimpleNameSyntax MakeGenericTypeName(TypeDefinition def, Model.Type boundType, NameUsage usage = NameUsage.Default) + { + var name = MakeTypeName(def, usage); + + if (def.GenericParameters.Count > 0) + { + return GenericName(name.Identifier) + .AddTypeArgumentListArguments(def + .GetLocalTypeParameters() + .Select(p => ResolveGenericParameter(p, boundType, def)).ToArray()); + } + else + { + return name.IdentifierName; + } + } + + public SimpleNameSyntax MakeGenericTypeNameForAttribute(TypeDefinition def, NameUsage usage) + { + var name = MakeTypeName(def, usage); + + if (def.GenericParameters.Count > 0) + { + return GenericName(name.Identifier).AddTypeArgumentListArguments(); + } + else + { + return name.IdentifierName; + } + } + + NameSyntax GetQName(TypeDefinition def) + { + var stack = new Stack(); + + stack.Push(MakeGenericTypeName(def, NameUsage.Default)); + + while (def.DeclaringElement is TypeDefinition pdef) + { + stack.Push(MakeGenericTypeName(pdef, NameUsage.Namespace)); + def = pdef; + } + + var qtype = TopNamespace; + + foreach (var name in stack) + { + qtype = QualifiedName(qtype, name); + } + + return qtype; + } + + NameSyntax GetQName(Model.Type type, TypeDefinition scope) + { + // FIXME: With the help of the 'scope' parameter we will be able to generate abbreviated + // qualified names. Unfortunately the commented approach is too naive. It will fail if + // there are multiple objects with identical name up the hierarchy. We will need a more + // sophisticated algorithm. + + var scopeSet = new HashSet(); + //while (scope != null) + //{ + // scopeSet.Add(scope); + // scope = scope.DeclaringElement as TypeDefinition; + //} + + if (type.Definition != null) + { + var stack = new Stack(); + + var def = type.Definition; + stack.Push(MakeGenericTypeName(def, type, NameUsage.Default)); + + while (def.DeclaringElement is TypeDefinition pdef && !scopeSet.Contains(pdef)) + { + stack.Push(MakeGenericTypeName(pdef, type, NameUsage.Namespace)); + def = pdef; + } + + var qtype = TopNamespace; + + foreach (var name in stack) + { + qtype = QualifiedName(qtype, name); + } + + return qtype; + } + else + { + return GetGenericTypeParameter(type.Parameter.Name).IdentifierName; + } + } + + public TypeSyntax MakeListSerializerSyntax(Model.Type elementType, TypeDefinition scope) + { + switch (elementType.Tag) + { + case TypeTag.AnyPointer: + case TypeTag.StructPointer: + case TypeTag.ListPointer: + return SyntaxHelpers.Type>(); + + case TypeTag.CapabilityPointer: + return SyntaxHelpers.Type>(); + + case TypeTag.Data: + return SyntaxHelpers.Type>>(); + + case TypeTag.Enum: + return GenericName("ListOfPrimitivesSerializer") + .AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)); + + case TypeTag.Group: + case TypeTag.Struct: + return GenericName("ListOfStructsSerializer") + .AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)); + + case TypeTag.Interface: + return GenericName("ListOfCapsSerializer") + .AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)); + + case TypeTag.List: + return GenericName("ListOfPointersSerializer") + .AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)); + + case TypeTag.Text: + return SyntaxHelpers.Type(); + + case TypeTag.Void: + return SyntaxHelpers.Type(); + + case TypeTag.Bool: + return SyntaxHelpers.Type(); + + case TypeTag.F32: + return SyntaxHelpers.Type>(); + + case TypeTag.F64: + return SyntaxHelpers.Type>(); + + case TypeTag.S8: + return SyntaxHelpers.Type>(); + + case TypeTag.U8: + return SyntaxHelpers.Type>(); + + case TypeTag.S16: + return SyntaxHelpers.Type>(); + + case TypeTag.U16: + case TypeTag.AnyEnum: + return SyntaxHelpers.Type>(); + + case TypeTag.S32: + return SyntaxHelpers.Type>(); + + case TypeTag.U32: + return SyntaxHelpers.Type>(); + + case TypeTag.S64: + return SyntaxHelpers.Type>(); + + case TypeTag.U64: + return SyntaxHelpers.Type>(); + + default: + throw new NotImplementedException("Unexpected type tag, don't know how to deal with this"); + } + } + + TypeSyntax MaybeNullableValueType(TypeSyntax typeSyntax, TypeUsage usage) + { + switch (usage) + { + case TypeUsage.DomainClassNullable: + return NullableType(typeSyntax); + + default: + return typeSyntax; + } + } + + public TypeSyntax MakeTypeSyntax(Model.Type type, TypeDefinition scope, TypeUsage usage) + { + switch (type.Tag) + { + case TypeTag.AnyEnum: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.CapabilityPointer: + if (type.Parameter != null) + { + return GetQName(type, scope); + } + else + { + return SyntaxHelpers.Type(); + } + + case TypeTag.AnyPointer: + case TypeTag.StructPointer: + switch (usage) + { + case TypeUsage.Reader: + return SyntaxHelpers.Type(); + + case TypeUsage.Writer: + return SyntaxHelpers.Type(); + + case TypeUsage.DomainClass: + case TypeUsage.DomainClassNullable: + if (type.Parameter != null) + { + return GetQName(type, scope); + } + else + { + return SyntaxHelpers.Type(); + } + + default: + throw new NotImplementedException(); + } + + case TypeTag.Bool: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.Data: + switch (usage) + { + case TypeUsage.Reader: + case TypeUsage.DomainClass: + case TypeUsage.DomainClassNullable: + return SyntaxHelpers.Type>(); + + case TypeUsage.Writer: + return SyntaxHelpers.Type>(); + + default: + throw new NotImplementedException(); + } + + case TypeTag.Enum: + return MaybeNullableValueType(GetQName(type, scope), usage); + + case TypeTag.Interface: + return GetQName(type, scope); + + case TypeTag.Struct: + case TypeTag.Group: + switch (usage) + { + case TypeUsage.Writer: + return QualifiedName(GetQName(type, scope), WriterStruct.IdentifierName); + + case TypeUsage.Reader: + return QualifiedName(GetQName(type, scope), ReaderStruct.IdentifierName); + + case TypeUsage.DomainClass: + case TypeUsage.DomainClassNullable: + return GetQName(type, scope); + + default: + throw new NotImplementedException(); + } + + case TypeTag.F32: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.F64: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.List when type.ElementType.Tag == TypeTag.Void && usage != TypeUsage.Writer: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.List: + switch (usage) + { + case TypeUsage.Writer: + return MakeListSerializerSyntax(type.ElementType, scope); + + case TypeUsage.Reader: + return GenericName(Identifier("IReadOnlyList")) + .AddTypeArgumentListArguments(MakeTypeSyntax(type.ElementType, scope, TypeUsage.Reader)); + + case TypeUsage.DomainClass: + case TypeUsage.DomainClassNullable: + return GenericName(Identifier("IReadOnlyList")) + .AddTypeArgumentListArguments(MakeTypeSyntax(type.ElementType, scope, TypeUsage.DomainClass)); + + default: + throw new NotImplementedException(); + } + + case TypeTag.ListPointer: + switch (usage) + { + case TypeUsage.Writer: + return SyntaxHelpers.Type(); + + case TypeUsage.Reader: + return SyntaxHelpers.Type>(); + + case TypeUsage.DomainClass: + case TypeUsage.DomainClassNullable: + return SyntaxHelpers.Type>(); + + default: + throw new NotImplementedException(); + } + + case TypeTag.S16: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.S32: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.S64: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.S8: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.Text: + return SyntaxHelpers.Type(); + + case TypeTag.U16: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.U32: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.U64: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.U8: + return MaybeNullableValueType(SyntaxHelpers.Type(), usage); + + case TypeTag.Void: + return PredefinedType(Token(SyntaxKind.VoidKeyword)); + + default: + throw new NotImplementedException("Unexpected type tag, don't know how to deal with this"); + } + } + + public string MakeParamsStructName(Method method) + { + return string.Format(ParamsStructFormat, method.Name); + } + + public string MakeResultStructName(Method method) + { + return string.Format(ResultStructFormat, method.Name); + } + + public Name GetCodeIdentifier(Method method) + { + return new Name(SyntaxHelpers.MakeCamel(method.Name)); + } + + public Name GetCodeIdentifier(Field field) + { + if (_fieldNameMap.TryGetValue(field, out var name)) + { + return name; + } + + var def = field.DeclaringType; + + if (def == null) + { + // Method parameters are internally represented with the same class "Field". + // They do not have a declaring type. Anyway, they don't suffer from the field-name-equals-nested-type-name problem. + return new Name(SyntaxHelpers.MakeCamel(field.Name)); + } + + var typeNames = new HashSet(def.NestedTypes.Select(t => MakeTypeName(t))); + + foreach (var member in def.Fields) + { + var memberName = new Name(SyntaxHelpers.MakeCamel(member.Name)); + + while (typeNames.Contains(memberName)) + { + memberName = new Name(string.Format(PropertyNamedLikeTypeRenameFormat, memberName.ToString())); + } + + _fieldNameMap.Add(member, memberName); + } + + return _fieldNameMap[field]; + } + + public Name GetGenericTypeParameter(string name) + { + return new Name(string.Format(GenericTypeParameterFormat, name)); + } + + public Name MakePipeliningSupportExtensionMethodName(IReadOnlyList path) + { + if (path.Count == 1 && path[0].Offset == 0) + return EagerMethod; + else + return new Name(string.Join("_", path.Select(f => GetCodeIdentifier(f).ToString()))); + } + + public Name MakeMemberAccessPathFieldName(Method method, IReadOnlyList path) + { + return new Name(string.Format(MemberAccessPathNameFormat, + method.Name, + MakePipeliningSupportExtensionMethodName(path))); + } + } +} diff --git a/capnpc-csharp/Generator/GeneratorOptions.cs b/capnpc-csharp/Generator/GeneratorOptions.cs new file mode 100644 index 0000000..76faf93 --- /dev/null +++ b/capnpc-csharp/Generator/GeneratorOptions.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace CapnpC.Generator +{ + class GeneratorOptions + { + public string TopNamespaceName { get; set; } = "CapnpGen"; + public string ReaderStructName { get; set; } = "READER"; + public string WriterStructName { get; set; } = "WRITER"; + public string ReaderParameterName { get; set; } = "reader"; + public string WriterParameterName { get; set; } = "writer"; + public string ReaderCreateMethodName { get; set; } = "create"; + public string ReaderContextFieldName { get; set; } = "ctx"; + public string ContextParameterName { get; set; } = "ctx"; + public string GroupReaderContextArgName { get; set; } = "ctx"; + public string GroupWriterContextArgName { get; set; } = "ctx"; + public string UnionDisciminatorEnumName { get; set; } = "WHICH"; + public string UnionDiscriminatorPropName { get; set; } = "which"; + public string UnionDiscriminatorFieldName { get; set; } = "_which"; + public string UnionDisciminatorUndefinedName { get; set; } = "undefined"; + public string UnionContentFieldName { get; set; } = "_content"; + public string SerializeMethodName { get; set; } = "serialize"; + public string ApplyDefaultsMethodName { get; set; } = "applyDefaults"; + public string AnonymousParameterName { get; set; } = "arg_"; + public string CancellationTokenParameterName { get; set; } = "cancellationToken_"; + public string ParamsLocalName { get; set; } = "in_"; + public string DeserializerLocalName { get; set; } = "d_"; + public string SerializerLocalName { get; set; } = "s_"; + public string ResultLocalName { get; set; } = "r_"; + public string ParamsStructFormat { get; set; } = "Params_{0}"; + public string ResultStructFormat { get; set; } = "Result_{0}"; + public string PropertyNamedLikeTypeRenameFormat { get; set; } = "The{0}"; + public string InstLocalName { get; set; } = "inst"; + public string GenericTypeParameterFormat { get; set; } = "T{0}"; + public string PipeliningExtensionsClassName { get; set; } = "PipeliningSupportExtensions"; + public string MemberAccessPathNameFormat { get; set; } = "Path_{0}_{1}"; + public string TaskParameterName { get; set; } = "task"; + public string EagerMethodName { get; set; } = "Eager"; + } +} diff --git a/capnpc-csharp/Generator/InterfaceSnippetGen.cs b/capnpc-csharp/Generator/InterfaceSnippetGen.cs new file mode 100644 index 0000000..f0adfaa --- /dev/null +++ b/capnpc-csharp/Generator/InterfaceSnippetGen.cs @@ -0,0 +1,844 @@ +using CapnpC.Model; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static CapnpC.Generator.SyntaxHelpers; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using System.Threading.Tasks; +using System.Threading; +using Microsoft.CodeAnalysis.CSharp; + +namespace CapnpC.Generator +{ + class InterfaceSnippetGen + { + readonly GenNames _names; + + public InterfaceSnippetGen(GenNames names) + { + _names = names; + } + + TypeSyntax TransformReturnType(Method method) + { + switch (method.Results.Count) + { + case 0: + return IdentifierName(nameof(Task)); + + case 1: + return GenericName(nameof(Task)).AddTypeArgumentListArguments( + _names.MakeTypeSyntax(method.Results[0].Type, method.DeclaringInterface, TypeUsage.DomainClass)); + + default: + return GenericName(nameof(Task)).AddTypeArgumentListArguments( + TupleType(SeparatedList( + method.Results.Select( + f => TupleElement(_names.MakeTypeSyntax(f.Type, method.DeclaringInterface, TypeUsage.DomainClass)))))); + } + } + + ParameterSyntax[] TransformParameters(Method method) + { + var list = new List(); + + if (method.Params.Count > 0) + { + var arg0 = method.Params[0]; + + if (arg0.Name == null) + { + list.Add(Parameter(_names.AnonymousParameter.Identifier) + .WithType(_names.MakeTypeSyntax(arg0.Type, method.DeclaringInterface, TypeUsage.DomainClass))); + } + else + { + foreach (var arg in method.Params) + { + list.Add(Parameter(Identifier(arg.Name)) + .WithType(_names.MakeTypeSyntax(arg.Type, method.DeclaringInterface, TypeUsage.DomainClass))); + } + } + } + + list.Add(Parameter(_names.CancellationTokenParameter.Identifier) + .WithType(IdentifierName(nameof(CancellationToken))) + .WithDefault(EqualsValueClause(LiteralExpression( + SyntaxKind.DefaultLiteralExpression, + Token(SyntaxKind.DefaultKeyword))))); + + return list.ToArray(); + } + + IEnumerable MakeTypeParameters(TypeDefinition def) + { + foreach (string name in def.GenericParameters) + { + yield return TypeParameter(_names.GetGenericTypeParameter(name).Identifier); + } + } + + IEnumerable MakeTypeParameterConstraints(TypeDefinition def) + { + foreach (string name in def.GenericParameters) + { + yield return TypeParameterConstraintClause( + _names.GetGenericTypeParameter(name).IdentifierName) + .AddConstraints(ClassOrStructConstraint(SyntaxKind.ClassConstraint)); + } + } + + public MemberDeclarationSyntax MakeInterface(TypeDefinition type) + { + var ifaceDecl = InterfaceDeclaration(_names.MakeTypeName(type, NameUsage.Interface).Identifier) + .AddModifiers(Public) + .AddAttributeLists( + AttributeList() + .AddAttributes( + Attribute(IdentifierName("Proxy")) + .AddArgumentListArguments( + AttributeArgument( + TypeOfExpression(_names.MakeGenericTypeNameForAttribute(type, NameUsage.Proxy)))), + Attribute(IdentifierName("Skeleton")) + .AddArgumentListArguments( + AttributeArgument( + TypeOfExpression(_names.MakeGenericTypeNameForAttribute(type, NameUsage.Skeleton)))))); + + if (type.GenericParameters.Count > 0) + { + ifaceDecl = ifaceDecl.AddTypeParameterListParameters(MakeTypeParameters(type).ToArray()); + } + + if (type.Superclasses.Count == 0) + { + ifaceDecl = ifaceDecl.AddBaseListTypes(SimpleBaseType(IdentifierName(nameof(IDisposable)))); + } + else + { + foreach (var superClass in type.Superclasses) + { + ifaceDecl = ifaceDecl.AddBaseListTypes( + SimpleBaseType(_names.MakeTypeSyntax( + superClass, type, + TypeUsage.NotRelevant))); + } + } + + foreach (var method in type.Methods) + { + var methodDecl = MethodDeclaration( + TransformReturnType(method), + _names.GetCodeIdentifier(method).Identifier) + .AddParameterListParameters(TransformParameters(method)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + + if (method.GenericParameters.Count > 0) + { + methodDecl = methodDecl + .AddTypeParameterListParameters(MakeTypeParameters(method).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(method).ToArray()); + + } + + ifaceDecl = ifaceDecl.AddMembers(methodDecl); + } + + return ifaceDecl; + } + + bool IsSubjectToPipelining(Model.Type type, HashSet visited) + { + if (!visited.Add(type)) + return false; + + switch (type.Tag) + { + case TypeTag.AnyPointer: + case TypeTag.CapabilityPointer: + case TypeTag.Interface: + case TypeTag.ListPointer: + case TypeTag.StructPointer: + return true; + + case TypeTag.List: + return IsSubjectToPipelining(type.ElementType, visited); + + case TypeTag.Struct: + return type.Fields.Any(f => IsSubjectToPipelining(f.Type, visited)); + + default: + return false; + } + } + + bool IsSubjectToPipelining(Method method) + { + return method.Results.Any(r => IsSubjectToPipelining(r.Type, new HashSet())); + } + + IEnumerable MakeProxyCallInitializerAssignments(Method method) + { + foreach (var methodParam in method.Params) + { + yield return AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.GetCodeIdentifier(methodParam).IdentifierName, + IdentifierName(methodParam.Name)); + } + } + + IEnumerable MakeProxyReturnResultTupleElements(Method method) + { + foreach (var item in method.ResultStruct.Fields) + { + yield return Argument(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ResultLocal.IdentifierName, + _names.GetCodeIdentifier(item).IdentifierName)); + } + } + + StatementSyntax MakeProxyReturnResult(Method method) + { + if (method.ResultStruct.Definition.SpecialName == SpecialName.MethodResultStruct) + { + if (method.ResultStruct.Fields.Count == 0) + { + return ReturnStatement(); + } + else + { + return ReturnStatement(TupleExpression() + .AddArguments(MakeProxyReturnResultTupleElements(method).ToArray())); + } + + } + else + { + return ReturnStatement(_names.ResultLocal.IdentifierName); + } + } + + StatementSyntax MakeProxyCreateResult(Method method) + { + var resultType = method.ResultStruct; + var domainType = _names.MakeTypeSyntax(resultType, method.DeclaringInterface, TypeUsage.DomainClass); + + var createDomain = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.CapnpSerializable)), + GenericName(nameof(Capnp.CapnpSerializable.Create)) + .AddTypeArgumentListArguments(domainType))) + .AddArgumentListArguments( + Argument(_names.DeserializerLocal.IdentifierName)); + + return LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + _names.ResultLocal.Identifier) + .WithInitializer( + EqualsValueClause(createDomain))))); + } + + IEnumerable MakeTypeParameters(Method method) + { + foreach (string name in method.GenericParameters) + { + yield return TypeParameter(_names.GetGenericTypeParameter(name).Identifier); + } + } + + IEnumerable MakeTypeParameterConstraints(Method method) + { + foreach (string name in method.GenericParameters) + { + yield return TypeParameterConstraintClause( + _names.GetGenericTypeParameter(name).IdentifierName) + .AddConstraints(ClassOrStructConstraint(SyntaxKind.ClassConstraint)); + } + } + + public MemberDeclarationSyntax MakeProxy(TypeDefinition type) + { + var classDecl = ClassDeclaration(_names.MakeTypeName(type, NameUsage.Proxy).Identifier) + .AddModifiers(Public) + .AddBaseListTypes( + SimpleBaseType(Type()), + SimpleBaseType(_names.MakeGenericTypeName(type, NameUsage.Interface))); + + if (type.GenericParameters.Count > 0) + { + classDecl = classDecl + .AddTypeParameterListParameters(MakeTypeParameters(type).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(type).ToArray()); + } + + var allMethods = + from c in Types.FromDefinition(type).AllImplementedClasses + from m in c.Definition.Methods + select m; + + foreach (var method in allMethods) + { + var bodyStmts = new List(); + + bodyStmts.Add(LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + _names.ParamsLocal.Identifier) + .WithInitializer( + EqualsValueClause( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.SerializerState)), + GenericName( + Identifier(nameof(Capnp.SerializerState.CreateForRpc))) + .WithTypeArgumentList( + TypeArgumentList( + SingletonSeparatedList( + _names.MakeTypeSyntax( + method.ParamsStruct, + method.ParamsStruct.Definition, + TypeUsage.Writer)))))))))))); + + if (method.ParamsStruct.Definition.SpecialName == SpecialName.MethodParamsStruct) + { + bodyStmts.Add(LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + _names.AnonymousParameter.Identifier) + .WithInitializer( + EqualsValueClause( + ObjectCreationExpression( + _names.MakeTypeSyntax( + method.ParamsStruct, + method.ParamsStruct.Definition, + TypeUsage.DomainClass)) + .WithArgumentList( + ArgumentList()) + .WithInitializer( + InitializerExpression( + SyntaxKind.ObjectInitializerExpression, + SeparatedList( + CommonSnippetGen.MakeCommaSeparatedList( + MakeProxyCallInitializerAssignments(method)).ToArray()))))))))); + } + + bodyStmts.Add(ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.AnonymousParameter.IdentifierName, + _names.SerializeMethod.IdentifierName)) + .AddArgumentListArguments( + Argument(_names.ParamsLocal.IdentifierName)))); + + var call = InvocationExpression(IdentifierName(nameof(Capnp.Rpc.BareProxy.Call))) + .AddArgumentListArguments( + Argument( + LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal(method.DeclaringInterface.Id))), + Argument( + LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(method.Id))), + Argument( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ParamsLocal.IdentifierName, + GenericName(nameof(Capnp.SerializerState.Rewrap)) + .AddTypeArgumentListArguments(Type()))) + .AddArgumentListArguments()), + Argument( + LiteralExpression(SyntaxKind.FalseLiteralExpression)), + Argument( + _names.CancellationTokenParameter.IdentifierName)); + + MethodDeclarationSyntax methodDecl; + + if (IsSubjectToPipelining(method)) + { + methodDecl = MethodDeclaration( + TransformReturnType(method), + _names.GetCodeIdentifier(method).Identifier) + .AddParameterListParameters(TransformParameters(method)) + .AddModifiers(Public); + + var pipelineAwareCall = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.Rpc.Impatient)), + IdentifierName(nameof(Capnp.Rpc.Impatient.MakePipelineAware)))) + .AddArgumentListArguments( + Argument(call), + Argument(SimpleLambdaExpression( + Parameter(_names.DeserializerLocal.Identifier), + Block( + MakeProxyCreateResult(method), + MakeProxyReturnResult(method))))); + + bodyStmts.Add(ReturnStatement(pipelineAwareCall)); + } + else + { + methodDecl = MethodDeclaration( + TransformReturnType(method), + _names.GetCodeIdentifier(method).Identifier) + .AddParameterListParameters(TransformParameters(method)) + .AddModifiers(Public, Token(SyntaxKind.AsyncKeyword)); + + var whenReturned = MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + call, + IdentifierName(nameof(Capnp.Rpc.IPromisedAnswer.WhenReturned))); + + var assignAwaited = LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .AddVariables( + VariableDeclarator( + _names.DeserializerLocal.Identifier) + .WithInitializer( + EqualsValueClause( + AwaitExpression(whenReturned))))); + + bodyStmts.Add(assignAwaited); + bodyStmts.Add(MakeProxyCreateResult(method)); + bodyStmts.Add(MakeProxyReturnResult(method)); + } + + if (method.GenericParameters.Count > 0) + { + methodDecl = methodDecl + .AddTypeParameterListParameters(MakeTypeParameters(method).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(method).ToArray()); + } + + methodDecl = methodDecl.AddBodyStatements(bodyStmts.ToArray()); + + classDecl = classDecl.AddMembers(methodDecl); + } + + return classDecl; + } + + IEnumerable MakeSkeletonSetMethodTableArguments(TypeDefinition def) + { + foreach (var method in def.Methods) + { + if (method.GenericParameters.Count > 0) + { + yield return Argument( + GenericName(_names.GetCodeIdentifier(method).ToString()) + .AddTypeArgumentListArguments( + Enumerable.Repeat( + Type(), + method.GenericParameters.Count).ToArray())); + } + else + { + yield return Argument(_names.GetCodeIdentifier(method).IdentifierName); + } + } + } + + IEnumerable MakeSkeletonMethodResultStructInitializer(Method method) + { + foreach (var arg in method.Results) + { + yield return AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + _names.GetCodeIdentifier(arg).IdentifierName, + IdentifierName(arg.Name)); + } + } + + IEnumerable MakeSkeletonMethodCallArgs(Method method) + { + foreach (var arg in method.ParamsStruct.Fields) + { + yield return Argument( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ParamsLocal.IdentifierName, + _names.GetCodeIdentifier(arg).IdentifierName)); + } + } + + StatementSyntax MakeSkeletonMethodSerializerLocalDeclaration(Method method) + { + return LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + _names.SerializerLocal.Identifier) + .WithInitializer( + EqualsValueClause( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.SerializerState)), + GenericName( + Identifier(nameof(Capnp.SerializerState.CreateForRpc))) + .WithTypeArgumentList( + TypeArgumentList( + SingletonSeparatedList( + _names.MakeTypeSyntax( + method.ResultStruct, + method.ResultStruct.Definition, + TypeUsage.Writer))))))))))); + + } + + CSharpSyntaxNode MakeMaybeTailCallLambdaBody(Method method) + { + var block = Block( + MakeSkeletonMethodSerializerLocalDeclaration(method)); + + if (method.ResultStruct.Definition.SpecialName == SpecialName.MethodResultStruct) + { + block = block.AddStatements( + LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .AddVariables( + VariableDeclarator(_names.ResultLocal.Identifier) + .WithInitializer(EqualsValueClause(ObjectCreationExpression( + _names.MakeTypeSyntax( + method.ResultStruct, + method.ResultStruct.Definition, + TypeUsage.DomainClass)) + .WithInitializer( + InitializerExpression(SyntaxKind.ObjectInitializerExpression) + .AddExpressions( + MakeSkeletonMethodResultStructInitializer(method).ToArray()))))))); + } + + if (method.Results.Count > 0) + { + block = block.AddStatements( + ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ResultLocal.IdentifierName, + _names.SerializeMethod.IdentifierName)) + .AddArgumentListArguments( + Argument(_names.SerializerLocal.IdentifierName)))); + } + + block = block.AddStatements( + ReturnStatement(_names.SerializerLocal.IdentifierName)); + + return block; + } + + IEnumerable MakeSkeletonMethodBody(Method method) + { + var call = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(SkeletonWorder.ImplName), + _names.GetCodeIdentifier(method).IdentifierName)); + + if (method.Params.Count > 0) + { + var paramsType = method.ParamsStruct; + var domainType = _names.MakeTypeSyntax(paramsType, method.ParamsStruct.Definition, TypeUsage.DomainClass); + + var createDomain = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.CapnpSerializable)), + GenericName(nameof(Capnp.CapnpSerializable.Create)) + .AddTypeArgumentListArguments(domainType))) + .AddArgumentListArguments( + Argument(_names.DeserializerLocal.IdentifierName)); + + if (method.ParamsStruct.Definition.SpecialName == SpecialName.MethodParamsStruct) + { + yield return LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .AddVariables( + VariableDeclarator(_names.ParamsLocal.Identifier) + .WithInitializer(EqualsValueClause(createDomain)))); + + call = call.AddArgumentListArguments( + MakeSkeletonMethodCallArgs(method).ToArray()); + } + else + { + call = call.AddArgumentListArguments( + Argument(createDomain)); + } + } + + call = call.AddArgumentListArguments( + Argument( + _names.CancellationTokenParameter.IdentifierName)); + + if (method.Results.Count == 0) + { + var awaitCall = AwaitExpression(call); + yield return ExpressionStatement(awaitCall); + yield return MakeSkeletonMethodSerializerLocalDeclaration(method); + yield return ReturnStatement(_names.SerializerLocal.IdentifierName); + } + else + { + ExpressionSyntax lambdaArg; + + if (method.ResultStruct.Definition.SpecialName == SpecialName.MethodResultStruct) + { + if (method.Results.Count == 1) + { + lambdaArg = SimpleLambdaExpression( + Parameter(Identifier(method.Results.Single().Name)), + MakeMaybeTailCallLambdaBody(method)); + } + else + { + lambdaArg = ParenthesizedLambdaExpression( + MakeMaybeTailCallLambdaBody(method)) + .AddParameterListParameters( + method.Results.Select(arg => Parameter(Identifier(arg.Name))).ToArray()); + } + } + else + { + lambdaArg = SimpleLambdaExpression( + Parameter(_names.ResultLocal.Identifier), + MakeMaybeTailCallLambdaBody(method)); + + } + + var maybeTailCall = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.Rpc.Impatient)), + IdentifierName(nameof(Capnp.Rpc.Impatient.MaybeTailCall)))) + .AddArgumentListArguments( + Argument(call), + Argument(lambdaArg)); + + yield return ReturnStatement(maybeTailCall); + } + } + + IEnumerable MakeSkeletonMethods(TypeDefinition def) + { + foreach (var method in def.Methods) + { + var methodDecl = MethodDeclaration( + Type>(), + _names.GetCodeIdentifier(method).Identifier) + .AddParameterListParameters( + Parameter(_names.DeserializerLocal.Identifier) + .WithType(Type()), + Parameter(_names.CancellationTokenParameter.Identifier) + .WithType(Type())) + .AddBodyStatements( + MakeSkeletonMethodBody(method).ToArray()); + + if (method.Results.Count == 0) + { + methodDecl = methodDecl.AddModifiers(Async); + } + + if (method.GenericParameters.Count > 0) + { + methodDecl = methodDecl + .AddTypeParameterListParameters(MakeTypeParameters(method).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(method).ToArray()); + } + + yield return methodDecl; + } + } + + public MemberDeclarationSyntax MakeSkeleton(TypeDefinition type) + { + var name = _names.MakeTypeName(type, NameUsage.Skeleton).Identifier; + var classDecl = ClassDeclaration(name) + .AddModifiers(Public) + .AddBaseListTypes( + SimpleBaseType( + GenericName(nameof(Capnp.Rpc.Skeleton)) + .AddTypeArgumentListArguments( + _names.MakeGenericTypeName(type, NameUsage.Interface)))) + .AddMembers( + // C'tor + ConstructorDeclaration(name) + .AddModifiers(Public) + .AddBodyStatements( + ExpressionStatement( + InvocationExpression( + IdentifierName(SkeletonWorder.SetMethodTableName)) + .AddArgumentListArguments( + MakeSkeletonSetMethodTableArguments(type).ToArray()))), + // InterfaceId + PropertyDeclaration(Type(), nameof(Capnp.Rpc.Skeleton.InterfaceId)) + .AddModifiers(Public, Override) + .WithExpressionBody( + ArrowExpressionClause( + ValueOf(type.Id))) + .WithSemicolonToken( + Token(SyntaxKind.SemicolonToken))); + + if (type.GenericParameters.Count > 0) + { + classDecl = classDecl + .AddTypeParameterListParameters(MakeTypeParameters(type).ToArray()) + .AddConstraintClauses(MakeTypeParameterConstraints(type).ToArray()); + } + + classDecl = classDecl.AddMembers(MakeSkeletonMethods(type).ToArray()); + + return classDecl; + } + + public bool RequiresPipeliningSupport(TypeDefinition type) + { + return type.Methods.Any(m => ExpandPipeliningPaths(m).Any()); + } + + IEnumerable> ExpandPipeliningPaths(Method method) + { + var stack = new Stack>(); + foreach (var field in method.ResultStruct.Fields) + { + stack.Push(new List() { field }); + } + + while (stack.Count > 0) + { + var path = stack.Pop(); + var last = path[path.Count - 1]; + + switch (last.Type.Tag) + { + case TypeTag.Interface: + case TypeTag.CapabilityPointer: + yield return path; + break; + + case TypeTag.Struct: + foreach (var field in last.Type.Fields) + { + if (path.Contains(field)) + { + // Recursive structs protection + continue; + } + + var copy = new List(); + copy.AddRange(path); + copy.Add(field); + stack.Push(copy); + } + break; + } + } + } + + readonly HashSet<(string, string)> _existingExtensionMethods = new HashSet<(string, string)>(); + + public MemberDeclarationSyntax MakePipeliningSupport(TypeDefinition type) + { + var classDecl = ClassDeclaration(_names.PipeliningExtensionsClassName.Identifier) + .AddModifiers(Public, Static, Partial); + + foreach (var method in type.Methods) + { + foreach (var path in ExpandPipeliningPaths(method)) + { + var accessPath = _names.MakeMemberAccessPathFieldName(method, path); + var methodName = _names.MakePipeliningSupportExtensionMethodName(path); + var capType = path[path.Count - 1].Type; + var capTypeSyntax = _names.MakeTypeSyntax(capType, null, TypeUsage.DomainClass); + + if (!_existingExtensionMethods.Add((capTypeSyntax.ToString(), methodName.ToString()))) + { + continue; + } + + var pathDecl = FieldDeclaration( + VariableDeclaration( + IdentifierName(nameof(Capnp.Rpc.MemberAccessPath))) + .AddVariables( + VariableDeclarator( + accessPath.Identifier) + .WithInitializer( + EqualsValueClause( + ObjectCreationExpression( + IdentifierName(nameof(Capnp.Rpc.MemberAccessPath))) + .AddArgumentListArguments( + path.Select( + f => Argument( + LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal(f.Offset)))).ToArray()))))) + .AddModifiers(Static, Readonly); + + + var methodDecl = MethodDeclaration( + capTypeSyntax, + methodName.Identifier) + .AddModifiers(Public, Static) + .AddParameterListParameters( + Parameter( + _names.TaskParameter.Identifier) + .AddModifiers(This) + .WithType(TransformReturnType(method))) + .AddBodyStatements( + ReturnStatement( + CastExpression( + capTypeSyntax, + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.Rpc.CapabilityReflection)), + GenericName( + Identifier(nameof(Capnp.Rpc.CapabilityReflection.CreateProxy))) + .AddTypeArgumentListArguments( + capTypeSyntax))) + .AddArgumentListArguments( + Argument( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName(nameof(Capnp.Rpc.Impatient)), + IdentifierName(nameof(Capnp.Rpc.Impatient.GetAnswer)))) + .AddArgumentListArguments( + Argument( + _names.TaskParameter.IdentifierName)), + IdentifierName(nameof(Capnp.Rpc.IPromisedAnswer.Access)))) + .AddArgumentListArguments( + Argument( + accessPath.IdentifierName))))))); + + classDecl = classDecl.AddMembers(pathDecl, methodDecl); + } + } + + return classDecl; + } + } +} diff --git a/capnpc-csharp/Generator/Name.cs b/capnpc-csharp/Generator/Name.cs new file mode 100644 index 0000000..f85f324 --- /dev/null +++ b/capnpc-csharp/Generator/Name.cs @@ -0,0 +1,35 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using System; +using System.Collections.Generic; +using System.Text; + +namespace CapnpC.Generator +{ + class Name + { + readonly string _name; + + public Name(string name) + { + _name = name ?? throw new ArgumentNullException(nameof(name)); + IdentifierName = SyntaxFactory.IdentifierName(_name); + Identifier = SyntaxFactory.Identifier(_name); + VariableDeclarator = SyntaxFactory.VariableDeclarator(_name); + } + + public IdentifierNameSyntax IdentifierName { get; } + public SyntaxToken Identifier { get; } + public VariableDeclaratorSyntax VariableDeclarator { get; } + + public override string ToString() => _name; + + public override bool Equals(object obj) + { + return obj is Name other && _name == other._name; + } + + public override int GetHashCode() => _name.GetHashCode(); + } +} diff --git a/capnpc-csharp/Generator/ReaderSnippetGen.cs b/capnpc-csharp/Generator/ReaderSnippetGen.cs new file mode 100644 index 0000000..9d57038 --- /dev/null +++ b/capnpc-csharp/Generator/ReaderSnippetGen.cs @@ -0,0 +1,715 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using CapnpC.Model; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static CapnpC.Generator.SyntaxHelpers; + +namespace CapnpC.Generator +{ + class ReaderSnippetGen + { + readonly GenNames _names; + + public ReaderSnippetGen(GenNames names) + { + _names = names; + } + + MemberDeclarationSyntax MakeReaderImplicitConversionOperator1() + { + return ConversionOperatorDeclaration( + Token(SyntaxKind.ImplicitKeyword), + IdentifierName(nameof(Capnp.DeserializerState))) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.StaticKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter(_names.ReaderParameter.Identifier) + .WithType(_names.ReaderStruct.IdentifierName)))) + .WithExpressionBody( + ArrowExpressionClause( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderParameter.IdentifierName, + _names.ReaderContextField.IdentifierName))) + .WithSemicolonToken( + Token(SyntaxKind.SemicolonToken)); + } + + MemberDeclarationSyntax MakeReaderImplicitConversionOperator2() + { + return ConversionOperatorDeclaration( + Token(SyntaxKind.ImplicitKeyword), + _names.ReaderStruct.IdentifierName) + .WithModifiers( + TokenList( + new[] { + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.StaticKeyword) })) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter(_names.ReaderContextField.Identifier) + .WithType(Type())))) + .WithExpressionBody( + ArrowExpressionClause( + ObjectCreationExpression(_names.ReaderStruct.IdentifierName) + .WithArgumentList( + ArgumentList( + SingletonSeparatedList( + Argument(_names.ReaderContextField.IdentifierName)))))) + .WithSemicolonToken( + Token(SyntaxKind.SemicolonToken)); + } + + MemberDeclarationSyntax MakeReaderCreateMethod() + { + return MethodDeclaration(_names.ReaderStruct.IdentifierName, _names.ReaderCreateMethod.Identifier) + .AddModifiers(Public, Static) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter(_names.ContextParameter.Identifier) + .WithType( + Type())))) + .WithExpressionBody( + ArrowExpressionClause( + ObjectCreationExpression(_names.ReaderStruct.IdentifierName) + .AddArgumentListArguments(Argument(_names.ContextParameter.IdentifierName)))) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + } + + IEnumerable MakeReaderStructMembers() + { + yield return FieldDeclaration( + VariableDeclaration( + Type()) + .AddVariables(_names.ReaderContextField.VariableDeclarator)) + .AddModifiers(Readonly); + + yield return ConstructorDeclaration(_names.ReaderStruct.Identifier) + .AddModifiers(Public) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter(_names.ContextParameter.Identifier) + .WithType(Type())))) + .WithBody( + Block( + SingletonList( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + _names.ReaderContextField.IdentifierName), + _names.ContextParameter.IdentifierName))))); + + yield return MakeReaderCreateMethod(); + yield return MakeReaderImplicitConversionOperator1(); + yield return MakeReaderImplicitConversionOperator2(); + } + + IEnumerable MakeGroupReaderStructMembers() + { + yield return FieldDeclaration( + VariableDeclaration( + Type()) + .AddVariables(_names.ReaderContextField.VariableDeclarator)) + .AddModifiers(Readonly); + + yield return ConstructorDeclaration(_names.ReaderStruct.Identifier) + .AddModifiers(Public) + .WithParameterList( + ParameterList( + SingletonSeparatedList(Parameter(_names.GroupReaderContextArg.Identifier) + .WithType(Type())))) + .WithBody( + Block( + SingletonList( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + _names.ReaderContextField.IdentifierName), + _names.GroupReaderContextArg.IdentifierName))))); + + yield return MakeReaderCreateMethod(); + yield return MakeReaderImplicitConversionOperator1(); + yield return MakeReaderImplicitConversionOperator2(); + } + + PropertyDeclarationSyntax MakeReaderProperty(TypeSyntax type, string name, ExpressionSyntax right, bool cond) + { + if (cond) + { + right = ConditionalExpression( + BinaryExpression( + SyntaxKind.EqualsExpression, + _names.UnionDiscriminatorProp.IdentifierName, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + IdentifierName(name))), + right, + LiteralExpression( + SyntaxKind.DefaultLiteralExpression, + Token(SyntaxKind.DefaultKeyword))); + } + + return PropertyDeclaration(type, name) + .AddModifiers(Public) + .WithExpressionBody(ArrowExpressionClause(right)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + } + + static Func MakeCastFunc(TypeSyntax type) => + x => CastExpression(type, x); + + static Func MakeListCastFunc(string castName, Field field) + { + // Insight: List may have complex default values (e.g. [true, false, false, true] as a + // valid default value for a list of bools. This does not yet fit the author's mindset. + + //if (field.DefaultValueIsExplicit) + //{ + // return x => InvocationExpression( + // MemberAccessExpression( + // SyntaxKind.SimpleMemberAccessExpression, + // x, + // IdentifierName(castName)) + // ) + // .AddArgumentListArguments( + // Argument(ValueOf(field.DefaultValue))); + //} + //else + + { + return x => InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + x, + IdentifierName(castName)) + ); + } + } + + static Func MakeListCastFuncWithCons( + string castName, ExpressionSyntax cons) + { + return x => InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + x, + IdentifierName(castName)) + ).AddArgumentListArguments(Argument(cons)); + } + + static Func MakeGenericListCastFunc(string castName, TypeSyntax genericArgument) + { + return x => InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + x, + GenericName(castName).AddTypeArgumentListArguments(genericArgument)) + ); + } + + PropertyDeclarationSyntax MakeReadProperty(TypeSyntax type, string name, SimpleNameSyntax readName, + object indexOrBitOffset, ExpressionSyntax secondArg, + Func cast, bool cond) + { + var right = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderContextField.IdentifierName, + readName)) + .AddArgumentListArguments( + Argument(ValueOf(indexOrBitOffset))); + + if (secondArg != null) + { + right = right.AddArgumentListArguments(Argument(secondArg)); + } + + ExpressionSyntax expr = right; + + if (cast != null) + { + expr = cast(expr); + } + + return MakeReaderProperty(type, name, expr, cond); + } + + PropertyDeclarationSyntax MakeReadProperty(TypeSyntax type, string name, string readName, + object indexOrBitOffset, ExpressionSyntax secondArg, + Func cast, bool cond) + { + return MakeReadProperty(type, name, IdentifierName(readName), indexOrBitOffset, secondArg, cast, cond); + } + + PropertyDeclarationSyntax MakeReadPrimitiveProperty(Field field, string readName) + { + return MakeReadProperty(Type(), _names.GetCodeIdentifier(field).ToString(), readName, field.BitOffset.Value, + ValueOf(field.DefaultValue.ScalarValue), null, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadEnumProperty(Field field) + { + var typeSyntax = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader); + return MakeReadProperty(typeSyntax, + _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.SerializerExtensions.ReadDataUShort), field.BitOffset.Value, + ValueOf(field.DefaultValue.ScalarValue), + x => CastExpression(typeSyntax, x), + field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadTextProperty(Field field) + { + return MakeReadProperty(Type(), _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.DeserializerState.ReadText), (int)field.Offset, + ValueOf(field.DefaultValue.ScalarValue), null, field.DiscValue.HasValue); + } + + MemberAccessExpressionSyntax MakeReaderCreator(TypeSyntax qtype) + { + return MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + qtype, + _names.ReaderCreateMethod.IdentifierName); + } + + PropertyDeclarationSyntax MakeReadStructProperty(Field field) + { + var qtype = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader); + var creator = MakeReaderCreator(qtype); + + return MakeReadProperty(qtype, _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.DeserializerState.ReadStruct), (int)field.Offset, + creator, null, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadGroupProperty(Field field) + { + var type = QualifiedName( + _names.MakeTypeName(field.Type.Definition).IdentifierName, + _names.ReaderStruct.IdentifierName); + + var right = ObjectCreationExpression(type) + .WithArgumentList( + ArgumentList( + SingletonSeparatedList( + Argument(_names.ReaderContextField.IdentifierName)))); + + return MakeReaderProperty(type, _names.GetCodeIdentifier(field).ToString(), right, field.DiscValue.HasValue); + } + + void MakeReadListPropertyImpl(Model.Type elementType, TypeDefinition scope, ExpressionSyntax context, int depth, + out TypeSyntax listType, out ExpressionSyntax impl) + { + var elementTypeSyntax = _names.MakeTypeSyntax(elementType, scope, TypeUsage.Reader); + listType = GenericName("IReadOnlyList").AddTypeArgumentListArguments(elementTypeSyntax); + + if (elementType.Tag == TypeTag.Interface || + elementType.Tag == TypeTag.CapabilityPointer) + { + if (depth == 0) + { + impl = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderContextField.IdentifierName, + GenericName(nameof(Capnp.DeserializerState.ReadCapList)) + .AddTypeArgumentListArguments(elementTypeSyntax) + )).AddArgumentListArguments(Argument(context)); + } + else + { + impl = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + GenericName(nameof(Capnp.DeserializerState.RequireCapList)) + .AddTypeArgumentListArguments(elementTypeSyntax) + )); + } + + return; + } + + if (depth == 0) + { + context = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderContextField.IdentifierName, + IdentifierName(nameof(Capnp.DeserializerState.ReadList)))) + .AddArgumentListArguments(Argument(context)); + } + else + { + context = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.DeserializerState.RequireList)) + )); + } + + string lambdaParamName = "_" + depth; + var lambdaParam = Parameter(Identifier(lambdaParamName)); + var lambdaArg = IdentifierName(lambdaParamName); + string castFuncName; + + switch (elementType.Tag) + { + case TypeTag.List: + { + + MakeReadListPropertyImpl( + elementType.ElementType, + scope, + lambdaArg, + depth + 1, + out var innerListType, + out var innerImpl); + + listType = GenericName("IReadOnlyList").AddTypeArgumentListArguments(innerListType); + + impl = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ListDeserializer.Cast)))) + .AddArgumentListArguments( + Argument(SimpleLambdaExpression(lambdaParam, innerImpl))); + + return; + } + + case TypeTag.ListPointer: + { + listType = Type>(); + + context = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.DeserializerState.RequireList)) + )).AddArgumentListArguments(Argument(lambdaArg)); + + impl = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ReadOnlyListExtensions.LazyListSelect)))) + .AddArgumentListArguments( + Argument(SimpleLambdaExpression(lambdaParam, context))); + + return; + } + + case TypeTag.Struct: + { + impl = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ListDeserializer.Cast)))) + .AddArgumentListArguments( + Argument(MakeReaderCreator(elementTypeSyntax))); + + return; + } + + case TypeTag.Enum: + { + var cons = SimpleLambdaExpression( + lambdaParam, + CastExpression(elementTypeSyntax, lambdaArg)); + + impl = InvocationExpression( + MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ListDeserializer.CastEnums)))) + .AddArgumentListArguments( + Argument(cons)); + + return; + } + + case TypeTag.AnyPointer: + case TypeTag.StructPointer: + { + listType = Type>(); + impl = context; + return; + } + + case TypeTag.Void: + { + listType = Type(); + impl = MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ListDeserializer.Count))); + return; + } + + case TypeTag.Data: + castFuncName = nameof(Capnp.ListDeserializer.CastData); + break; + + case TypeTag.Text: + castFuncName = nameof(Capnp.ListDeserializer.CastText2); + break; + + case TypeTag.Bool: + castFuncName = nameof(Capnp.ListDeserializer.CastBool); + break; + + case TypeTag.F32: + castFuncName = nameof(Capnp.ListDeserializer.CastFloat); + break; + + case TypeTag.F64: + castFuncName = nameof(Capnp.ListDeserializer.CastDouble); + break; + + case TypeTag.S8: + castFuncName = nameof(Capnp.ListDeserializer.CastSByte); + break; + + case TypeTag.U8: + castFuncName = nameof(Capnp.ListDeserializer.CastByte); + break; + + case TypeTag.S16: + castFuncName = nameof(Capnp.ListDeserializer.CastShort); + break; + + case TypeTag.U16: + case TypeTag.AnyEnum: + castFuncName = nameof(Capnp.ListDeserializer.CastUShort); + break; + + case TypeTag.S32: + castFuncName = nameof(Capnp.ListDeserializer.CastInt); + break; + + case TypeTag.U32: + castFuncName = nameof(Capnp.ListDeserializer.CastUInt); + break; + + case TypeTag.S64: + castFuncName = nameof(Capnp.ListDeserializer.CastLong); + break; + + case TypeTag.U64: + castFuncName = nameof(Capnp.ListDeserializer.CastULong); + break; + + default: + throw new NotImplementedException("Unexpected type tag, don't know how to deal with this"); + } + + impl = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(castFuncName))); + } + + PropertyDeclarationSyntax MakeReadListProperty(Field field) + { + var elementType = field.Type.ElementType; + var context = ValueOf((int)field.Offset); + MakeReadListPropertyImpl(elementType, field.DeclaringType, context, 0, out var listType, out var impl); + return MakeReaderProperty(listType, _names.GetCodeIdentifier(field).ToString(), impl, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadAnyListProperty(Field field) + { + var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader); + + return MakeReadProperty(type, _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.DeserializerState.ReadList), + (int)field.Offset, null, x => CastExpression(type, x), field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadCapProperty(Field field) + { + var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader); + var readName = GenericName(nameof(Capnp.DeserializerState.ReadCap)) + .AddTypeArgumentListArguments(type); + + return MakeReadProperty(type, _names.GetCodeIdentifier(field).ToString(), + readName, + (int)field.Offset, null, null, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadAnyCapProperty(Field field) + { + var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader); + + return MakeReadProperty(type, _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.DeserializerState.ReadCap), + (int)field.Offset, null, null, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadDataProperty(Field field) + { + var context = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.ReaderContextField.IdentifierName, + IdentifierName(nameof(Capnp.DeserializerState.ReadList)))) + .AddArgumentListArguments(Argument(ValueOf((int)field.Offset))); + var impl = InvocationExpression(MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + context, + IdentifierName(nameof(Capnp.ListDeserializer.CastByte)))); + + return MakeReaderProperty( + _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Reader), + _names.GetCodeIdentifier(field).ToString(), impl, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReadAnyPointerProperty(Field field) + { + var type = IdentifierName(nameof(Capnp.DeserializerState)); + + return MakeReadProperty(type, _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.DeserializerState.StructReadPointer), + (int)field.Offset, null, null, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeReaderUnionSelector(TypeDefinition def) + { + var type = _names.UnionDiscriminatorEnum.IdentifierName; + return MakeReadProperty( + type, + _names.UnionDiscriminatorProp.ToString(), + nameof(Capnp.SerializerExtensions.ReadDataUShort), + def.UnionInfo.TagOffset, + ValueOf(default(ushort)), + MakeCastFunc(type), false); + } + + PropertyDeclarationSyntax MakeReaderFieldProperty(Field field) + { + switch (field.Type.Tag) + { + case TypeTag.Bool: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataBool)); + + case TypeTag.S8: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataSByte)); + + case TypeTag.U8: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataByte)); + + case TypeTag.S16: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataShort)); + + case TypeTag.U16: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataUShort)); + + case TypeTag.S32: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataInt)); + + case TypeTag.U32: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataUInt)); + + case TypeTag.S64: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataLong)); + + case TypeTag.U64: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataULong)); + + case TypeTag.F32: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataFloat)); + + case TypeTag.F64: + return MakeReadPrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataDouble)); + + case TypeTag.Enum: + return MakeReadEnumProperty(field); + + case TypeTag.Text: + return MakeReadTextProperty(field); + + case TypeTag.Struct: + return MakeReadStructProperty(field); + + case TypeTag.Group: + return MakeReadGroupProperty(field); + + case TypeTag.List: + return MakeReadListProperty(field); + + case TypeTag.Interface: + return MakeReadCapProperty(field); + + case TypeTag.CapabilityPointer: + return MakeReadAnyCapProperty(field); + + case TypeTag.ListPointer: + return MakeReadAnyListProperty(field); + + case TypeTag.AnyPointer: + case TypeTag.StructPointer: + return MakeReadAnyPointerProperty(field); + + case TypeTag.Data: + return MakeReadDataProperty(field); + + default: + return null; + } + } + + public StructDeclarationSyntax MakeReaderStruct(TypeDefinition def) + { + var readerDecl = StructDeclaration(_names.ReaderStruct.ToString()).AddModifiers(Public); + + var members = def.Tag == TypeTag.Group ? + MakeGroupReaderStructMembers() : + MakeReaderStructMembers(); + + readerDecl = readerDecl.AddMembers(members.ToArray()); + + if (def.UnionInfo != null) + { + readerDecl = readerDecl.AddMembers(MakeReaderUnionSelector(def)); + } + + foreach (var field in def.Fields) + { + var propDecl = MakeReaderFieldProperty(field); + + if (propDecl != null) + { + readerDecl = readerDecl.AddMembers(propDecl); + } + } + + return readerDecl; + } + } +} diff --git a/capnpc-csharp/Generator/SerializerStateWorder.cs b/capnpc-csharp/Generator/SerializerStateWorder.cs new file mode 100644 index 0000000..8f64689 --- /dev/null +++ b/capnpc-csharp/Generator/SerializerStateWorder.cs @@ -0,0 +1,12 @@ +using Capnp; +using System.Collections.Generic; +using System.Text; + +namespace CapnpC.Generator +{ + class SerializerStateWorder: SerializerState + { + public const string LinkName = nameof(SerializerStateWorder.Link); + public const string SetStructName = nameof(SerializerStateWorder.SetStruct); + } +} diff --git a/capnpc-csharp/Generator/SkeletonWorder.cs b/capnpc-csharp/Generator/SkeletonWorder.cs new file mode 100644 index 0000000..0d34191 --- /dev/null +++ b/capnpc-csharp/Generator/SkeletonWorder.cs @@ -0,0 +1,12 @@ +using System; + +namespace CapnpC.Generator +{ + class SkeletonWorder : Capnp.Rpc.Skeleton + { + public override ulong InterfaceId => throw new NotImplementedException(); + + public const string SetMethodTableName = nameof(SkeletonWorder.SetMethodTable); + public const string ImplName = nameof(SkeletonWorder.Impl); + } +} diff --git a/capnpc-csharp/Generator/SyntaxHelpers.cs b/capnpc-csharp/Generator/SyntaxHelpers.cs new file mode 100644 index 0000000..4d087ae --- /dev/null +++ b/capnpc-csharp/Generator/SyntaxHelpers.cs @@ -0,0 +1,128 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +namespace CapnpC.Generator +{ + static class SyntaxHelpers + { + public static string MakeCamel(string name) => $"{char.ToUpperInvariant(name[0])}{name.Substring(1)}"; + public static string MakeAllLower(string name) => $"@{name}"; + + public static readonly SyntaxToken Async = Token(SyntaxKind.AsyncKeyword); + public static readonly SyntaxToken Public = Token(SyntaxKind.PublicKeyword); + public static readonly SyntaxToken Private = Token(SyntaxKind.PrivateKeyword); + public static readonly SyntaxToken Readonly = Token(SyntaxKind.ReadOnlyKeyword); + public static readonly SyntaxToken Static = Token(SyntaxKind.StaticKeyword); + public static readonly SyntaxToken Override = Token(SyntaxKind.OverrideKeyword); + public static readonly SyntaxToken Partial = Token(SyntaxKind.PartialKeyword); + public static readonly SyntaxToken This = Token(SyntaxKind.ThisKeyword); + + public static TypeSyntax Type(Type type) + { + switch (0) + { + case 0 when type == typeof(bool): + return PredefinedType(Token(SyntaxKind.BoolKeyword)); + + case 0 when type == typeof(sbyte): + return PredefinedType(Token(SyntaxKind.SByteKeyword)); + + case 0 when type == typeof(byte): + return PredefinedType(Token(SyntaxKind.ByteKeyword)); + + case 0 when type == typeof(short): + return PredefinedType(Token(SyntaxKind.ShortKeyword)); + + case 0 when type == typeof(ushort): + return PredefinedType(Token(SyntaxKind.UShortKeyword)); + + case 0 when type == typeof(int): + return PredefinedType(Token(SyntaxKind.IntKeyword)); + + case 0 when type == typeof(uint): + return PredefinedType(Token(SyntaxKind.UIntKeyword)); + + case 0 when type == typeof(long): + return PredefinedType(Token(SyntaxKind.LongKeyword)); + + case 0 when type == typeof(ulong): + return PredefinedType(Token(SyntaxKind.ULongKeyword)); + + case 0 when type == typeof(float): + return PredefinedType(Token(SyntaxKind.FloatKeyword)); + + case 0 when type == typeof(double): + return PredefinedType(Token(SyntaxKind.DoubleKeyword)); + + case 0 when type == typeof(string): + return PredefinedType(Token(SyntaxKind.StringKeyword)); + + case 0 when type == typeof(object): + return PredefinedType(Token(SyntaxKind.ObjectKeyword)); + + case 0 when type.IsGenericType: + return GenericName(type.Name.Substring(0, type.Name.IndexOf('`'))) + .AddTypeArgumentListArguments(type.GetGenericArguments().Select(Type).ToArray()); + + default: + return ParseTypeName(type.Name); + } + } + + public static TypeSyntax Type() => Type(typeof(T)); + + public static ExpressionSyntax ValueOf(object value) + { + switch (value) + { + case bool x: + return LiteralExpression(x ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression); + + case sbyte x: + return CastExpression(Type(), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x))); + + case byte x: + return CastExpression(Type(), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x))); + + case short x: + return CastExpression(Type(), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x))); + + case ushort x: + return CastExpression(Type(), LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x))); + + case int x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case uint x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case long x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case ulong x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case float x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case double x: + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(x)); + + case string x: + return LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(x)); + + case null: + return LiteralExpression(SyntaxKind.NullLiteralExpression); + + default: + throw new NotImplementedException(); + } + } + } +} diff --git a/capnpc-csharp/Generator/WriterSnippetGen.cs b/capnpc-csharp/Generator/WriterSnippetGen.cs new file mode 100644 index 0000000..af62b09 --- /dev/null +++ b/capnpc-csharp/Generator/WriterSnippetGen.cs @@ -0,0 +1,406 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using CapnpC.Model; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static CapnpC.Generator.SyntaxHelpers; + +namespace CapnpC.Generator +{ + class WriterSnippetGen + { + readonly GenNames _names; + + public WriterSnippetGen(GenNames names) + { + _names = names; + } + + IEnumerable MakeWriterStructMembers(TypeDefinition structType) + { + yield return ConstructorDeclaration(_names.WriterStruct.Identifier) + .AddModifiers(Public) + .WithBody( + Block( + ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName(SerializerStateWorder.SetStructName))) + .AddArgumentListArguments( + Argument( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(structType.StructDataWordCount))), + Argument( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(structType.StructPointerCount))))))); + } + + IEnumerable MakeGroupWriterStructMembers() + { + yield return ConstructorDeclaration(_names.WriterStruct.Identifier) + .AddModifiers(Public) + .WithBody(Block()); + } + + PropertyDeclarationSyntax MakeWriterProperty( + TypeSyntax type, + string name, + ExpressionSyntax getter, + ExpressionSyntax setter, + bool cast, + bool cond) + { + if (cast) + { + getter = CastExpression(type, getter); + } + + if (cond) + { + getter = ConditionalExpression( + BinaryExpression( + SyntaxKind.EqualsExpression, + _names.UnionDiscriminatorProp.IdentifierName, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + _names.UnionDiscriminatorEnum.IdentifierName, + IdentifierName(name))), + getter, + LiteralExpression( + SyntaxKind.DefaultLiteralExpression, + Token(SyntaxKind.DefaultKeyword))); + } + + var accessors = new AccessorDeclarationSyntax[setter != null ? 2 : 1]; + + accessors[0] = AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) + .WithExpressionBody(ArrowExpressionClause(getter)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + + if (setter != null) + { + accessors[1] = AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) + .WithExpressionBody(ArrowExpressionClause(setter)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); + } + + return PropertyDeclaration(type, name) + .AddModifiers(Public) + .AddAccessorListAccessors(accessors); + } + + ExpressionSyntax MakePointerSyntax(TypeSyntax type, object index) => + InvocationExpression( + GenericName(nameof(Capnp.SerializerState.BuildPointer)) + .AddTypeArgumentListArguments(type)) + .AddArgumentListArguments( + Argument(ValueOf(index))); + + ExpressionSyntax MakeReadCapSyntax(TypeSyntax type, object index) => + InvocationExpression( + GenericName(nameof(Capnp.SerializerState.ReadCap)) + .AddTypeArgumentListArguments(type)) + .AddArgumentListArguments( + Argument(ValueOf(index))); + + ExpressionSyntax MakeTypedPointerSyntax(object index, TypeSyntax type) => + InvocationExpression( + GenericName(nameof(Capnp.SerializerState.BuildPointer)) + .AddTypeArgumentListArguments(type)) + .AddArgumentListArguments( + Argument(ValueOf(index))); + + ExpressionSyntax MakeLinkSyntax(object index) => + InvocationExpression( + IdentifierName(SerializerStateWorder.LinkName)) + .AddArgumentListArguments( + Argument(ValueOf(index)), + Argument(IdentifierName("value"))); + + ExpressionSyntax MakeLinkObjectSyntax(object index) => + InvocationExpression( + IdentifierName(nameof(Capnp.SerializerState.LinkObject))) + .AddArgumentListArguments( + Argument(ValueOf(index)), + Argument(IdentifierName("value"))); + + PropertyDeclarationSyntax MakePointerProperty(TypeSyntax type, string name, object index, bool cast, bool cond) + { + ExpressionSyntax getter = MakePointerSyntax(type, index); + ExpressionSyntax setter = MakeLinkSyntax(index); + + return MakeWriterProperty(type, name, getter, setter, cast, cond); + } + + PropertyDeclarationSyntax MakePointerAsStructProperty( + TypeSyntax type, string name, object index, + bool cast, bool cond) + { + ExpressionSyntax getter = MakeTypedPointerSyntax(index, type); + ExpressionSyntax setter = MakeLinkSyntax(index); + + return MakeWriterProperty(type, name, getter, setter, cast, cond); + } + + PropertyDeclarationSyntax MakeProperty( + TypeSyntax outerType, + TypeSyntax innerType, + string name, + string readName, + string writeName, + object indexOrBitOffset, + ExpressionSyntax secondArg, + bool cast, + bool cond, + bool pasd) + { + var getter = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName(readName))) + .AddArgumentListArguments( + Argument(ValueOf(indexOrBitOffset)), + Argument(secondArg)); + + ExpressionSyntax value = IdentifierName("value"); + + if (cast) + { + value = CastExpression(innerType, value); + } + + var setter = InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName(writeName))) + .AddArgumentListArguments( + Argument(ValueOf(indexOrBitOffset)), + Argument(value), + Argument(secondArg)); + + if (pasd) + { + setter.AddArgumentListArguments(Argument(secondArg)); + } + + return MakeWriterProperty(outerType, name, getter, setter, cast, cond); + } + + PropertyDeclarationSyntax MakePrimitiveProperty(Field field, string readName) + { + return MakeProperty(Type(), null, _names.GetCodeIdentifier(field).ToString(), + readName, + nameof(Capnp.SerializerExtensions.WriteData), + field.BitOffset.Value, + ValueOf(field.DefaultValue.ScalarValue), + false, + field.DiscValue.HasValue, + true); + } + + PropertyDeclarationSyntax MakeEnumProperty(Field field, string readName) + { + return MakeProperty(_names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.NotRelevant), Type(), + _names.GetCodeIdentifier(field).ToString(), + readName, + nameof(Capnp.SerializerExtensions.WriteData), + field.BitOffset.Value, + ValueOf(field.DefaultValue.ScalarValue), + true, + field.DiscValue.HasValue, + true); + } + + PropertyDeclarationSyntax MakeTextProperty(Field field) + { + return MakeProperty(Type(), null, + _names.GetCodeIdentifier(field).ToString(), + nameof(Capnp.SerializerState.ReadText), + nameof(Capnp.SerializerState.WriteText), + (int)field.Offset, + ValueOf(field.DefaultValue.ScalarValue), + false, + field.DiscValue.HasValue, + false); + } + + PropertyDeclarationSyntax MakeStructProperty(Field field) + { + var qtype = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Writer); + + return MakePointerAsStructProperty(qtype, _names.GetCodeIdentifier(field).ToString(), + (int)field.Offset, false, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeGroupProperty(Field field) + { + var type = QualifiedName( + _names.MakeTypeName(field.Type.Definition).IdentifierName, + _names.WriterStruct.IdentifierName); + + var getter = InvocationExpression( + GenericName(nameof(Capnp.SerializerState.Rewrap)) + .AddTypeArgumentListArguments(type)); + + return MakeWriterProperty(type, _names.GetCodeIdentifier(field).ToString(), getter, null, false, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeListProperty(Field field) + { + var qtype = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Writer); + + return MakePointerProperty(qtype, _names.GetCodeIdentifier(field).ToString(), + (int)field.Offset, false, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakePointerProperty(Field field) + { + var type = IdentifierName(nameof(Capnp.DynamicSerializerState)); + + return MakePointerProperty(type, _names.GetCodeIdentifier(field).ToString(), (int)field.Offset, false, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeCapProperty(Field field) + { + var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.Writer); + int index = (int)field.Offset; + string name = _names.GetCodeIdentifier(field).ToString(); + ExpressionSyntax getter = MakeReadCapSyntax(type, index); + ExpressionSyntax setter = MakeLinkObjectSyntax(index); + + return MakeWriterProperty(type, name, getter, setter, false, field.DiscValue.HasValue); + } + + PropertyDeclarationSyntax MakeWriterUnionSelector(TypeDefinition def) + { + return MakeProperty( + _names.UnionDiscriminatorEnum.IdentifierName, + Type(), + _names.UnionDiscriminatorProp.ToString(), + nameof(Capnp.SerializerExtensions.ReadDataUShort), + nameof(Capnp.SerializerExtensions.WriteData), + def.UnionInfo.TagOffset, + ValueOf(default(ushort)), + true, false, true); + } + + PropertyDeclarationSyntax MakeWriterFieldProperty(Field field) + { + switch (field.Type.Tag) + { + case TypeTag.Bool: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataBool)); + + case TypeTag.S8: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataSByte)); + + case TypeTag.U8: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataByte)); + + case TypeTag.S16: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataShort)); + + case TypeTag.U16: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataUShort)); + + case TypeTag.S32: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataInt)); + + case TypeTag.U32: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataUInt)); + + case TypeTag.S64: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataLong)); + + case TypeTag.U64: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataULong)); + + case TypeTag.F32: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataFloat)); + + case TypeTag.F64: + return MakePrimitiveProperty(field, + nameof(Capnp.SerializerExtensions.ReadDataDouble)); + + case TypeTag.Enum: + return MakeEnumProperty(field, nameof(Capnp.SerializerExtensions.ReadDataUShort)); + + case TypeTag.Text: + return MakeTextProperty(field); + + case TypeTag.Struct: + return MakeStructProperty(field); + + case TypeTag.Group: + return MakeGroupProperty(field); + + case TypeTag.List: + case TypeTag.Data: + return MakeListProperty(field); + + case TypeTag.AnyPointer: + case TypeTag.StructPointer: + case TypeTag.ListPointer: + return MakePointerProperty(field); + + case TypeTag.CapabilityPointer: + case TypeTag.Interface: + return MakeCapProperty(field); + + default: + return null; + } + } + + public ClassDeclarationSyntax MakeWriterStruct(TypeDefinition def) + { + var WriterDecl = ClassDeclaration(_names.WriterStruct.ToString()) + .AddModifiers(Public) + .AddBaseListTypes( + SimpleBaseType(IdentifierName(nameof(Capnp.SerializerState)))); + + var members = def.Tag == TypeTag.Group ? + MakeGroupWriterStructMembers() : + MakeWriterStructMembers(def); + + WriterDecl = WriterDecl.AddMembers(members.ToArray()); + + if (def.UnionInfo != null) + { + WriterDecl = WriterDecl.AddMembers(MakeWriterUnionSelector(def)); + } + + foreach (var field in def.Fields) + { + var propDecl = MakeWriterFieldProperty(field); + + if (propDecl != null) + { + WriterDecl = WriterDecl.AddMembers(propDecl); + } + } + + return WriterDecl; + } + } +} diff --git a/capnpc-csharp/Model/AbstractType.cs b/capnpc-csharp/Model/AbstractType.cs new file mode 100644 index 0000000..2c1451a --- /dev/null +++ b/capnpc-csharp/Model/AbstractType.cs @@ -0,0 +1,45 @@ +using System.Collections.Generic; + +namespace CapnpC.Model +{ + abstract class AbstractType + { + public TypeTag Tag { get; set; } + protected List Fields { get; } = new List(); + + public uint? FixedBitWidth + { + get + { + switch (Tag) + { + case TypeTag.Bool: + return 1; + + case TypeTag.U8: + case TypeTag.S8: + return 8; + + case TypeTag.U16: + case TypeTag.S16: + case TypeTag.Enum: + case TypeTag.AnyEnum: + return 16; + + case TypeTag.U32: + case TypeTag.S32: + case TypeTag.F32: + return 32; + + case TypeTag.U64: + case TypeTag.S64: + case TypeTag.F64: + return 64; + + default: + return null; + } + } + } + } +} diff --git a/capnpc-csharp/Model/Enumerant.cs b/capnpc-csharp/Model/Enumerant.cs new file mode 100644 index 0000000..99d53fc --- /dev/null +++ b/capnpc-csharp/Model/Enumerant.cs @@ -0,0 +1,10 @@ +namespace CapnpC.Model +{ + class Enumerant + { + public TypeDefinition TypeDefinition { get; set; } + public string Literal { get; set; } + public ushort? Ordinal { get; set; } + public int CodeOrder { get; set; } + } +} diff --git a/capnpc-csharp/Model/Field.cs b/capnpc-csharp/Model/Field.cs new file mode 100644 index 0000000..eee384b --- /dev/null +++ b/capnpc-csharp/Model/Field.cs @@ -0,0 +1,52 @@ +namespace CapnpC.Model +{ + class Field + { + public TypeDefinition DeclaringType { get; set; } + public Field Parent { get; set; } + public string Name { get; set; } + public Type Type { get; set; } + public Value DefaultValue { get; set; } + public bool DefaultValueIsExplicit { get; set; } + public ushort? DiscValue { get; set; } + public uint Offset { get; set; } + public int CodeOrder { get; set; } + + public ulong? BitOffset => (ulong)Offset * Type?.FixedBitWidth; + + public Field Clone() + { + var field = new Field() + { + DeclaringType = DeclaringType, + Parent = Parent, + Name = Name, + Type = Type, + DefaultValue = DefaultValue, + DefaultValueIsExplicit = DefaultValueIsExplicit, + DiscValue = DiscValue, + Offset = Offset, + CodeOrder = CodeOrder, + }; + field.InheritFreeGenericParameters(); + return field; + } + + public void InheritFreeGenericParameters() + { + Type.InheritFreeParameters(DeclaringType); + } + + public override bool Equals(object obj) + { + return obj is Field other && + DeclaringType == other.DeclaringType && + Name == other.Name; + } + + public override int GetHashCode() + { + return (DeclaringType, Name).GetHashCode(); + } + } +} diff --git a/capnpc-csharp/Model/GenFile.cs b/capnpc-csharp/Model/GenFile.cs new file mode 100644 index 0000000..045c975 --- /dev/null +++ b/capnpc-csharp/Model/GenFile.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace CapnpC.Model +{ + class GenFile: IHasNestedDefinitions + { + public string Name { get; set; } + public string[] Namespace { get; set; } + + public List NestedTypes { get; } = new List(); + public List Constants { get; } = new List(); + } +} diff --git a/capnpc-csharp/Model/GenericParameter.cs b/capnpc-csharp/Model/GenericParameter.cs new file mode 100644 index 0000000..8526b0d --- /dev/null +++ b/capnpc-csharp/Model/GenericParameter.cs @@ -0,0 +1,26 @@ +namespace CapnpC.Model +{ + class GenericParameter + { + public IHasGenericParameters DeclaringEntity { get; set; } + public int Index { get; set; } + public string Name => DeclaringEntity.GenericParameters[Index]; + + public override bool Equals(object obj) + { + // Instead of equality by Name, we could instead take (DeclaringEntity, Index), but there is a caveat: + // Since methods can also own generic parameters, we have different classes of declaring entities involved. + // Both the method will define generic parameters, and the Cap'n'p-generated params/result structs. + // Therefore we end in two GenericParameter instances, one with the Method as declaring entity, the + // other one with the params/result type definition as declaring entity. They are semantically the same, + // and the easy way to match them is by Name. Equality by Name is the only working choice, even though + // it feels a little less reboust than by matching declaring entity + parameter position. + return obj is GenericParameter other && Name == other.Name; + } + + public override int GetHashCode() + { + return Name.GetHashCode(); + } + } +} diff --git a/capnpc-csharp/Model/HasGenericParameters.cs b/capnpc-csharp/Model/HasGenericParameters.cs new file mode 100644 index 0000000..6636ff4 --- /dev/null +++ b/capnpc-csharp/Model/HasGenericParameters.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; +namespace CapnpC.Model +{ + static class HasGenericParameters + { + public static IEnumerable GetLocalTypeParameters(this IHasGenericParameters me) + { + for (int i = 0; i < me.GenericParameters.Count; i++) + { + yield return new GenericParameter() + { + DeclaringEntity = me, + Index = i + }; + } + } + } +} diff --git a/capnpc-csharp/Model/IHasGenericParameters.cs b/capnpc-csharp/Model/IHasGenericParameters.cs new file mode 100644 index 0000000..5b9ce58 --- /dev/null +++ b/capnpc-csharp/Model/IHasGenericParameters.cs @@ -0,0 +1,9 @@ +using System.Collections.Generic; + +namespace CapnpC.Model +{ + interface IHasGenericParameters + { + List GenericParameters { get; } + } +} diff --git a/capnpc-csharp/Model/IHasNestedDefinitions.cs b/capnpc-csharp/Model/IHasNestedDefinitions.cs new file mode 100644 index 0000000..e9e030b --- /dev/null +++ b/capnpc-csharp/Model/IHasNestedDefinitions.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; + +namespace CapnpC.Model +{ + interface IHasNestedDefinitions + { + List NestedTypes { get; } + List Constants { get; } + } +} diff --git a/capnpc-csharp/Model/InvalidSchemaException.cs b/capnpc-csharp/Model/InvalidSchemaException.cs new file mode 100644 index 0000000..4732ca8 --- /dev/null +++ b/capnpc-csharp/Model/InvalidSchemaException.cs @@ -0,0 +1,11 @@ +using System; + +namespace CapnpC.Model +{ + class InvalidSchemaException : Exception + { + public InvalidSchemaException(string message) : base(message) + { + } + } +} diff --git a/capnpc-csharp/Model/Method.cs b/capnpc-csharp/Model/Method.cs new file mode 100644 index 0000000..e263f89 --- /dev/null +++ b/capnpc-csharp/Model/Method.cs @@ -0,0 +1,16 @@ +using System.Collections.Generic; + +namespace CapnpC.Model +{ + class Method: IHasGenericParameters + { + public TypeDefinition DeclaringInterface { get; set; } + public int Id { get; set; } + public string Name { get; set; } + public List Params { get; } = new List(); + public List Results { get; } = new List(); + public Type ParamsStruct { get; set; } + public Type ResultStruct { get; set; } + public List GenericParameters { get; } = new List(); + } +} diff --git a/capnpc-csharp/Model/SchemaModel.cs b/capnpc-csharp/Model/SchemaModel.cs new file mode 100644 index 0000000..0e6b5be --- /dev/null +++ b/capnpc-csharp/Model/SchemaModel.cs @@ -0,0 +1,654 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; + +namespace CapnpC.Model +{ + class SchemaModel + { + readonly Schema.CodeGeneratorRequest.Reader _request; + readonly List _files = new List(); + readonly Stack _typeNest = new Stack(); + readonly TypeDefinitionManager _typeDefMgr = new TypeDefinitionManager(); + Method _currentMethod; + + Dictionary _id2node; + + public SchemaModel(Schema.CodeGeneratorRequest.Reader request) + { + _request = request; + } + + public IReadOnlyList FilesToGenerate => _files; + + Schema.Node.Reader IdToNode(ulong id) + { + try + { + return _id2node[id]; + } + catch (KeyNotFoundException) + { + throw new InvalidSchemaException($"Node with ID {id} is missing"); + } + } + + void Build() + { + if (_request.Nodes == null || _request.Nodes.Count == 0) + { + throw new InvalidSchemaException("No nodes, nothing to generate"); + } + + try + { + _id2node = _request.Nodes.ToDictionary(n => n.Id); + } + catch (ArgumentException) + { + throw new InvalidSchemaException("Nodes with duplicate IDs detected"); + } + + foreach (var reqFile in _request.RequestedFiles) + { + var file = new GenFile() + { + Name = reqFile.Filename + }; + + _files.Add(file); + _typeNest.Push(file); + + var fileNode = IdToNode(reqFile.Id); + + if (!fileNode.IsFile) + throw new InvalidSchemaException("Expected a file node"); + + ProcessFile(fileNode); + + _typeNest.Pop(); + } + } + + void ProcessFile(Schema.Node.Reader fileReader) + { + foreach (var annotation in fileReader.Annotations) + { + if (annotation.Id == 0xb9c6f99ebf805f2c) // Cxx namespace + { + ((GenFile)_typeNest.Peek()).Namespace = annotation.Value.Text.Split("::"); + } + } + + foreach (var nestedNode in fileReader.NestedNodes) + { + var node = IdToNode(nestedNode.Id); + + ProcessNode(node, nestedNode.Name); + } + } + + TypeDefinition GetOrCreateTypeDef(ulong id, TypeTag tag) => _typeDefMgr.GetOrCreate(id, tag); + TypeDefinition GetGroupTypeDef(ulong id, string name) + { + var nodeReader = _id2node[id]; + + if (!nodeReader.IsStruct) + throw new InvalidSchemaException($"Expected node with id {id} to be a struct definition"); + + return ProcessStruct(nodeReader, name); + } + void ProcessBrand(Schema.Brand.Reader brandReader, Type type) + { + foreach (var scopeReader in brandReader.Scopes) + { + var whatToBind = GetOrCreateTypeDef(scopeReader.ScopeId, TypeTag.Unknown); + int index = 0; + + switch (0) + { + case 0 when scopeReader.IsBind: + foreach (var bindingReader in scopeReader.Bind) + { + var typeParameter = new GenericParameter() + { + DeclaringEntity = whatToBind, + Index = index++ + }; + + switch (0) + { + case 0 when bindingReader.IsType: + type.BindGenericParameter(typeParameter, ProcessType(bindingReader.Type)); + break; + + case 0 when bindingReader.IsUnbound: + type.BindGenericParameter(typeParameter, Types.FromParameter(typeParameter)); + break; + } + } + break; + + case 0 when scopeReader.IsInherit: + for (index = 0; index < type.DeclaringType.Definition.GenericParameters.Count; index++) + { + var typeParameter = new GenericParameter() + { + DeclaringEntity = whatToBind, + Index = index + }; + + type.BindGenericParameter(typeParameter, Types.FromParameter(typeParameter)); + } + break; + } + } + } + Type ProcessType(Schema.Type.Reader typeReader) + { + Type result; + + switch (0) + { + case 0 when typeReader.IsAnyPointer: + switch (0) + { + case 0 when typeReader.AnyPointer_IsParameter: + return Types.FromParameter( + new GenericParameter() + { + DeclaringEntity = GetOrCreateTypeDef(typeReader.AnyPointer_Parameter_ScopeId, TypeTag.Unknown), + Index = typeReader.AnyPointer_Parameter_ParameterIndex + }); + + case 0 when typeReader.AnyPointer_IsImplicitMethodParameter: + return Types.FromParameter( + new GenericParameter() + { + DeclaringEntity = _currentMethod ?? throw new InvalidOperationException("current method not set"), + Index = typeReader.AnyPointer_ImplicitMethodParameter_ParameterIndex + }); + + case 0 when typeReader.AnyPointer_IsUnconstrained: + + switch (0) + { + case 0 when typeReader.AnyPointer_Unconstrained_IsAnyKind: + return Types.AnyPointer; + + case 0 when typeReader.AnyPointer_Unconstrained_IsCapability: + return Types.CapabilityPointer; + + case 0 when typeReader.AnyPointer_Unconstrained_IsList: + return Types.ListPointer; + + case 0 when typeReader.AnyPointer_Unconstrained_IsStruct: + return Types.StructPointer; + + default: + throw new NotImplementedException(); + } + + default: + throw new NotImplementedException(); + } + + case 0 when typeReader.IsBool: + return Types.Bool; + + case 0 when typeReader.IsData: + return Types.Data; + + case 0 when typeReader.IsFloat64: + return Types.F64; + + case 0 when typeReader.IsEnum: + return Types.FromDefinition(GetOrCreateTypeDef(typeReader.Enum_TypeId, TypeTag.Enum)); + + case 0 when typeReader.IsFloat32: + return Types.F32; + + case 0 when typeReader.IsInt16: + return Types.S16; + + case 0 when typeReader.IsInt32: + return Types.S32; + + case 0 when typeReader.IsInt64: + return Types.S64; + + case 0 when typeReader.IsInt8: + return Types.S8; + + case 0 when typeReader.IsInterface: + result = Types.FromDefinition(GetOrCreateTypeDef(typeReader.Interface_TypeId, TypeTag.Interface)); + ProcessBrand(typeReader.Interface_Brand, result); + return result; + + case 0 when typeReader.IsList: + return Types.List(ProcessType(typeReader.List_ElementType)); + + case 0 when typeReader.IsStruct: + result = Types.FromDefinition(GetOrCreateTypeDef(typeReader.Struct_TypeId, TypeTag.Struct)); + ProcessBrand(typeReader.Struct_Brand, result); + return result; + + case 0 when typeReader.IsText: + return Types.Text; + + case 0 when typeReader.IsUInt16: + return Types.U16; + + case 0 when typeReader.IsUInt32: + return Types.U32; + + case 0 when typeReader.IsUInt64: + return Types.U64; + + case 0 when typeReader.IsUInt8: + return Types.U8; + + case 0 when typeReader.IsVoid: + return Types.Void; + + default: + throw new NotImplementedException(); + } + } + + Value ProcessValue(Schema.Value.Reader valueReader) + { + var value = new Value(); + + switch (0) + { + case 0 when valueReader.IsAnyPointer: + value.ScalarValue = valueReader.AnyPointer; + value.Type = Types.AnyPointer; + break; + + case 0 when valueReader.IsBool: + value.ScalarValue = valueReader.Bool; + value.Type = Types.Bool; + break; + + case 0 when valueReader.IsData: + value.Items.AddRange(valueReader.Data.CastByte().Select(Value.Scalar)); + value.Type = Types.Data; + break; + + case 0 when valueReader.IsEnum: + value.ScalarValue = valueReader.Enum; + value.Type = Types.AnyEnum; + break; + + case 0 when valueReader.IsFloat32: + value.ScalarValue = valueReader.Float32; + value.Type = Types.F32; + break; + + case 0 when valueReader.IsFloat64: + value.ScalarValue = valueReader.Float64; + value.Type = Types.F64; + break; + + case 0 when valueReader.IsInt16: + value.ScalarValue = valueReader.Int16; + value.Type = Types.S16; + break; + + case 0 when valueReader.IsInt32: + value.ScalarValue = valueReader.Int32; + value.Type = Types.S32; + break; + + case 0 when valueReader.IsInt64: + value.ScalarValue = valueReader.Int64; + value.Type = Types.S64; + break; + + case 0 when valueReader.IsInt8: + value.ScalarValue = valueReader.Int8; + value.Type = Types.S8; + break; + + case 0 when valueReader.IsInterface: + value.ScalarValue = null; + value.Type = Types.CapabilityPointer; + break; + + case 0 when valueReader.IsList: + value.RawValue = valueReader.List; + value.Type = Types.ListPointer; + break; + + case 0 when valueReader.IsStruct: + value.RawValue = valueReader.Struct; + value.Type = Types.StructPointer; + break; + + case 0 when valueReader.IsText: + value.ScalarValue = valueReader.Text; + value.Type = Types.Text; + break; + + case 0 when valueReader.IsUInt16: + value.ScalarValue = valueReader.UInt16; + value.Type = Types.U16; + break; + + case 0 when valueReader.IsUInt32: + value.ScalarValue = valueReader.UInt32; + value.Type = Types.U32; + break; + + case 0 when valueReader.IsUInt64: + value.ScalarValue = valueReader.UInt64; + value.Type = Types.U64; + break; + + case 0 when valueReader.IsUInt8: + value.ScalarValue = valueReader.UInt8; + value.Type = Types.U8; + break; + + case 0 when valueReader.IsVoid: + value.Type = Types.Void; + break; + + default: + throw new NotImplementedException(); + } + + return value; + } + + void ProcessFields(Schema.Node.Reader reader, TypeDefinition declaringType, List fields) + { + if (reader.Fields == null) + { + return; + } + + foreach (var fieldReader in reader.Fields) + { + var field = new Field() + { + DeclaringType = declaringType, + Name = fieldReader.Name, + CodeOrder = fieldReader.CodeOrder + }; + + if (fieldReader.DiscriminantValue != Schema.Field.Reader.NoDiscriminant) + { + field.DiscValue = fieldReader.DiscriminantValue; + } + + switch (0) + { + case 0 when fieldReader.IsGroup: + field.Type = Types.FromDefinition(GetGroupTypeDef( + fieldReader.Group_TypeId, fieldReader.Name)); + break; + + case 0 when fieldReader.IsSlot: + field.DefaultValue = ProcessValue(fieldReader.Slot_DefaultValue); + field.DefaultValueIsExplicit = fieldReader.Slot_HadExplicitDefault; + field.Offset = fieldReader.Slot_Offset; + field.Type = ProcessType(fieldReader.Slot_Type); + field.DefaultValue.Type = field.Type; + break; + + default: + throw new NotImplementedException(); + } + + field.InheritFreeGenericParameters(); + + fields.Add(field); + } + } + + void ProcessInterfaceOrStructTail(TypeDefinition def, Schema.Node.Reader reader) + { + def.IsGeneric = reader.IsGeneric; + + if (def.IsGeneric) + { + foreach (var paramReader in reader.Parameters) + { + def.GenericParameters.Add(paramReader.Name); + } + } + + _typeNest.Push(def); + + if (reader.NestedNodes != null) + { + foreach (var nestedReader in reader.NestedNodes) + { + var node = IdToNode(nestedReader.Id); + ProcessNode(node, nestedReader.Name); + } + } + + ProcessFields(reader, def, def.Fields); + + if (reader.IsInterface) + { + foreach (var methodReader in reader.Interface_Methods) + { + var method = new Method() + { + DeclaringInterface = def, + Id = def.Methods.Count, + Name = methodReader.Name + }; + foreach (var implicitParameterReader in methodReader.ImplicitParameters) + { + method.GenericParameters.Add(implicitParameterReader.Name); + } + _currentMethod = method; + + def.Methods.Add(method); + + var paramNode = IdToNode(methodReader.ParamStructType); + var paramType = ProcessParameterList(paramNode, methodReader.ParamBrand, method.Params); + if (paramType != null) + { + paramType.SpecialName = SpecialName.MethodParamsStruct; + paramType.UsingMethod = method; + method.ParamsStruct = Types.FromDefinition(paramType); + } + else + { + method.ParamsStruct = method.Params[0].Type; + } + method.ParamsStruct.InheritFreeParameters(def); + method.ParamsStruct.InheritFreeParameters(method); + + var resultNode = IdToNode(methodReader.ResultStructType); + var resultType = ProcessParameterList(resultNode, methodReader.ResultBrand, method.Results); + if (resultType != null) + { + resultType.SpecialName = SpecialName.MethodResultStruct; + resultType.UsingMethod = method; + method.ResultStruct = Types.FromDefinition(resultType); + } + else + { + method.ResultStruct = method.Results[0].Type; + } + method.ResultStruct.InheritFreeParameters(def); + method.ResultStruct.InheritFreeParameters(method); + } + + _currentMethod = null; + } + + _typeNest.Pop(); + } + + TypeDefinition ProcessStruct(Schema.Node.Reader structReader, string name) + { + var def = GetOrCreateTypeDef( + structReader.Id, + structReader.Struct_IsGroup ? TypeTag.Group : TypeTag.Struct); + + def.DeclaringElement = _typeNest.Peek(); + if (structReader.Struct_IsGroup) + ((TypeDefinition)def.DeclaringElement).NestedGroups.Add(def); + else + def.DeclaringElement.NestedTypes.Add(def); + def.Name = name; + def.StructDataWordCount = structReader.Struct_DataWordCount; + def.StructPointerCount = structReader.Struct_PointerCount; + + if (structReader.Struct_DiscriminantCount > 0) + { + def.UnionInfo = new TypeDefinition.DiscriminationInfo( + structReader.Struct_DiscriminantCount, + 16u * structReader.Struct_DiscriminantOffset); + } + + ProcessInterfaceOrStructTail(def, structReader); + + return def; + } + + TypeDefinition ProcessParameterList(Schema.Node.Reader reader, Schema.Brand.Reader brandReader, List list) + { +//# If a named parameter list was specified in the method +//# declaration (rather than a single struct parameter type) then a corresponding struct type is +//# auto-generated. Such an auto-generated type will not be listed in the interface's +//# `nestedNodes` and its `scopeId` will be zero -- it is completely detached from the namespace. +//# (Awkwardly, it does of course inherit generic parameters from the method's scope, which makes +//# this a situation where you can't just climb the scope chain to find where a particular +//# generic parameter was introduced. Making the `scopeId` zero was a mistake.) + + if (!reader.IsStruct) + { + throw new InvalidSchemaException("Expected a struct"); + } + + if (reader.ScopeId == 0) + { + // Auto-generated => Named parameter list + ProcessFields(reader, null, list); + return ProcessStruct(reader, null); + } + else + { + // Single, anonymous, struct-typed parameter + var def = GetOrCreateTypeDef(reader.Id, TypeTag.Struct); + var type = Types.FromDefinition(def); + ProcessBrand(brandReader, type); + var anon = new Field() { Type = type }; + list.Add(anon); + return null; + } + } + + TypeDefinition ProcessInterface(Schema.Node.Reader ifaceReader, string name) + { + var def = GetOrCreateTypeDef( + ifaceReader.Id, + TypeTag.Interface); + + def.DeclaringElement = _typeNest.Peek(); + def.DeclaringElement.NestedTypes.Add(def); + def.Name = name; + + foreach (var superClassReader in ifaceReader.Interface_Superclasses) + { + var superClass = GetOrCreateTypeDef( + superClassReader.Id, + TypeTag.Interface); + + def.Superclasses.Add(Types.FromDefinition(superClass)); + } + + ProcessInterfaceOrStructTail(def, ifaceReader); + + return def; + } + + void ProcessEnum(Schema.Node.Reader enumReader, string name) + { + var def = GetOrCreateTypeDef(enumReader.Id, TypeTag.Enum); + + def.DeclaringElement = _typeNest.Peek(); + def.DeclaringElement.NestedTypes.Add(def); + def.Name = name; + + _typeNest.Push(def); + + foreach (var fieldReader in enumReader.Enumerants) + { + var field = new Enumerant() + { + TypeDefinition = def, + Literal = fieldReader.Name, + CodeOrder = fieldReader.CodeOrder + }; + + if (fieldReader.Ordinal_IsExplicit) + { + field.Ordinal = fieldReader.Ordinal_Explicit; + } + + def.Enumerants.Add(field); + } + + _typeNest.Pop(); + } + + void ProcessConst(Schema.Node.Reader constReader, string name) + { + var value = ProcessValue(constReader.Const_Value); + value.Type = ProcessType(constReader.Const_Type); + + _typeNest.Peek().Constants.Add(value); + } + + void ProcessNode(Schema.Node.Reader node, string name) + { + switch (0) + { + case 0 when node.IsAnnotation: + break; + + case 0 when node.IsConst: + ProcessConst(node, name); + break; + + case 0 when node.IsEnum: + ProcessEnum(node, name); + break; + + case 0 when node.IsFile: + throw new InvalidSchemaException("Did not expect file nodes to appear as nested nodes"); + + case 0 when node.IsInterface: + ProcessInterface(node, name); + break; + + case 0 when node.IsStruct: + ProcessStruct(node, name); + break; + + default: + throw new InvalidSchemaException($"Don't know how to process node {node.DisplayName}"); + } + } + + public static SchemaModel Create(Schema.CodeGeneratorRequest.Reader request) + { + var model = new SchemaModel(request); + model.Build(); + return model; + } + } +} diff --git a/capnpc-csharp/Model/SpecialName.cs b/capnpc-csharp/Model/SpecialName.cs new file mode 100644 index 0000000..89f546f --- /dev/null +++ b/capnpc-csharp/Model/SpecialName.cs @@ -0,0 +1,9 @@ +namespace CapnpC.Model +{ + enum SpecialName + { + NothingSpecial, + MethodParamsStruct, + MethodResultStruct + } +} diff --git a/capnpc-csharp/Model/Type.cs b/capnpc-csharp/Model/Type.cs new file mode 100644 index 0000000..3512b2b --- /dev/null +++ b/capnpc-csharp/Model/Type.cs @@ -0,0 +1,196 @@ +using Capnp; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; + +namespace CapnpC.Model +{ + class Type: AbstractType + { + public TypeDefinition Definition { get; set; } + public GenericParameter Parameter { get; set; } + public Type ElementType { get; set; } + + readonly Dictionary _parameterBindings = + new Dictionary(); + public Type(TypeTag tag) + { + Tag = tag; + } + + public bool IsValueType + { + get + { + switch (Tag) + { + case TypeTag.AnyPointer: + case TypeTag.CapabilityPointer: + case TypeTag.Data: + case TypeTag.Group: + case TypeTag.Interface: + case TypeTag.List when ElementType.Tag != TypeTag.Void: + case TypeTag.ListPointer: + case TypeTag.Struct: + case TypeTag.StructPointer: + case TypeTag.Text: + case TypeTag.Void: + return false; + + default: + return true; + } + } + } + + public void InheritFreeParameters(IHasGenericParameters declaringType) + { + while (declaringType != null) + { + foreach (var p in declaringType.GetLocalTypeParameters()) + { + if (!_parameterBindings.ContainsKey(p)) + { + _parameterBindings[p] = Types.FromParameter(p); + } + } + + declaringType = (declaringType as TypeDefinition)?.DeclaringElement as IHasGenericParameters; + } + + ElementType?.InheritFreeParameters(declaringType); + } + + Type SubstituteGenerics(Type type) + { + if (type == null) + { + return null; + } + + if (type.Parameter != null) + { + if (_parameterBindings.TryGetValue(type.Parameter, out var boundType)) + { + return boundType; + } + else + { + return Types.AnyPointer; + } + } + + var stype = new Type(type.Tag) + { + Definition = type.Definition, + ElementType = SubstituteGenerics(type.ElementType) + }; + + foreach (var kvp in type._parameterBindings) + { + var p = kvp.Value.Parameter; + + if (p != null && _parameterBindings.TryGetValue(p, out var boundType)) + { + stype._parameterBindings[kvp.Key] = boundType; + } + else + { + stype._parameterBindings[kvp.Key] = kvp.Value; + } + } + + return stype; + } + + Field SubstituteGenerics(Field field) + { + var result = field.Clone(); + result.Type = SubstituteGenerics(result.Type); + return result; + } + + public new IReadOnlyList Fields => Definition.Fields.LazyListSelect(SubstituteGenerics); + + public Type DeclaringType + { + get + { + var parentDef = Definition?.DeclaringElement as TypeDefinition; + // FIXME: Will become more sophisticated as soon as generics are implemented + return parentDef != null ? Types.FromDefinition(parentDef) : null; + } + } + + public (int, Type) GetRank() + { + var cur = this; + int rank = 0; + + while (cur.Tag == TypeTag.List) + { + cur = cur.ElementType; + ++rank; + } + + return (rank, cur); + } + + public IEnumerable AllImplementedClasses + { + get + { + var stk = new Stack(); + stk.Push(this); + var set = new HashSet(); + while (stk.Count > 0) + { + var def = stk.Pop(); + + if (def == null) + { + break; + } + + if (set.Add(def)) + { + foreach (var super in def.Definition.Superclasses) + { + stk.Push(super); + } + } + } + return set; + } + } + + public Type ResolveGenericParameter(GenericParameter genericParameter) + { + if (_parameterBindings.TryGetValue(genericParameter, out var type)) + { + return type; + } + else + { + return Types.AnyPointer; + } + } + + public void BindGenericParameter(GenericParameter genericParameter, Type boundType) + { + _parameterBindings.Add(genericParameter, boundType); + } + + public override bool Equals(object obj) + { + return obj is Type other && Definition == other.Definition; + } + + public override int GetHashCode() + { + return Definition?.GetHashCode() ?? 0; + } + } +} diff --git a/capnpc-csharp/Model/TypeCategory.cs b/capnpc-csharp/Model/TypeCategory.cs new file mode 100644 index 0000000..3411ac1 --- /dev/null +++ b/capnpc-csharp/Model/TypeCategory.cs @@ -0,0 +1,8 @@ +namespace CapnpC.Model +{ + enum TypeCategory + { + Value, + Pointer + } +} diff --git a/capnpc-csharp/Model/TypeDefinition.cs b/capnpc-csharp/Model/TypeDefinition.cs new file mode 100644 index 0000000..ce00e2c --- /dev/null +++ b/capnpc-csharp/Model/TypeDefinition.cs @@ -0,0 +1,67 @@ +using System.Collections.Generic; +using System.Linq; +namespace CapnpC.Model +{ + class TypeDefinition : AbstractType, IHasNestedDefinitions, IHasGenericParameters + { + public class DiscriminationInfo + { + public DiscriminationInfo(ushort numOptions, uint tagOffset) + { + NumOptions = numOptions; + TagOffset = tagOffset; + } + + public ushort NumOptions { get; } + public uint TagOffset { get; } + } + + public TypeDefinition(TypeTag tag, ulong id) + { + Tag = tag; + Id = id; + } + + public ulong Id { get; } + public IHasNestedDefinitions DeclaringElement { get; set; } + public Method UsingMethod { get; set; } + public string Name { get; set; } + public SpecialName SpecialName { get; set; } + public DiscriminationInfo UnionInfo { get; set; } + public new List Fields => base.Fields; + public List Enumerants { get; } = new List(); + public List NestedTypes { get; } = new List(); + public List NestedGroups { get; } = new List(); + public List Constants { get; } = new List(); + public List Methods { get; } = new List(); + public List Superclasses { get; } = new List(); + public List GenericParameters { get; } = new List(); + public bool IsGeneric { get; set; } + public ushort StructDataWordCount { get; set; } + public ushort StructPointerCount { get; set; } + + public IEnumerable DefinitionHierarchy + { + get + { + IHasNestedDefinitions cur = this; + + while (cur is TypeDefinition def) + { + yield return def; + cur = def.DeclaringElement; + } + } + } + + public IEnumerable AllTypeParameters + { + get + { + return from def in DefinitionHierarchy + from p in def.GetLocalTypeParameters() + select p; + } + } + } +} diff --git a/capnpc-csharp/Model/TypeDefinitionManager.cs b/capnpc-csharp/Model/TypeDefinitionManager.cs new file mode 100644 index 0000000..7c1562e --- /dev/null +++ b/capnpc-csharp/Model/TypeDefinitionManager.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; + +namespace CapnpC.Model +{ + class TypeDefinitionManager + { + readonly Dictionary _id2def = + new Dictionary(); + + public TypeDefinition GetOrCreate(ulong id, TypeTag tag) + { + if (_id2def.TryGetValue(id, out var def)) + { + if (def.Tag == TypeTag.Unknown) + { + def.Tag = tag; + } + else if (tag != TypeTag.Unknown && def.Tag != tag) + { + throw new ArgumentOutOfRangeException(nameof(tag), "Type tag does not match existing type"); + } + } + else + { + def = new TypeDefinition(tag, id); + _id2def.Add(id, def); + } + + return def; + } + + public TypeDefinition GetExisting(ulong id) + { + return _id2def[id]; + } + } +} diff --git a/capnpc-csharp/Model/TypeTag.cs b/capnpc-csharp/Model/TypeTag.cs new file mode 100644 index 0000000..66b7d5e --- /dev/null +++ b/capnpc-csharp/Model/TypeTag.cs @@ -0,0 +1,33 @@ +namespace CapnpC.Model +{ + enum TypeTag + { + Unknown, + Void, + Bool, + S8, + U8, + S16, + U16, + S32, + U32, + S64, + U64, + F32, + F64, + List, + Data, + Text, + AnyPointer, + StructPointer, + ListPointer, + CapabilityPointer, + ParameterPointer, + ImplicitMethodParameterPointer, + Struct, + Group, + Interface, + Enum, + AnyEnum + } +} diff --git a/capnpc-csharp/Model/Types.cs b/capnpc-csharp/Model/Types.cs new file mode 100644 index 0000000..ee20603 --- /dev/null +++ b/capnpc-csharp/Model/Types.cs @@ -0,0 +1,56 @@ +using System; + +namespace CapnpC.Model +{ + static class Types + { + public static readonly Type Void = new Type(TypeTag.Void); + public static readonly Type Bool = new Type(TypeTag.Bool); + public static readonly Type S8 = new Type(TypeTag.S8); + public static readonly Type U8 = new Type(TypeTag.U8); + public static readonly Type S16 = new Type(TypeTag.S16); + public static readonly Type U16 = new Type(TypeTag.U16); + public static readonly Type S32 = new Type(TypeTag.S32); + public static readonly Type U32 = new Type(TypeTag.U32); + public static readonly Type S64 = new Type(TypeTag.S64); + public static readonly Type U64 = new Type(TypeTag.U64); + public static readonly Type F32 = new Type(TypeTag.F32); + public static readonly Type F64 = new Type(TypeTag.F64); + public static readonly Type AnyPointer = new Type(TypeTag.AnyPointer); + public static readonly Type StructPointer = new Type(TypeTag.StructPointer); + public static readonly Type ListPointer = new Type(TypeTag.ListPointer); + public static readonly Type CapabilityPointer = new Type(TypeTag.CapabilityPointer); + public static readonly Type Data = new Type(TypeTag.Data); + public static readonly Type Text = new Type(TypeTag.Text); + public static readonly Type AnyEnum = new Type(TypeTag.AnyEnum); + + public static Type List(Type elementType) + { + return new Type(TypeTag.List) + { + ElementType = elementType + }; + } + + public static Type FromDefinition(TypeDefinition def) + { + if (def.Tag == TypeTag.Unknown) + { + throw new InvalidOperationException("Oops, type definition is not yet valid, cannot create type"); + } + + return new Type(def.Tag) + { + Definition = def + }; + } + + public static Type FromParameter(GenericParameter genericParameter) + { + return new Type(TypeTag.AnyPointer) + { + Parameter = genericParameter + }; + } + } +} diff --git a/capnpc-csharp/Model/Value.cs b/capnpc-csharp/Model/Value.cs new file mode 100644 index 0000000..955e51a --- /dev/null +++ b/capnpc-csharp/Model/Value.cs @@ -0,0 +1,300 @@ +using Capnp; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace CapnpC.Model +{ + class Value + { + public static Value Scalar(T scalar) + { + var value = new Value() + { + ScalarValue = scalar + }; + + if (typeof(T) == typeof(bool)) + value.Type = Types.Bool; + else if (typeof(T) == typeof(float)) + value.Type = Types.F32; + else if (typeof(T) == typeof(double)) + value.Type = Types.F64; + else if (typeof(T) == typeof(sbyte)) + value.Type = Types.S8; + else if (typeof(T) == typeof(byte)) + value.Type = Types.U8; + else if (typeof(T) == typeof(short)) + value.Type = Types.S16; + else if (typeof(T) == typeof(ushort)) + value.Type = Types.U16; + else if (typeof(T) == typeof(int)) + value.Type = Types.S32; + else if (typeof(T) == typeof(uint)) + value.Type = Types.U32; + else if (typeof(T) == typeof(long)) + value.Type = Types.S64; + else if (typeof(T) == typeof(ulong)) + value.Type = Types.U64; + else if (typeof(T) == typeof(string)) + value.Type = Types.Text; + else + throw new NotImplementedException(); + + return value; + } + + public Type Type { get; set; } + public object ScalarValue { get; set; } + public Capnp.DeserializerState RawValue { get; set; } + public List Items { get; } = new List(); + public int VoidListCount { get; set; } + public ushort DiscriminatorValue { get; private set; } + public List<(Field, Value)> Fields { get; } = new List<(Field, Value)>(); + + public Enumerant GetEnumerant() + { + if (Type.Tag != TypeTag.Enum) + throw new InvalidOperationException(); + + if (Type.Definition.Enumerants[0].Ordinal.HasValue) + return Type.Definition.Enumerants.Single(e => e.Ordinal == (ushort)ScalarValue); + else + return Type.Definition.Enumerants[(ushort)ScalarValue]; + } + + void DecodeStruct() + { + if (RawValue.Kind != Capnp.ObjectKind.Struct) + { + throw new NotSupportedException(); + } + + var def = Type.Definition; + + if (def.UnionInfo != null) + { + DiscriminatorValue = RawValue.ReadDataUShort(def.UnionInfo.TagOffset, ushort.MaxValue); + } + + foreach (var field in Type.Fields) + { + if (field.DiscValue.HasValue && field.DiscValue.Value != DiscriminatorValue) + continue; + + Value value = new Value() + { + Type = field.Type + }; + + switch (field.Type.Tag) + { + case TypeTag.AnyEnum: + value.ScalarValue = field.DefaultValue?.ScalarValue as ushort? ?? 0; + break; + + case TypeTag.AnyPointer: + value.RawValue = RawValue.StructReadPointer((int)field.Offset); + break; + + case TypeTag.Bool: + value.ScalarValue = RawValue.ReadDataBool(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as bool?) ?? false); + break; + + case TypeTag.CapabilityPointer: + case TypeTag.Interface: + continue; + + case TypeTag.Data: + case TypeTag.Group: + case TypeTag.Struct: + case TypeTag.List: + case TypeTag.Text: + value.RawValue = RawValue.StructReadPointer((int)field.Offset); + value.Decode(); + break; + + case TypeTag.ListPointer: + case TypeTag.StructPointer: + value.RawValue = RawValue.StructReadPointer((int)field.Offset); + break; + + case TypeTag.Enum: + value.ScalarValue = field.DefaultValue?.ScalarValue as ushort? ?? ushort.MaxValue; + break; + + case TypeTag.F32: + value = Scalar(RawValue.ReadDataFloat(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as float?) ?? 0.0f)); + break; + + case TypeTag.F64: + value = Scalar(RawValue.ReadDataDouble(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as double?) ?? 0.0f)); + break; + + case TypeTag.S16: + value = Scalar(RawValue.ReadDataShort(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as short?) ?? 0)); + break; + + case TypeTag.S32: + value = Scalar(RawValue.ReadDataInt(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as int?) ?? 0)); + break; + + case TypeTag.S64: + value = Scalar(RawValue.ReadDataLong(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as long?) ?? 0)); + break; + + case TypeTag.S8: + value = Scalar(RawValue.ReadDataSByte(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as sbyte?) ?? 0)); + break; + + case TypeTag.U16: + value = Scalar(RawValue.ReadDataUShort(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as ushort?) ?? 0)); + break; + + case TypeTag.U32: + value = Scalar(RawValue.ReadDataUInt(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as uint?) ?? 0)); + break; + + case TypeTag.U64: + value = Scalar(RawValue.ReadDataULong(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as ulong?) ?? 0)); + break; + + case TypeTag.U8: + value = Scalar(RawValue.ReadDataByte(field.BitOffset.Value, (field.DefaultValue?.ScalarValue as byte?) ?? 0)); + break; + + case TypeTag.Void: + continue; + + default: + throw new NotImplementedException(); + } + + Fields.Add((field, value)); + } + } + + void DecodeList() + { + switch (Type.Tag) + { + case TypeTag.Data: + Items.AddRange(RawValue.RequireList().CastByte().Select(Scalar)); + break; + + case TypeTag.List: + switch (Type.ElementType.Tag) + { + case TypeTag.AnyEnum: + case TypeTag.Enum: + Items.AddRange(RawValue.RequireList().CastUShort().Select(u => { + var v = Scalar(u); + v.Type = Type.ElementType; + return v; })); + break; + + case TypeTag.AnyPointer: + Items.AddRange(RawValue.RequireList().Cast(d => new Value() { Type = Type.ElementType, RawValue = d })); + break; + + case TypeTag.Bool: + Items.AddRange(RawValue.RequireList().CastBool().Select(Scalar)); + break; + + case TypeTag.Data: + case TypeTag.Group: + case TypeTag.Struct: + case TypeTag.List: + Items.AddRange(RawValue.RequireList().Cast(d => { + var v = new Value() { Type = Type.ElementType, RawValue = d }; + v.Decode(); + return v; + })); + break; + + case TypeTag.Text: + Items.AddRange(RawValue.RequireList().CastText2().Select(Scalar)); + break; + + case TypeTag.F32: + Items.AddRange(RawValue.RequireList().CastFloat().Select(Scalar)); + break; + + case TypeTag.F64: + Items.AddRange(RawValue.RequireList().CastDouble().Select(Scalar)); + break; + + case TypeTag.S8: + Items.AddRange(RawValue.RequireList().CastSByte().Select(Scalar)); + break; + + case TypeTag.S16: + Items.AddRange(RawValue.RequireList().CastShort().Select(Scalar)); + break; + + case TypeTag.S32: + Items.AddRange(RawValue.RequireList().CastInt().Select(Scalar)); + break; + + case TypeTag.S64: + Items.AddRange(RawValue.RequireList().CastLong().Select(Scalar)); + break; + + case TypeTag.Void: + VoidListCount = RawValue.RequireList().Count; + break; + + case TypeTag.U16: + Items.AddRange(RawValue.RequireList().CastUShort().Select(Scalar)); + break; + + case TypeTag.U32: + Items.AddRange(RawValue.RequireList().CastUInt().Select(Scalar)); + break; + + case TypeTag.U64: + Items.AddRange(RawValue.RequireList().CastULong().Select(Scalar)); + break; + + case TypeTag.U8: + Items.AddRange(RawValue.RequireList().CastByte().Select(Scalar)); + break; + + default: + throw new NotImplementedException(); + } + break; + + case TypeTag.ListPointer: + Items.AddRange(RawValue.RequireList().Cast(d => new Value() { Type = Type.ElementType, RawValue = d })); + break; + + case TypeTag.Text: + ScalarValue = RawValue.RequireList().CastText(); + break; + } + } + + public void Decode() + { + if (RawValue.Kind == ObjectKind.Nil) return; + + switch (Type.Tag) + { + case TypeTag.Group: + case TypeTag.Struct: + DecodeStruct(); + break; + + case TypeTag.List: + case TypeTag.ListPointer: + case TypeTag.Text: + case TypeTag.Data: + DecodeList(); + break; + } + + RawValue = default(Capnp.DeserializerState); + } + } +} diff --git a/capnpc-csharp/Program.cs b/capnpc-csharp/Program.cs new file mode 100644 index 0000000..779049a --- /dev/null +++ b/capnpc-csharp/Program.cs @@ -0,0 +1,38 @@ +using Capnp; +using System; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; + +namespace CapnpC +{ + class Program + { + static void Main(string[] args) + { + Stream input; + + if (args.Length > 0) + { + input = new FileStream(args[0], FileMode.Open, FileAccess.Read); + } + else + { + input = Console.OpenStandardInput(); + } + + WireFrame segments; + + using (input) + { + segments = Framing.ReadSegments(input); + } + + var dec = DeserializerState.CreateRoot(segments); + var reader = Schema.CodeGeneratorRequest.Reader.Create(dec); + var model = Model.SchemaModel.Create(reader); + var codeGen = new Generator.CodeGenerator(model, new Generator.GeneratorOptions()); + codeGen.Generate(); + } + } +} diff --git a/capnpc-csharp/Schema/SchemaSerialization.cs b/capnpc-csharp/Schema/SchemaSerialization.cs new file mode 100644 index 0000000..a61281a --- /dev/null +++ b/capnpc-csharp/Schema/SchemaSerialization.cs @@ -0,0 +1,1577 @@ +using Capnp; +using System; +using System.Collections.Generic; +using System.Text; + +namespace CapnpC.Schema +{ + namespace Superclass + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public Brand.Reader Brand => State.ReadStruct(0, Schema.Brand.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 1); + } + + public ulong Id + { + get => this.ReadDataULong(0); + set => this.WriteData(0, value); + } + + public Brand.Writer Brand + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + namespace Method + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public string Name => State.ReadText(0); + public ushort CodeOrder => State.ReadDataUShort(0); + public IReadOnlyList ImplicitParameters => State.ReadListOfStructs(4, Node.Parameter.Reader.Create); + public ulong ParamStructType => State.ReadDataULong(64); + public Brand.Reader ParamBrand => State.ReadStruct(2, Brand.Reader.Create); + public ulong ResultStructType => State.ReadDataULong(128); + public Brand.Reader ResultBrand => State.ReadStruct(3, Brand.Reader.Create); + public IReadOnlyList Annotations => State.ReadListOfStructs(1, Annotation.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(5, 3); + } + + public string Name + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ushort CodeOrder + { + get => this.ReadDataUShort(0); + set => this.WriteData(0, value); + } + + public ListOfStructsSerializer ImplicitParameters + { + get => BuildPointer>(4); + set => Link(4, value); + } + + public ref ulong ParamStructType => ref this.RefData(8); + + public Brand.Writer ParamBrand + { + get => BuildPointer(2); + set => Link(2, value); + } + + public ulong ResultStructType + { + get => this.ReadDataULong(128); + set => this.WriteData(128, value); + } + + public Brand.Writer ResultBrand + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + namespace Type + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ushort Tag => State.ReadDataUShort(0); + public bool IsVoid => Tag == 0; + public bool IsBool => Tag == 1; + public bool IsInt8 => Tag == 2; + public bool IsInt16 => Tag == 3; + public bool IsInt32 => Tag == 4; + public bool IsInt64 => Tag == 5; + public bool IsUInt8 => Tag == 6; + public bool IsUInt16 => Tag == 7; + public bool IsUInt32 => Tag == 8; + public bool IsUInt64 => Tag == 9; + public bool IsFloat32 => Tag == 10; + public bool IsFloat64 => Tag == 11; + public bool IsText => Tag == 12; + public bool IsData => Tag == 13; + public bool IsList => Tag == 14; + public Reader List_ElementType => IsList ? State.ReadStruct(0, Create) : default; + public bool IsEnum => Tag == 15; + public ulong Enum_TypeId => IsEnum ? State.ReadDataULong(64) : 0; + public Brand.Reader Enum_Brand => IsEnum ? State.ReadStruct(0, Brand.Reader.Create) : default; + public bool IsStruct => Tag == 16; + public ulong Struct_TypeId => IsStruct ? State.ReadDataULong(64) : 0; + public Brand.Reader Struct_Brand => IsStruct ? State.ReadStruct(0, Brand.Reader.Create) : default; + public bool IsInterface => Tag == 17; + public ulong Interface_TypeId => IsInterface ? State.ReadDataULong(64) : 0; + public Brand.Reader Interface_Brand => IsInterface ? State.ReadStruct(0, Brand.Reader.Create) : default; + public bool IsAnyPointer => Tag == 18; + public ushort AnyPointer_Tag => IsAnyPointer ? State.ReadDataUShort(64) : default; + public bool AnyPointer_IsUnconstrained => IsAnyPointer && AnyPointer_Tag == 0; + public ushort AnyPointer_Unconstrained_Tag => AnyPointer_IsUnconstrained ? State.ReadDataUShort(80) : (ushort)0; + public bool AnyPointer_Unconstrained_IsAnyKind => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 0; + public bool AnyPointer_Unconstrained_IsStruct => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 1; + public bool AnyPointer_Unconstrained_IsList => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 2; + public bool AnyPointer_Unconstrained_IsCapability => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 3; + public bool AnyPointer_IsParameter => IsAnyPointer && AnyPointer_Tag == 1; + public ulong AnyPointer_Parameter_ScopeId => AnyPointer_IsParameter ? State.ReadDataULong(128) : 0; + public ushort AnyPointer_Parameter_ParameterIndex => AnyPointer_IsParameter ? State.ReadDataUShort(80) : (ushort)0; + public bool AnyPointer_IsImplicitMethodParameter => AnyPointer_Tag == 2; + public ushort AnyPointer_ImplicitMethodParameter_ParameterIndex => AnyPointer_IsImplicitMethodParameter ? State.ReadDataUShort(80) : default; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(3, 1); + } + + public ref ushort Tag => ref this.RefData(0); + + public bool IsVoid + { + get => Tag == 0; + set => Tag = 0; + } + + public bool IsBool + { + get => Tag == 1; + set => Tag = 1; + } + + public bool IsInt8 + { + get => Tag == 2; + set => Tag = 2; + } + + public bool IsInt16 + { + get => Tag == 3; + set => Tag = 3; + } + + public bool IsInt32 + { + get => Tag == 4; + set => Tag = 4; + } + + public bool IsInt64 + { + get => Tag == 5; + set => Tag = 5; + } + + public bool IsUInt8 + { + get => Tag == 6; + set => Tag = 6; + } + + public bool IsUInt16 + { + get => Tag == 7; + set => Tag = 7; + } + + public bool IsUInt32 + { + get => Tag == 8; + set => Tag = 8; + } + + public bool IsUInt64 + { + get => Tag == 9; + set => Tag = 9; + } + + public bool IsFloat32 + { + get => Tag == 10; + set => Tag = 10; + } + + public bool IsFloat64 + { + get => Tag == 11; + set => Tag = 11; + } + + public bool IsText + { + get => Tag == 12; + set => Tag = 12; + } + + public bool IsData + { + get => Tag == 13; + set => Tag = 13; + } + + public bool IsList + { + get => Tag == 14; + set => Tag = 14; + } + + public Writer List_ElementType + { + get => IsList ? BuildPointer(0) : default; + set { Link(0, value); } + } + + public bool IsEnum + { + get => Tag == 15; + set => Tag = 15; + } + + public ulong Enum_TypeId + { + get => IsEnum ? this.ReadDataULong(64) : 0; + set { this.WriteData(64, value); } + } + + public Brand.Writer Enum_Brand + { + get => IsEnum ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsStruct + { + get => Tag == 16; + set => Tag = 16; + } + + public ulong Struct_TypeId + { + get => IsStruct ? this.ReadDataULong(64) : 0; + set => this.WriteData(64, value); + } + + public Brand.Writer Struct_Brand + { + get => IsStruct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsInterface + { + get => Tag == 17; + set => Tag = 17; + } + + public ulong Interface_TypeId + { + get => IsStruct ? this.ReadDataULong(64) : 0; + set => this.WriteData(64, value); + } + + public Brand.Writer Interface_Brand + { + get => IsStruct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsAnyPointer + { + get => Tag == 18; + set => Tag = 18; + } + + public ushort AnyPointer_Tag + { + get => IsAnyPointer ? this.ReadDataUShort(64) : default; + set => this.WriteData(64, value); + } + + public bool AnyPointer_IsUnconstrained + { + get => IsAnyPointer && AnyPointer_Tag == 0; + set => AnyPointer_Tag = 0; + } + + public ushort AnyPointer_Unconstrained_Tag + { + get => AnyPointer_IsUnconstrained ? this.ReadDataUShort(80) : (ushort)0; + set => this.WriteData(80, value); + } + + public bool AnyPointer_Unconstrained_IsAnyKind + { + get => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 0; + set => AnyPointer_Unconstrained_Tag = 0; + } + + public bool AnyPointer_Unconstrained_IsStruct + { + get => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 1; + set => AnyPointer_Unconstrained_Tag = 1; + } + + public bool AnyPointer_Unconstrained_IsList + { + get => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 2; + set => AnyPointer_Unconstrained_Tag = 2; + } + + public bool AnyPointer_Unconstrained_IsCapability + { + get => AnyPointer_IsUnconstrained && AnyPointer_Unconstrained_Tag == 3; + set => AnyPointer_Unconstrained_Tag = 3; + } + + public bool AnyPointer_IsParameter + { + get => IsAnyPointer && AnyPointer_Tag == 1; + set => AnyPointer_Tag = 1; + } + + public ulong AnyPointer_Parameter_ScopeId + { + get => AnyPointer_IsParameter ? this.ReadDataULong(128) : 0; + set => this.WriteData(128, value); + } + + public ushort AnyPointer_Parameter_ParameterIndex + { + get => AnyPointer_IsParameter ? this.ReadDataUShort(80) : (ushort)0; + set => this.WriteData(80, value); + } + + public bool AnyPointer_IsImplicitMethodParameter + { + get => AnyPointer_Tag == 2; + set => AnyPointer_Tag = 2; + } + + public ushort AnyPointer_ImplicitMethodParameter_ParameterIndex + { + get => AnyPointer_IsImplicitMethodParameter ? this.ReadDataUShort(80) : default; + set => this.WriteData(80, value); + } + } + } + + namespace Brand + { + namespace Scope + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong ScopeId => State.ReadDataULong(0); + public ushort Tag => State.ReadDataUShort(64); + public bool IsBind => Tag == 0; + public IReadOnlyList Bind => IsBind ? State.ReadListOfStructs(0, Binding.Reader.Create) : null; + public bool IsInherit => Tag == 1; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(2, 1); + } + + public ulong ScopeId + { + get => this.ReadDataULong(0); + set => this.WriteData(0, value); + } + + public ushort Tag + { + get => this.ReadDataUShort(64); + set => this.WriteData(64, value); + } + + public bool IsBind + { + get => Tag == 0; + set => Tag = 0; + } + + public ListOfStructsSerializer Bind + { + get => IsBind ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public bool IsInherit + { + get => Tag == 1; + set => Tag = 1; + } + } + + namespace Binding + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ushort Tag => State.ReadDataUShort(0); + public bool IsUnbound => Tag == 0; + public bool IsType => Tag == 1; + public Type.Reader Type => IsType ? State.ReadStruct(0, Schema.Type.Reader.Create) : default; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 1); + } + + public ushort Tag + { + get => this.ReadDataUShort(0); + set => this.WriteData(0, value); + } + + public bool IsUnbound + { + get => Tag == 0; + set => Tag = 0; + } + + public bool IsType + { + get => Tag == 1; + set => Tag = 1; + } + + public Type.Writer Type + { + get => IsType ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + } + + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public IReadOnlyList Scopes => State.ReadListOfStructs(0, Scope.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(0, 1); + } + + public ListOfStructsSerializer Scopes + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + } + + namespace Value + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ushort Tag => State.ReadDataUShort(0); + public bool IsVoid => Tag == 0; + public bool IsBool => Tag == 1; + public bool Bool => IsBool ? State.ReadDataBool(16) : default; + public bool IsInt8 => Tag == 2; + public sbyte Int8 => IsInt8 ? State.ReadDataSByte(16) : default; + public bool IsInt16 => Tag == 3; + public short Int16 => IsInt16 ? State.ReadDataShort(16) : default; + public bool IsInt32 => Tag == 4; + public int Int32 => IsInt32 ? State.ReadDataInt(32) : default; + public bool IsInt64 => Tag == 5; + public long Int64 => IsInt64 ? State.ReadDataLong(64) : default; + public bool IsUInt8 => Tag == 6; + public byte UInt8 => IsUInt8 ? State.ReadDataByte(16) : default; + public bool IsUInt16 => Tag == 7; + public ushort UInt16 => IsUInt16 ? State.ReadDataUShort(16) : default; + public bool IsUInt32 => Tag == 8; + public uint UInt32 => IsUInt32 ? State.ReadDataUInt(32) : default; + public bool IsUInt64 => Tag == 9; + public ulong UInt64 => IsUInt64 ? State.ReadDataULong(64) : default; + public bool IsFloat32 => Tag == 10; + public float Float32 => IsFloat32 ? State.ReadDataFloat(32) : default; + public bool IsFloat64 => Tag == 11; + public double Float64 => IsFloat64 ? State.ReadDataDouble(64) : default; + public bool IsText => Tag == 12; + public string Text => IsText ? State.ReadText(0) : default; + public bool IsData => Tag == 13; + public ListDeserializer Data => IsData ? State.ReadList(0) : default; + public bool IsList => Tag == 14; + public DeserializerState List => IsList ? State.StructReadPointer(0) : default; + public bool IsEnum => Tag == 15; + public ushort Enum => IsEnum ? State.ReadDataUShort(16) : default; + public bool IsStruct => Tag == 16; + public DeserializerState Struct => IsStruct ? State.StructReadPointer(0) : default; + public bool IsInterface => Tag == 17; + public bool IsAnyPointer => Tag == 18; + public DeserializerState AnyPointer => IsAnyPointer ? State.StructReadPointer(0) : default; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(2, 1); + } + + public ushort Tag + { + get => this.ReadDataUShort(0); + set => this.WriteData(0, value); + } + + public bool IsVoid + { + get => Tag == 0; + set => Tag = 0; + } + + public bool IsBool + { + get => Tag == 1; + set => Tag = 1; + } + + public bool Bool + { + get => IsBool ? this.ReadDataBool(16) : default; + set => this.WriteData(16, value); + } + + public bool IsInt8 + { + get => Tag == 2; + set => Tag = 2; + } + + public sbyte Int8 + { + get => IsInt8 ? this.ReadDataSByte(16) : default; + set => this.WriteData(16, value); + } + + public bool IsInt16 + { + get => Tag == 3; + set => Tag = 3; + } + + public short Int16 + { + get => IsInt16 ? this.ReadDataShort(16) : default; + set => this.WriteData(16, value); + } + + public bool IsInt32 + { + get => Tag == 4; + set => Tag = 4; + } + + public int Int32 + { + get => IsInt32 ? this.ReadDataInt(32) : default; + set => this.WriteData(32, value); + } + + public bool IsInt64 + { + get => Tag == 5; + set => Tag = 5; + } + + public long Int64 + { + get => IsInt64 ? this.ReadDataLong(64) : default; + set => this.WriteData(64, value); + } + + public bool IsUInt8 + { + get => Tag == 6; + set => Tag = 6; + } + + public byte UInt8 + { + get => IsUInt8 ? this.ReadDataByte(16) : default; + set => this.WriteData(16, value); + } + + public bool IsUInt16 + { + get => Tag == 7; + set => Tag = 7; + } + + public ushort UInt16 + { + get => IsUInt16 ? this.ReadDataUShort(16) : default; + set => this.WriteData(16, value); + } + + public bool IsUInt32 + { + get => Tag == 8; + set => Tag = 8; + } + + public uint UInt32 + { + get => IsUInt32 ? this.ReadDataUInt(32) : default; + set => this.WriteData(32, value); + } + + public bool IsUInt64 + { + get => Tag == 9; + set => Tag = 9; + } + + public ulong UInt64 + { + get => IsUInt64 ? this.ReadDataULong(64) : default; + set => this.WriteData(64, value); + } + + public bool IsFloat32 + { + get => Tag == 10; + set => Tag = 10; + } + + public float Float32 + { + get => IsFloat32 ? this.ReadDataFloat(32) : default; + set => this.WriteData(32, value); + } + + public bool IsFloat64 + { + get => Tag == 11; + set => Tag = 11; + } + + public double Float64 + { + get => IsFloat64 ? this.ReadDataDouble(64) : default; + set => this.WriteData(64, value); + } + + public bool IsText + { + get => Tag == 12; + set => Tag = 12; + } + + public string Text + { + get => IsText ? ReadText(0) : default; + set => WriteText(0, value); + } + + public bool IsData + { + get => Tag == 13; + set => Tag = 13; + } + + public SerializerState Data + { + get => IsData ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsList + { + get => Tag == 14; + set => Tag = 14; + } + + public SerializerState List + { + get => IsList ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsEnum + { + get => Tag == 15; + set => Tag = 15; + } + + public ushort Enum + { + get => IsEnum ? this.ReadDataUShort(16) : default; + set => this.WriteData(16, value); + } + + public bool IsStruct + { + get => Tag == 16; + set => Tag = 16; + } + + public SerializerState Struct + { + get => IsStruct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public bool IsInterface + { + get => Tag == 17; + set => Tag = 17; + } + + public bool IsAnyPointer + { + get => Tag == 18; + set => Tag = 18; + } + + public SerializerState AnyPointer + { + get => IsAnyPointer ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + namespace Annotation + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public Brand.Reader Brand => State.ReadStruct(1, Schema.Brand.Reader.Create); + public Value.Reader Value => State.ReadStruct(0, Schema.Value.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 2); + } + + public ref ulong Id => ref this.RefData(0); + + public Brand.Writer Brand + { + get => BuildPointer(1); + set => Link(1, value); + } + + public Value.Writer Value + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public enum ElementSize: ushort + { + Empty = 0, + Bit = 1, + Byte = 2, + TwoBytes = 3, + FourBytes = 4, + EightBytes = 5, + Pointer = 6, + InlineComposite = 7 + } + + namespace Field + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public string Name => State.ReadText(0); + public ushort CodeOrder => State.ReadDataUShort(0); + public IReadOnlyList Annotations => State.ReadListOfStructs(1, Annotation.Reader.Create); + public ushort DiscriminantValue => State.ReadDataUShort(16, 65535); + public ushort Tag => State.ReadDataUShort(64); + public bool IsSlot => Tag == 0; + public uint Slot_Offset => IsSlot ? State.ReadDataUInt(32) : default; + public Type.Reader Slot_Type => IsSlot ? State.ReadStruct(2, Type.Reader.Create) : default; + public Value.Reader Slot_DefaultValue => IsSlot ? State.ReadStruct(3, Value.Reader.Create) : default; + public bool Slot_HadExplicitDefault => IsSlot ? State.ReadDataBool(128) : default; + public bool IsGroup => Tag == 1; + public ulong Group_TypeId => IsGroup ? State.ReadDataULong(128) : default; + public ushort Ordinal_Tag => State.ReadDataUShort(80); + public bool Ordinal_IsImplicit => Ordinal_Tag == 0; + public bool Ordinal_IsExplicit => Ordinal_Tag == 1; + public ushort Ordinal_Explicit => Ordinal_IsExplicit ? State.ReadDataUShort(96) : default; + + public const ushort NoDiscriminant = 0xffff; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(3, 3); + } + + public string Name + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ref ushort CodeOrder => ref this.RefData(0); + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ushort DiscriminantValue + { + get => this.ReadDataUShort(16, 65535); + set => this.WriteData(16, value, (ushort)65535); + } + + public ref ushort Tag => ref this.RefData(8); + + public bool IsSlot + { + get => Tag == 0; + set => Tag = 0; + } + + public uint Slot_Offset + { + get => IsSlot ? this.ReadDataUInt(32) : default; + set => this.WriteData(32, value); + } + + public Type.Writer Slot_Type + { + get => IsSlot ? BuildPointer(2) : default; + set => Link(2, value); + } + + public Value.Writer Slot_DefaultValue + { + get => IsSlot ? BuildPointer(3) : default; + set => Link(3, value); + } + + public bool Slot_HadExplicitDefault + { + get => IsSlot ? this.ReadDataBool(128) : default; + set => this.WriteData(128, value); + } + + public bool IsGroup + { + get => Tag == 1; + set => Tag = 1; + } + + public ref ulong Group_TypeId => ref this.RefData(2); + + public ref ushort Ordinal_Tag => ref this.RefData(5); + + public bool Ordinal_IsImplicit + { + get => Ordinal_Tag == 0; + set => Ordinal_Tag = 0; + } + + public bool Ordinal_IsExplicit + { + get => Ordinal_Tag == 1; + set => Ordinal_Tag = 1; + } + + public ref ushort Ordinal_Explicit => ref this.RefData(6); + } + } + + namespace Node + { + namespace Parameter + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public string Name => State.ReadText(0); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(0, 1); + } + + public string Name + { + get => ReadText(0); + set => WriteText(0, value); + } + } + } + + namespace NestedNode + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public string Name => State.ReadText(0); + public ulong Id => State.ReadDataULong(0); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 1); + } + + public string Name + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ref ulong Id => ref this.RefData(0); + } + } + + namespace SourceInfo + { + namespace Member + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public string DocComment => State.ReadText(0); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(0, 1); + } + + public string DocComment + { + get => ReadText(0); + set => WriteText(0, value); + } + } + } + + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public string DocComment => State.ReadText(0); + public IReadOnlyList Members => State.ReadListOfStructs(1, Member.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 2); + } + + public ref ulong Id => ref this.RefData(0); + + public string DocComment + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ListOfStructsSerializer Members + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public string DisplayName => State.ReadText(0); + public uint DisplayNamePrefixLength => State.ReadDataUInt(64); + public ulong ScopeId => State.ReadDataULong(128); + public IReadOnlyList Parameters => State.ReadListOfStructs(5, Parameter.Reader.Create); + public bool IsGeneric => State.ReadDataBool(288); + public IReadOnlyList NestedNodes => State.ReadListOfStructs(1, NestedNode.Reader.Create); + public IReadOnlyList Annotations => State.ReadListOfStructs(2, Annotation.Reader.Create); + public ushort Tag => State.ReadDataUShort(96); + public bool IsFile => Tag == 0; + public bool IsStruct => Tag == 1; + public ushort Struct_DataWordCount => IsStruct ? State.ReadDataUShort(112) : default; + public ushort Struct_PointerCount => IsStruct ? State.ReadDataUShort(192) : default; + public ElementSize Struct_PreferredListEncoding => IsStruct ? (ElementSize)State.ReadDataUShort(208) : default; + public bool Struct_IsGroup => IsStruct ? State.ReadDataBool(224) : default; + public ushort Struct_DiscriminantCount => IsStruct ? State.ReadDataUShort(240) : default; + public uint Struct_DiscriminantOffset => IsStruct ? State.ReadDataUInt(256) : default; + public IReadOnlyList Fields => IsStruct ? State.ReadListOfStructs(3, Field.Reader.Create) : default; + public bool IsEnum => Tag == 2; + public IReadOnlyList Enumerants => IsEnum ? State.ReadListOfStructs(3, Field.Reader.Create) : default; + public bool IsInterface => Tag == 3; + public IReadOnlyList Interface_Methods => IsInterface ? State.ReadListOfStructs(3, Method.Reader.Create) : default; + public IReadOnlyList Interface_Superclasses => IsInterface ? State.ReadListOfStructs(4, Superclass.Reader.Create) : default; + public bool IsConst => Tag == 4; + public Type.Reader Const_Type => IsConst ? State.ReadStruct(3, Type.Reader.Create) : default; + public Value.Reader Const_Value => IsConst ? State.ReadStruct(4, Value.Reader.Create) : default; + public bool IsAnnotation => Tag == 5; + public Type.Reader Annotation_Type => IsAnnotation ? State.ReadStruct(3, Type.Reader.Create) : default; + public bool Annotation_TargetsFile => IsAnnotation ? State.ReadDataBool(112) : default; + public bool Annotation_TargetsConst => IsAnnotation ? State.ReadDataBool(113) : default; + public bool Annotation_TargetsEnum => IsAnnotation ? State.ReadDataBool(114) : default; + public bool Annotation_TargetsEnumerant => IsAnnotation ? State.ReadDataBool(115) : default; + public bool Annotation_TargetsStruct => IsAnnotation ? State.ReadDataBool(116) : default; + public bool Annotation_TargetsField => IsAnnotation ? State.ReadDataBool(117) : default; + public bool Annotation_TargetsUnion => IsAnnotation ? State.ReadDataBool(118) : default; + public bool Annotation_TargetsGroup => IsAnnotation ? State.ReadDataBool(119) : default; + public bool Annotation_TargetsInterface => IsAnnotation ? State.ReadDataBool(120) : default; + public bool Annotation_TargetsMethod => IsAnnotation ? State.ReadDataBool(121) : default; + public bool Annotation_TargetsParam => IsAnnotation ? State.ReadDataBool(122) : default; + public bool Annotation_TargetsAnnotation => IsAnnotation ? State.ReadDataBool(123) : default; + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(5, 6); + } + + public ulong Id + { + get => this.ReadDataULong(0); + set => this.WriteData(0, value); + } + + public string DisplayName + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ref uint DisplayNamePrefixLength => ref this.RefData(2); + + public ref ulong ScopeId => ref this.RefData(2); + + public ListOfStructsSerializer Parameters + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public bool IsGeneric + { + get => this.ReadDataBool(288); + set => this.WriteData(288, value); + } + + public ListOfStructsSerializer NestedNodes + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(2); + set => Link(2, value); + } + + public ref ushort Tag => ref this.RefData(6); + + public bool IsFile + { + get => Tag == 0; + set => Tag = 0; + } + + public bool IsStruct + { + get => Tag == 1; + set => Tag = 1; + } + + public ref ushort Struct_DataWordCount => ref this.RefData(7); + + public ref ushort Struct_PointerCount => ref this.RefData(12); + + public ref ElementSize Struct_PreferredListEncoding => ref this.RefData(13); + + public bool Struct_IsGroup + { + get => IsStruct ? this.ReadDataBool(224) : default; + set => this.WriteData(224, value); + } + + public ref ushort Struct_DiscriminantCount => ref this.RefData(15); + + public ref uint Struct_DiscriminantOffset => ref this.RefData(8); + + public ListOfStructsSerializer Fields + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public bool IsEnum + { + get => Tag == 2; + set => Tag = 2; + } + + public ListOfStructsSerializer Enumerants + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public bool IsInterface + { + get => Tag == 3; + set => Tag = 3; + } + + public ListOfStructsSerializer Interface_Methods + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public ListOfStructsSerializer Interface_Superclasses + { + get => IsInterface ? BuildPointer>(4) : default; + set => Link(4, value); + } + + public bool IsConst + { + get => Tag == 4; + set => Tag = 4; + } + + public Type.Writer Const_Type + { + get => IsConst ? BuildPointer(3) : default; + set => Link(3, value); + } + + public Value.Writer Const_Value + { + get => IsConst ? BuildPointer(4) : default; + set => Link(4, value); + } + + public bool IsAnnotation + { + get => Tag == 5; + set => Tag = 5; + } + + public Type.Writer Annotation_Type + { + get => IsAnnotation ? BuildPointer(3) : default; + set => Link(3, value); + } + + public bool Annotation_TargetsFile + { + get => IsAnnotation ? this.ReadDataBool(112) : default; + set => this.WriteData(112, value); + } + + public bool Annotation_TargetsConst + { + get => IsAnnotation ? this.ReadDataBool(113) : default; + set => this.WriteData(113, value); + } + + public bool Annotation_TargetsEnum + { + get => IsAnnotation ? this.ReadDataBool(114) : default; + set => this.WriteData(114, value); + } + + public bool Annotation_TargetsEnumerant + { + get => IsAnnotation ? this.ReadDataBool(115) : default; + set => this.WriteData(115, value); + } + + public bool Annotation_TargetsStruct + { + get => IsAnnotation ? this.ReadDataBool(116) : default; + set => this.WriteData(116, value); + } + + public bool Annotation_TargetsField + { + get => IsAnnotation ? this.ReadDataBool(117) : default; + set => this.WriteData(117, value); + } + + public bool Annotation_TargetsUnion + { + get => IsAnnotation ? this.ReadDataBool(118) : default; + set => this.WriteData(118, value); + } + + public bool Annotation_TargetsGroup + { + get => IsAnnotation ? this.ReadDataBool(119) : default; + set => this.WriteData(119, value); + } + + public bool Annotation_TargetsInterface + { + get => IsAnnotation ? this.ReadDataBool(120) : default; + set => this.WriteData(120, value); + } + + public bool Annotation_TargetsMethod + { + get => IsAnnotation ? this.ReadDataBool(121) : default; + set => this.WriteData(121, value); + } + + public bool Annotation_TargetsParam + { + get => IsAnnotation ? this.ReadDataBool(122) : default; + set => this.WriteData(122, value); + } + + public bool Annotation_TargetsAnnotation + { + get => IsAnnotation ? this.ReadDataBool(123) : default; + set => this.WriteData(123, value); + } + } + } + + namespace CapnpVersion + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ushort Major => State.ReadDataUShort(0); + public byte Minor => State.ReadDataByte(16); + public byte Micro => State.ReadDataByte(24); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 0); + } + + public ref ushort Major => ref this.RefData(0); + public ref byte Minor => ref this.RefData(2); + public ref byte Micro => ref this.RefData(3); + } + } + + namespace CodeGeneratorRequest + { + namespace RequestedFile + { + namespace Import + { + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public string Name => State.ReadText(0); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 1); + } + + public ref ulong Id => ref this.RefData(0); + + public string Name + { + get => ReadText(0); + set => WriteText(0, value); + } + } + } + + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public ulong Id => State.ReadDataULong(0); + public string Filename => State.ReadText(0); + public IReadOnlyList Imports => State.ReadListOfStructs(1, Import.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(1, 2); + } + + public ref ulong Id => ref this.RefData(0); + + public string Filename + { + get => ReadText(0); + set => WriteText(0, value); + } + + public ListOfStructsSerializer Imports + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public struct Reader + { + public DeserializerState State { get; } + + public Reader(DeserializerState ctx) + { + State = ctx; + } + + public static Reader Create(DeserializerState ctx) => new Reader(ctx); + + public CapnpVersion.Reader CapnpVersion => State.ReadStruct(2, Schema.CapnpVersion.Reader.Create); + public IReadOnlyList Nodes => State.ReadListOfStructs(0, Node.Reader.Create); + public IReadOnlyList SourceInfo => State.ReadListOfStructs(3, Node.SourceInfo.Reader.Create); + public IReadOnlyList RequestedFiles => State.ReadListOfStructs(1, RequestedFile.Reader.Create); + } + + public class Writer: SerializerState + { + public Writer() + { + SetStruct(0, 3); + } + + public CapnpVersion.Writer CapnpVersion + { + get => BuildPointer(2); + set => Link(2, value); + } + + public ListOfStructsSerializer Nodes + { + get => BuildPointer>(0); + set => Link(0, value); + } + + public ListOfStructsSerializer SourceInfo + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public ListOfStructsSerializer RequestedFiles + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } +} diff --git a/capnpc-csharp/Schema/schema-with-offsets.capnp b/capnpc-csharp/Schema/schema-with-offsets.capnp new file mode 100644 index 0000000..709eaab --- /dev/null +++ b/capnpc-csharp/Schema/schema-with-offsets.capnp @@ -0,0 +1,235 @@ +# F:/Downloads/capnproto-c++-win32-0.7.0/capnproto-c++-0.7.0/src/capnp/schema-priv.capnp +@0xa93fc509624c72d9; +$import "/F:/Downloads/capnproto-c++-win32-0.7.0/capnproto-c++-0.7.0/src/capnp/c++.capnp".namespace("capnp::schema"); +struct Node @0xe682ab4cf923a417 { # 40 bytes, 6 ptrs + id @0 :UInt64; # bits[0, 64) + displayName @1 :Text; # ptr[0] + displayNamePrefixLength @2 :UInt32; # bits[64, 96) + scopeId @3 :UInt64; # bits[128, 192) + parameters @32 :List(Parameter); # ptr[5] + isGeneric @33 :Bool; # bits[288, 289) + nestedNodes @4 :List(NestedNode); # ptr[1] + annotations @5 :List(Annotation); # ptr[2] + union { # tag bits [96, 112) + file @6 :Void; # bits[0, 0), union tag = 0 + struct :group { # union tag = 1 + dataWordCount @7 :UInt16; # bits[112, 128) + pointerCount @8 :UInt16; # bits[192, 208) + preferredListEncoding @9 :ElementSize; # bits[208, 224) + isGroup @10 :Bool; # bits[224, 225) + discriminantCount @11 :UInt16; # bits[240, 256) + discriminantOffset @12 :UInt32; # bits[256, 288) + fields @13 :List(Field); # ptr[3] + } + enum :group { # union tag = 2 + enumerants @14 :List(Enumerant); # ptr[3] + } + interface :group { # union tag = 3 + methods @15 :List(Method); # ptr[3] + superclasses @31 :List(Superclass); # ptr[4] + } + const :group { # union tag = 4 + type @16 :Type; # ptr[3] + value @17 :Value; # ptr[4] + } + annotation :group { # union tag = 5 + type @18 :Type; # ptr[3] + targetsFile @19 :Bool; # bits[112, 113) + targetsConst @20 :Bool; # bits[113, 114) + targetsEnum @21 :Bool; # bits[114, 115) + targetsEnumerant @22 :Bool; # bits[115, 116) + targetsStruct @23 :Bool; # bits[116, 117) + targetsField @24 :Bool; # bits[117, 118) + targetsUnion @25 :Bool; # bits[118, 119) + targetsGroup @26 :Bool; # bits[119, 120) + targetsInterface @27 :Bool; # bits[120, 121) + targetsMethod @28 :Bool; # bits[121, 122) + targetsParam @29 :Bool; # bits[122, 123) + targetsAnnotation @30 :Bool; # bits[123, 124) + } + } + struct Parameter @0xb9521bccf10fa3b1 { # 0 bytes, 1 ptrs + name @0 :Text; # ptr[0] + } + struct NestedNode @0xdebf55bbfa0fc242 { # 8 bytes, 1 ptrs + name @0 :Text; # ptr[0] + id @1 :UInt64; # bits[0, 64) + } + struct SourceInfo @0xf38e1de3041357ae { # 8 bytes, 2 ptrs + id @0 :UInt64; # bits[0, 64) + docComment @1 :Text; # ptr[0] + members @2 :List(Member); # ptr[1] + struct Member @0xc2ba9038898e1fa2 { # 0 bytes, 1 ptrs + docComment @0 :Text; # ptr[0] + } + } +} +struct Field @0x9aad50a41f4af45f { # 24 bytes, 4 ptrs + name @0 :Text; # ptr[0] + codeOrder @1 :UInt16; # bits[0, 16) + annotations @2 :List(Annotation); # ptr[1] + discriminantValue @3 :UInt16 = 65535; # bits[16, 32) + union { # tag bits [64, 80) + slot :group { # union tag = 0 + offset @4 :UInt32; # bits[32, 64) + type @5 :Type; # ptr[2] + defaultValue @6 :Value; # ptr[3] + hadExplicitDefault @10 :Bool; # bits[128, 129) + } + group :group { # union tag = 1 + typeId @7 :UInt64; # bits[128, 192) + } + } + ordinal :group { + union { # tag bits [80, 96) + implicit @8 :Void; # bits[0, 0), union tag = 0 + explicit @9 :UInt16; # bits[96, 112), union tag = 1 + } + } + const noDiscriminant @0x97b14cbe7cfec712 :UInt16 = 65535; +} +struct Enumerant @0x978a7cebdc549a4d { # 8 bytes, 2 ptrs + name @0 :Text; # ptr[0] + codeOrder @1 :UInt16; # bits[0, 16) + annotations @2 :List(Annotation); # ptr[1] +} +struct Superclass @0xa9962a9ed0a4d7f8 { # 8 bytes, 1 ptrs + id @0 :UInt64; # bits[0, 64) + brand @1 :Brand; # ptr[0] +} +struct Method @0x9500cce23b334d80 { # 24 bytes, 5 ptrs + name @0 :Text; # ptr[0] + codeOrder @1 :UInt16; # bits[0, 16) + implicitParameters @7 :List(Node.Parameter); # ptr[4] + paramStructType @2 :UInt64; # bits[64, 128) + paramBrand @5 :Brand; # ptr[2] + resultStructType @3 :UInt64; # bits[128, 192) + resultBrand @6 :Brand; # ptr[3] + annotations @4 :List(Annotation); # ptr[1] +} +struct Type @0xd07378ede1f9cc60 { # 24 bytes, 1 ptrs + union { # tag bits [0, 16) + void @0 :Void; # bits[0, 0), union tag = 0 + bool @1 :Void; # bits[0, 0), union tag = 1 + int8 @2 :Void; # bits[0, 0), union tag = 2 + int16 @3 :Void; # bits[0, 0), union tag = 3 + int32 @4 :Void; # bits[0, 0), union tag = 4 + int64 @5 :Void; # bits[0, 0), union tag = 5 + uint8 @6 :Void; # bits[0, 0), union tag = 6 + uint16 @7 :Void; # bits[0, 0), union tag = 7 + uint32 @8 :Void; # bits[0, 0), union tag = 8 + uint64 @9 :Void; # bits[0, 0), union tag = 9 + float32 @10 :Void; # bits[0, 0), union tag = 10 + float64 @11 :Void; # bits[0, 0), union tag = 11 + text @12 :Void; # bits[0, 0), union tag = 12 + data @13 :Void; # bits[0, 0), union tag = 13 + list :group { # union tag = 14 + elementType @14 :Type; # ptr[0] + } + enum :group { # union tag = 15 + typeId @15 :UInt64; # bits[64, 128) + brand @21 :Brand; # ptr[0] + } + struct :group { # union tag = 16 + typeId @16 :UInt64; # bits[64, 128) + brand @22 :Brand; # ptr[0] + } + interface :group { # union tag = 17 + typeId @17 :UInt64; # bits[64, 128) + brand @23 :Brand; # ptr[0] + } + anyPointer :group { # union tag = 18 + union { # tag bits [64, 80) + unconstrained :group { # union tag = 0 + union { # tag bits [80, 96) + anyKind @18 :Void; # bits[0, 0), union tag = 0 + struct @25 :Void; # bits[0, 0), union tag = 1 + list @26 :Void; # bits[0, 0), union tag = 2 + capability @27 :Void; # bits[0, 0), union tag = 3 + } + } + parameter :group { # union tag = 1 + scopeId @19 :UInt64; # bits[128, 192) + parameterIndex @20 :UInt16; # bits[80, 96) + } + implicitMethodParameter :group { # union tag = 2 + parameterIndex @24 :UInt16; # bits[80, 96) + } + } + } + } +} +struct Brand @0x903455f06065422b { # 0 bytes, 1 ptrs + scopes @0 :List(Scope); # ptr[0] + struct Scope @0xabd73485a9636bc9 { # 16 bytes, 1 ptrs + scopeId @0 :UInt64; # bits[0, 64) + union { # tag bits [64, 80) + bind @1 :List(Binding); # ptr[0], union tag = 0 + inherit @2 :Void; # bits[0, 0), union tag = 1 + } + } + struct Binding @0xc863cd16969ee7fc { # 8 bytes, 1 ptrs + union { # tag bits [0, 16) + unbound @0 :Void; # bits[0, 0), union tag = 0 + type @1 :Type; # ptr[0], union tag = 1 + } + } +} +struct Value @0xce23dcd2d7b00c9b { # 16 bytes, 1 ptrs + union { # tag bits [0, 16) + void @0 :Void; # bits[0, 0), union tag = 0 + bool @1 :Bool; # bits[16, 17), union tag = 1 + int8 @2 :Int8; # bits[16, 24), union tag = 2 + int16 @3 :Int16; # bits[16, 32), union tag = 3 + int32 @4 :Int32; # bits[32, 64), union tag = 4 + int64 @5 :Int64; # bits[64, 128), union tag = 5 + uint8 @6 :UInt8; # bits[16, 24), union tag = 6 + uint16 @7 :UInt16; # bits[16, 32), union tag = 7 + uint32 @8 :UInt32; # bits[32, 64), union tag = 8 + uint64 @9 :UInt64; # bits[64, 128), union tag = 9 + float32 @10 :Float32; # bits[32, 64), union tag = 10 + float64 @11 :Float64; # bits[64, 128), union tag = 11 + text @12 :Text; # ptr[0], union tag = 12 + data @13 :Data; # ptr[0], union tag = 13 + list @14 :AnyPointer; # ptr[0], union tag = 14 + enum @15 :UInt16; # bits[16, 32), union tag = 15 + struct @16 :AnyPointer; # ptr[0], union tag = 16 + interface @17 :Void; # bits[0, 0), union tag = 17 + anyPointer @18 :AnyPointer; # ptr[0], union tag = 18 + } +} +struct Annotation @0xf1c8950dab257542 { # 8 bytes, 2 ptrs + id @0 :UInt64; # bits[0, 64) + brand @2 :Brand; # ptr[1] + value @1 :Value; # ptr[0] +} +enum ElementSize @0xd1958f7dba521926 { + empty @0; + bit @1; + byte @2; + twoBytes @3; + fourBytes @4; + eightBytes @5; + pointer @6; + inlineComposite @7; +} +struct CapnpVersion @0xd85d305b7d839963 { # 8 bytes, 0 ptrs + major @0 :UInt16; # bits[0, 16) + minor @1 :UInt8; # bits[16, 24) + micro @2 :UInt8; # bits[24, 32) +} +struct CodeGeneratorRequest @0xbfc546f6210ad7ce { # 0 bytes, 4 ptrs + capnpVersion @2 :CapnpVersion; # ptr[2] + nodes @0 :List(Node); # ptr[0] + sourceInfo @3 :List(Node.SourceInfo); # ptr[3] + requestedFiles @1 :List(RequestedFile); # ptr[1] + struct RequestedFile @0xcfea0eb02e810062 { # 8 bytes, 2 ptrs + id @0 :UInt64; # bits[0, 64) + filename @1 :Text; # ptr[0] + imports @2 :List(Import); # ptr[1] + struct Import @0xae504193122357e5 { # 8 bytes, 1 ptrs + id @0 :UInt64; # bits[0, 64) + name @1 :Text; # ptr[0] + } + } +} diff --git a/capnpc-csharp/capnpc-csharp.csproj b/capnpc-csharp/capnpc-csharp.csproj new file mode 100644 index 0000000..76ee9e5 --- /dev/null +++ b/capnpc-csharp/capnpc-csharp.csproj @@ -0,0 +1,23 @@ + + + + Exe + netcoreapp2.1 + CapnpC + 7.1 + + + + + + + + + + + + + + + +