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<Capnproto_test.Capnp.Test.TestAllTypes>(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<Capnproto_test.Capnp.Test.TestAllTypes>(_));
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<WRITER>());
}
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<byte> 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<bool> BoolList
{
get;
set;
}
public IReadOnlyList<sbyte> Int8List
{
get;
set;
}
public IReadOnlyList<short> Int16List
{
get;
set;
}
public IReadOnlyList<int> Int32List
{
get;
set;
}
public IReadOnlyList<long> Int64List
{
get;
set;
}
public IReadOnlyList<byte> UInt8List
{
get;
set;
}
public IReadOnlyList<ushort> UInt16List
{
get;
set;
}
public IReadOnlyList<uint> UInt32List
{
get;
set;
}
public IReadOnlyList<ulong> UInt64List
{
get;
set;
}
public IReadOnlyList<float> Float32List
{
get;
set;
}
public IReadOnlyList<double> Float64List
{
get;
set;
}
public IReadOnlyList<string> TextList
{
get;
set;
}
public IReadOnlyList<IReadOnlyList<byte>> DataList
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes> StructList
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestEnum> 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<byte> 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<bool> BoolList => ctx.ReadList(4).CastBool();
public IReadOnlyList<sbyte> Int8List => ctx.ReadList(5).CastSByte();
public IReadOnlyList<short> Int16List => ctx.ReadList(6).CastShort();
public IReadOnlyList<int> Int32List => ctx.ReadList(7).CastInt();
public IReadOnlyList<long> Int64List => ctx.ReadList(8).CastLong();
public IReadOnlyList<byte> UInt8List => ctx.ReadList(9).CastByte();
public IReadOnlyList<ushort> UInt16List => ctx.ReadList(10).CastUShort();
public IReadOnlyList<uint> UInt32List => ctx.ReadList(11).CastUInt();
public IReadOnlyList<ulong> UInt64List => ctx.ReadList(12).CastULong();
public IReadOnlyList<float> Float32List => ctx.ReadList(13).CastFloat();
public IReadOnlyList<double> Float64List => ctx.ReadList(14).CastDouble();
public IReadOnlyList<string> TextList => ctx.ReadList(15).CastText2();
public IReadOnlyList<IReadOnlyList<byte>> DataList => ctx.ReadList(16).CastData();
public IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes.READER> StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestEnum> 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<byte> DataField
{
get => BuildPointer<ListOfPrimitivesSerializer<byte>>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>(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<ListOfEmptySerializer>(3);
set => Link(3, value);
}
public ListOfBitsSerializer BoolList
{
get => BuildPointer<ListOfBitsSerializer>(4);
set => Link(4, value);
}
public ListOfPrimitivesSerializer<sbyte> Int8List
{
get => BuildPointer<ListOfPrimitivesSerializer<sbyte>>(5);
set => Link(5, value);
}
public ListOfPrimitivesSerializer<short> Int16List
{
get => BuildPointer<ListOfPrimitivesSerializer<short>>(6);
set => Link(6, value);
}
public ListOfPrimitivesSerializer<int> Int32List
{
get => BuildPointer<ListOfPrimitivesSerializer<int>>(7);
set => Link(7, value);
}
public ListOfPrimitivesSerializer<long> Int64List
{
get => BuildPointer<ListOfPrimitivesSerializer<long>>(8);
set => Link(8, value);
}
public ListOfPrimitivesSerializer<byte> UInt8List
{
get => BuildPointer<ListOfPrimitivesSerializer<byte>>(9);
set => Link(9, value);
}
public ListOfPrimitivesSerializer<ushort> UInt16List
{
get => BuildPointer<ListOfPrimitivesSerializer<ushort>>(10);
set => Link(10, value);
}
public ListOfPrimitivesSerializer<uint> UInt32List
{
get => BuildPointer<ListOfPrimitivesSerializer<uint>>(11);
set => Link(11, value);
}
public ListOfPrimitivesSerializer<ulong> UInt64List
{
get => BuildPointer<ListOfPrimitivesSerializer<ulong>>(12);
set => Link(12, value);
}
public ListOfPrimitivesSerializer<float> Float32List
{
get => BuildPointer<ListOfPrimitivesSerializer<float>>(13);
set => Link(13, value);
}
public ListOfPrimitivesSerializer<double> Float64List
{
get => BuildPointer<ListOfPrimitivesSerializer<double>>(14);
set => Link(14, value);
}
public ListOfTextSerializer TextList
{
get => BuildPointer<ListOfTextSerializer>(15);
set => Link(15, value);
}
public ListOfPointersSerializer<ListOfPrimitivesSerializer<byte>> DataList
{
get => BuildPointer<ListOfPointersSerializer<ListOfPrimitivesSerializer<byte>>>(16);
set => Link(16, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER> StructList
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>>(17);
set => Link(17, value);
}
public ListOfPrimitivesSerializer<Capnproto_test.Capnp.Test.TestEnum> EnumList
{
get => BuildPointer<ListOfPrimitivesSerializer<Capnproto_test.Capnp.Test.TestEnum>>(18);
set => Link(18, value);
}
public ListOfEmptySerializer InterfaceList
{
get => BuildPointer<ListOfEmptySerializer>(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<Capnproto_test.Capnp.Test.TestAllTypes>(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<Capnproto_test.Capnp.Test.TestAllTypes>(_));
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<WRITER>());
}
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<byte>[]{}, 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<byte>[]{}, 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<byte>[]{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<byte>[]{}, 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<byte>[]{}, 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<byte>[]{}, 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<byte>[]{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<byte>[]{}, 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<byte>[]{}, 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<byte>[]{}, 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<byte> 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<bool> BoolList
{
get;
set;
}
public IReadOnlyList<sbyte> Int8List
{
get;
set;
}
public IReadOnlyList<short> Int16List
{
get;
set;
}
public IReadOnlyList<int> Int32List
{
get;
set;
}
public IReadOnlyList<long> Int64List
{
get;
set;
}
public IReadOnlyList<byte> UInt8List
{
get;
set;
}
public IReadOnlyList<ushort> UInt16List
{
get;
set;
}
public IReadOnlyList<uint> UInt32List
{
get;
set;
}
public IReadOnlyList<ulong> UInt64List
{
get;
set;
}
public IReadOnlyList<float> Float32List
{
get;
set;
}
public IReadOnlyList<double> Float64List
{
get;
set;
}
public IReadOnlyList<string> TextList
{
get;
set;
}
public IReadOnlyList<IReadOnlyList<byte>> DataList
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes> StructList
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestEnum> 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<byte> 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<bool> BoolList => ctx.ReadList(4).CastBool();
public IReadOnlyList<sbyte> Int8List => ctx.ReadList(5).CastSByte();
public IReadOnlyList<short> Int16List => ctx.ReadList(6).CastShort();
public IReadOnlyList<int> Int32List => ctx.ReadList(7).CastInt();
public IReadOnlyList<long> Int64List => ctx.ReadList(8).CastLong();
public IReadOnlyList<byte> UInt8List => ctx.ReadList(9).CastByte();
public IReadOnlyList<ushort> UInt16List => ctx.ReadList(10).CastUShort();
public IReadOnlyList<uint> UInt32List => ctx.ReadList(11).CastUInt();
public IReadOnlyList<ulong> UInt64List => ctx.ReadList(12).CastULong();
public IReadOnlyList<float> Float32List => ctx.ReadList(13).CastFloat();
public IReadOnlyList<double> Float64List => ctx.ReadList(14).CastDouble();
public IReadOnlyList<string> TextList => ctx.ReadList(15).CastText2();
public IReadOnlyList<IReadOnlyList<byte>> DataList => ctx.ReadList(16).CastData();
public IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes.READER> StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestEnum> 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<byte> DataField
{
get => BuildPointer<ListOfPrimitivesSerializer<byte>>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>(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<ListOfEmptySerializer>(3);
set => Link(3, value);
}
public ListOfBitsSerializer BoolList
{
get => BuildPointer<ListOfBitsSerializer>(4);
set => Link(4, value);
}
public ListOfPrimitivesSerializer<sbyte> Int8List
{
get => BuildPointer<ListOfPrimitivesSerializer<sbyte>>(5);
set => Link(5, value);
}
public ListOfPrimitivesSerializer<short> Int16List
{
get => BuildPointer<ListOfPrimitivesSerializer<short>>(6);
set => Link(6, value);
}
public ListOfPrimitivesSerializer<int> Int32List
{
get => BuildPointer<ListOfPrimitivesSerializer<int>>(7);
set => Link(7, value);
}
public ListOfPrimitivesSerializer<long> Int64List
{
get => BuildPointer<ListOfPrimitivesSerializer<long>>(8);
set => Link(8, value);
}
public ListOfPrimitivesSerializer<byte> UInt8List
{
get => BuildPointer<ListOfPrimitivesSerializer<byte>>(9);
set => Link(9, value);
}
public ListOfPrimitivesSerializer<ushort> UInt16List
{
get => BuildPointer<ListOfPrimitivesSerializer<ushort>>(10);
set => Link(10, value);
}
public ListOfPrimitivesSerializer<uint> UInt32List
{
get => BuildPointer<ListOfPrimitivesSerializer<uint>>(11);
set => Link(11, value);
}
public ListOfPrimitivesSerializer<ulong> UInt64List
{
get => BuildPointer<ListOfPrimitivesSerializer<ulong>>(12);
set => Link(12, value);
}
public ListOfPrimitivesSerializer<float> Float32List
{
get => BuildPointer<ListOfPrimitivesSerializer<float>>(13);
set => Link(13, value);
}
public ListOfPrimitivesSerializer<double> Float64List
{
get => BuildPointer<ListOfPrimitivesSerializer<double>>(14);
set => Link(14, value);
}
public ListOfTextSerializer TextList
{
get => BuildPointer<ListOfTextSerializer>(15);
set => Link(15, value);
}
public ListOfPointersSerializer<ListOfPrimitivesSerializer<byte>> DataList
{
get => BuildPointer<ListOfPointersSerializer<ListOfPrimitivesSerializer<byte>>>(16);
set => Link(16, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER> StructList
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>>(17);
set => Link(17, value);
}
public ListOfPrimitivesSerializer<Capnproto_test.Capnp.Test.TestEnum> EnumList
{
get => BuildPointer<ListOfPrimitivesSerializer<Capnproto_test.Capnp.Test.TestEnum>>(18);
set => Link(18, value);
}
public ListOfEmptySerializer InterfaceList
{
get => BuildPointer<ListOfEmptySerializer>(19);
set => Link(19, value);
}
}
}
public class TestAnyPointer : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
AnyPointerField = CapnpSerializable.Create<AnyPointer>(reader.AnyPointerField);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.AnyPointerField.SetObject(AnyPointerField);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
}
}
public class TestAnyOthers : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
AnyStructField = CapnpSerializable.Create<AnyPointer>(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<WRITER>());
}
public void applyDefaults()
{
}
public AnyPointer AnyStructField
{
get;
set;
}
public IReadOnlyList<object> 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<DeserializerState> AnyListField => (IReadOnlyList<DeserializerState>)ctx.ReadList(1);
public BareProxy CapabilityField => ctx.ReadCap(2);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 3);
}
public DynamicSerializerState AnyStructField
{
get => BuildPointer<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState AnyListField
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
public BareProxy CapabilityField
{
get => ReadCap<BareProxy>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestUnion.@union0>(reader.Union0);
Union1 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnion.@union1>(reader.Union1);
Union2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnion.@union2>(reader.Union2);
Union3 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnion.@union3>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestUnionInUnion.@outer>(reader.Outer);
applyDefaults();
}
public void serialize(WRITER writer)
{
Outer?.serialize(writer.Outer);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestUnionInUnion.@outer.@inner>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestGroups.@groups>(reader.Groups);
applyDefaults();
}
public void serialize(WRITER writer)
{
Groups?.serialize(writer.Groups);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestGroups.@groups.@foo>(reader.Foo);
break;
case WHICH.Baz:
Baz = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGroups.@groups.@baz>(reader.Baz);
break;
case WHICH.Bar:
Bar = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGroups.@groups.@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 = 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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1>(reader.Group1);
Group2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2>(reader.Group2);
applyDefaults();
}
public void serialize(WRITER writer)
{
Group1?.serialize(writer.Group1);
Group2?.serialize(writer.Group2);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1.@corge>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2.@corge>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestUnion>(reader.S16s8s64s8Set);
S0sps1s32Set = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnion>(reader.S0sps1s32Set);
Unnamed1 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnnamedUnion>(reader.Unnamed1);
Unnamed2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUnnamedUnion>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestUnion.WRITER>(0);
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestUnion.WRITER S0sps1s32Set
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestUnion.WRITER>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed1
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER>(2);
set => Link(2, value);
}
public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed2
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER>(3);
set => Link(3, value);
}
}
}
public class TestNestedTypes : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
TheNestedStruct = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.WRITER>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestLists.Struct0>(_));
List1 = reader.List1.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.Struct1>(_));
List8 = reader.List8.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.Struct8>(_));
List16 = reader.List16.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.Struct16>(_));
List32 = reader.List32.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.Struct32>(_));
List64 = reader.List64.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.Struct64>(_));
ListP = reader.ListP.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLists.StructP>(_));
Int32ListList = reader.Int32ListList;
TextListList = reader.TextListList;
StructListList = reader.StructListList.ToReadOnlyList(_2 => _2.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAllTypes>(_)));
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<WRITER>());
}
public void applyDefaults()
{
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct0> List0
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct1> List1
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct8> List8
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct16> List16
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct32> List32
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct64> List64
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.StructP> ListP
{
get;
set;
}
public IReadOnlyList<IReadOnlyList<int>> Int32ListList
{
get;
set;
}
public IReadOnlyList<IReadOnlyList<string>> TextListList
{
get;
set;
}
public IReadOnlyList<IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes>> 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<Capnproto_test.Capnp.Test.TestLists.Struct0.READER> List0 => ctx.ReadList(0).Cast(Capnproto_test.Capnp.Test.TestLists.Struct0.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct1.READER> List1 => ctx.ReadList(1).Cast(Capnproto_test.Capnp.Test.TestLists.Struct1.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct8.READER> List8 => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestLists.Struct8.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct16.READER> List16 => ctx.ReadList(3).Cast(Capnproto_test.Capnp.Test.TestLists.Struct16.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct32.READER> List32 => ctx.ReadList(4).Cast(Capnproto_test.Capnp.Test.TestLists.Struct32.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.Struct64.READER> List64 => ctx.ReadList(5).Cast(Capnproto_test.Capnp.Test.TestLists.Struct64.READER.create);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestLists.StructP.READER> ListP => ctx.ReadList(6).Cast(Capnproto_test.Capnp.Test.TestLists.StructP.READER.create);
public IReadOnlyList<IReadOnlyList<int>> Int32ListList => ctx.ReadList(7).Cast(_0 => _0.RequireList().CastInt());
public IReadOnlyList<IReadOnlyList<string>> TextListList => ctx.ReadList(8).Cast(_0 => _0.RequireList().CastText2());
public IReadOnlyList<IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes.READER>> 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<Capnproto_test.Capnp.Test.TestLists.Struct0.WRITER> List0
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct0.WRITER>>(0);
set => Link(0, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct1.WRITER> List1
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct1.WRITER>>(1);
set => Link(1, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct8.WRITER> List8
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct8.WRITER>>(2);
set => Link(2, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct16.WRITER> List16
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct16.WRITER>>(3);
set => Link(3, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct32.WRITER> List32
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct32.WRITER>>(4);
set => Link(4, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct64.WRITER> List64
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.Struct64.WRITER>>(5);
set => Link(5, value);
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.StructP.WRITER> ListP
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestLists.StructP.WRITER>>(6);
set => Link(6, value);
}
public ListOfPointersSerializer<ListOfPrimitivesSerializer<int>> Int32ListList
{
get => BuildPointer<ListOfPointersSerializer<ListOfPrimitivesSerializer<int>>>(7);
set => Link(7, value);
}
public ListOfPointersSerializer<ListOfTextSerializer> TextListList
{
get => BuildPointer<ListOfPointersSerializer<ListOfTextSerializer>>(8);
set => Link(8, value);
}
public ListOfPointersSerializer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>> StructListList
{
get => BuildPointer<ListOfPointersSerializer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>>>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestLists>(reader.Lists);
applyDefaults();
}
public void serialize(WRITER writer)
{
Lists?.serialize(writer.Lists);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<int>[]{new int[]{1, 2, 3}, new int[]{4, 5}, new int[]{12341234}}, TextListList = new IReadOnlyList<string>[]{new string[]{"foo", "bar"}, new string[]{"baz"}, new string[]{"qux", "corge"}}, StructListList = new IReadOnlyList<Capnproto_test.Capnp.Test.TestAllTypes>[]{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<byte>[]{}, 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<byte>[]{}, 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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestLists.WRITER>(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<Capnproto_test.Capnp.Test.TestLateUnion.@theUnion>(reader.TheUnion);
AnotherUnion = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestLateUnion.@anotherUnion>(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<WRITER>());
}
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<WRITER>());
}
public void applyDefaults()
{
}
public string Qux
{
get => _which == WHICH.Qux ? (string)_content : null;
set
{
_which = WHICH.Qux;
_content = value;
}
}
public IReadOnlyList<int> Corge
{
get => _which == WHICH.Corge ? (IReadOnlyList<int>)_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<int> 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<int> Corge
{
get => which == WHICH.Corge ? BuildPointer<ListOfPrimitivesSerializer<int>>(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<WRITER>());
}
public void applyDefaults()
{
}
public string Qux
{
get => _which == WHICH.Qux ? (string)_content : null;
set
{
_which = WHICH.Qux;
_content = value;
}
}
public IReadOnlyList<int> Corge
{
get => _which == WHICH.Corge ? (IReadOnlyList<int>)_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<int> 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<int> Corge
{
get => which == WHICH.Corge ? BuildPointer<ListOfPrimitivesSerializer<int>>(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<Capnproto_test.Capnp.Test.TestOldVersion>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestOldVersion.WRITER>(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<Capnproto_test.Capnp.Test.TestNewVersion>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNewVersion.WRITER>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNewUnionVersion.@a>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestStructUnion.@un>(reader.Un);
applyDefaults();
}
public void serialize(WRITER writer)
{
Un?.serialize(writer.Un);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct>(reader.Struct);
break;
case WHICH.Object:
Object = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAnyPointer>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.WRITER>(0) : default;
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestAnyPointer.WRITER Object
{
get => which == WHICH.Object ? BuildPointer<Capnproto_test.Capnp.Test.TestAnyPointer.WRITER>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct>(_));
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<WRITER>());
}
public void applyDefaults()
{
}
public string SomeText
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct> 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<Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct.READER> 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<Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct.WRITER> StructList
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct.WRITER>>(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<WRITER>());
}
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<WRITER>());
}
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<TFoo, TBar> : 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<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.@ug>(reader.Ug);
break;
}
Foo = CapnpSerializable.Create<TFoo>(reader.Foo);
Rev = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TBar, TFoo>>(reader.Rev);
List = reader.List.ToReadOnlyList(_ => CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<WRITER>());
}
public void applyDefaults()
{
}
public TFoo Foo
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TBar, TFoo> Rev
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.@ug Ug
{
get => _which == WHICH.Ug ? (Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.@ug)_content : null;
set
{
_which = WHICH.Ug;
_content = value;
}
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<TBar, TFoo>.READER Rev => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics<TBar, TFoo>.READER.create);
public @ug.READER Ug => which == WHICH.Ug ? new @ug.READER(ctx) : default;
public IReadOnlyList<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.READER> List => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<DynamicSerializerState>(0);
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TBar, TFoo>.WRITER Rev
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TBar, TFoo>.WRITER>(1);
set => Link(1, value);
}
public @ug.WRITER Ug
{
get => which == WHICH.Ug ? Rewrap<@ug.WRITER>() : default;
}
public ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER> List
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<WRITER>());
}
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<TFoo>(reader.Foo);
Bar = CapnpSerializable.Create<TBar>(reader.Bar);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.Foo.SetObject(Foo);
writer.Bar.SetObject(Bar);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState Bar
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
}
}
public class Inner2<TBaz> : ICapnpSerializable where TBaz : class
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Bar = CapnpSerializable.Create<TBar>(reader.Bar);
Baz = CapnpSerializable.Create<TBaz>(reader.Baz);
InnerBound = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner>(reader.InnerBound);
InnerUnbound = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<WRITER>());
}
public void applyDefaults()
{
}
public TBar Bar
{
get;
set;
}
public TBaz Baz
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner InnerBound
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.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<TFoo, TBar>.Inner.READER InnerBound => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.READER InnerUnbound => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.READER.create);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 4);
}
public DynamicSerializerState Bar
{
get => BuildPointer<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState Baz
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER InnerBound
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER>(2);
set => Link(2, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER InnerUnbound
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER>(3);
set => Link(3, value);
}
}
public class DeepNest<TQux> : ICapnpSerializable where TQux : class
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Foo = CapnpSerializable.Create<TFoo>(reader.Foo);
Bar = CapnpSerializable.Create<TBar>(reader.Bar);
Baz = CapnpSerializable.Create<TBaz>(reader.Baz);
Qux = CapnpSerializable.Create<TQux>(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<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState Bar
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
public DynamicSerializerState Baz
{
get => BuildPointer<DynamicSerializerState>(2);
set => Link(2, value);
}
public DynamicSerializerState Qux
{
get => BuildPointer<DynamicSerializerState>(3);
set => Link(3, value);
}
}
[Proxy(typeof(DeepNestInterfaceProxy<>)), Skeleton(typeof(DeepNestInterfaceSkeleton<>))]
public interface IDeepNestInterface<TQuux> : IDisposable
{
Task Call(CancellationToken cancellationToken_ = default);
}
public class DeepNestInterfaceProxy<TQuux> : Proxy, IDeepNestInterface<TQuux> where TQuux : class
{
public async Task Call(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<TBaz>.DeepNest<TQux>.DeepNestInterface<TQuux>.Params_call.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<TBaz>.DeepNest<TQux>.DeepNestInterface<TQuux>.Params_call()
{};
arg_.serialize(in_);
var d_ = await Call(9816138025992274567UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<TBaz>.DeepNest<TQux>.DeepNestInterface<TQuux>.Result_call>(d_);
return;
}
}
public class DeepNestInterfaceSkeleton<TQuux> : Skeleton<IDeepNestInterface<TQuux>> where TQuux : class
{
public DeepNestInterfaceSkeleton()
{
SetMethodTable(Call);
}
public override ulong InterfaceId => 9816138025992274567UL;
async Task<AnswerOrCounterquestion> Call(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Call(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<TBaz>.DeepNest<TQux>.DeepNestInterface<TQuux>.Result_call.WRITER>();
return s_;
}
}
public static class DeepNestInterface<TQuux>
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<WRITER>());
}
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<WRITER>());
}
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<TQux> : IDisposable
{
Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>)> Call(Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string> arg_, CancellationToken cancellationToken_ = default);
}
public class InterfaceProxy<TQux> : Proxy, IInterface<TQux> where TQux : class
{
public Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>)> Call(Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string> arg_, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.WRITER>();
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(14548678385738242652UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Interface<TQux>.Result_call>(d_);
return (r_.Qux, r_.Gen);
}
);
}
}
public class InterfaceSkeleton<TQux> : Skeleton<IInterface<TQux>> where TQux : class
{
public InterfaceSkeleton()
{
SetMethodTable(Call);
}
public override ulong InterfaceId => 14548678385738242652UL;
Task<AnswerOrCounterquestion> Call(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.Call(CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>>(d_), cancellationToken_), (qux, gen) =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Interface<TQux>.Result_call.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Interface<TQux>.Result_call{Qux = qux, Gen = gen};
r_.serialize(s_);
return s_;
}
);
}
}
public static class Interface<TQux>
where TQux : class
{
public class Result_call : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Qux = CapnpSerializable.Create<TQux>(reader.Qux);
Gen = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>>(reader.Gen);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.Qux.SetObject(Qux);
Gen?.serialize(writer.Gen);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
public void applyDefaults()
{
}
public TQux Qux
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer> 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER Gen => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER.create);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 2);
}
public DynamicSerializerState Qux
{
get => BuildPointer<DynamicSerializerState>(0);
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER Gen
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER>(1);
set => Link(1, value);
}
}
}
}
public class UseAliases : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Foo = CapnpSerializable.Create<TFoo>(reader.Foo);
Inner = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner>(reader.Inner);
Inner2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer>>(reader.Inner2);
Inner2Bind = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>>(reader.Inner2Bind);
Inner2Text = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>>(reader.Inner2Text);
RevFoo = CapnpSerializable.Create<TBar>(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<WRITER>());
}
public void applyDefaults()
{
}
public TFoo Foo
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner Inner
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer> Inner2
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string> Inner2Bind
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string> 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<TFoo, TBar>.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer>.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.READER Inner2Bind => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.READER Inner2Text => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.READER.create);
public DeserializerState RevFoo => ctx.StructReadPointer(5);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 6);
}
public DynamicSerializerState Foo
{
get => BuildPointer<DynamicSerializerState>(0);
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER Inner
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner.WRITER>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer>.WRITER Inner2
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<AnyPointer>.WRITER>(2);
set => Link(2, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.WRITER Inner2Bind
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.WRITER>(3);
set => Link(3, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.WRITER Inner2Text
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.Inner2<string>.WRITER>(4);
set => Link(4, value);
}
public DynamicSerializerState RevFoo
{
get => BuildPointer<DynamicSerializerState>(5);
set => Link(5, value);
}
}
}
}
public class TestGenericsWrapper<TFoo, TBar> : ICapnpSerializable where TFoo : class where TBar : class
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Value = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>>(reader.Value);
applyDefaults();
}
public void serialize(WRITER writer)
{
Value?.serialize(writer.Value);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
public void applyDefaults()
{
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar> 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<TFoo, TBar>.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.READER.create);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.WRITER Value
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<TFoo, TBar>.WRITER>(0);
set => Link(0, value);
}
}
}
public class TestGenericsWrapper2 : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Value = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>>(reader.Value);
applyDefaults();
}
public void serialize(WRITER writer)
{
Value?.serialize(writer.Value);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
public void applyDefaults()
{
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes> 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<string, Capnproto_test.Capnp.Test.TestAllTypes>.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.READER.create);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.WRITER Value
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.WRITER>(0);
set => Link(0, value);
}
}
}
[Proxy(typeof(TestImplicitMethodParamsProxy)), Skeleton(typeof(TestImplicitMethodParamsSkeleton))]
public interface ITestImplicitMethodParams : IDisposable
{
Task<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>> Call<TT, TU>(TT foo, TU bar, CancellationToken cancellationToken_ = default)
where TT : class where TU : class;
}
public class TestImplicitMethodParamsProxy : Proxy, ITestImplicitMethodParams
{
public Task<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>> Call<TT, TU>(TT foo, TU bar, CancellationToken cancellationToken_ = default)
where TT : class where TU : class
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestImplicitMethodParams.Params_call<TT, TU>.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParams.Params_call<TT, TU>()
{Foo = foo, Bar = bar};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(10058534285777328794UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>>(d_);
return r_;
}
);
}
}
public class TestImplicitMethodParamsSkeleton : Skeleton<ITestImplicitMethodParams>
{
public TestImplicitMethodParamsSkeleton()
{
SetMethodTable(Call<AnyPointer, AnyPointer>);
}
public override ulong InterfaceId => 10058534285777328794UL;
Task<AnswerOrCounterquestion> Call<TT, TU>(DeserializerState d_, CancellationToken cancellationToken_)
where TT : class where TU : class
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestImplicitMethodParams.Params_call<TT, TU>>(d_);
return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>.WRITER>();
r_.serialize(s_);
return s_;
}
);
}
}
public static class TestImplicitMethodParams
{
public class Params_call<TT, TU> : ICapnpSerializable where TT : class where TU : class
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Foo = CapnpSerializable.Create<TT>(reader.Foo);
Bar = CapnpSerializable.Create<TU>(reader.Bar);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.Foo.SetObject(Foo);
writer.Bar.SetObject(Bar);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState Bar
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
}
}
}
[Proxy(typeof(TestImplicitMethodParamsInGenericProxy<>)), Skeleton(typeof(TestImplicitMethodParamsInGenericSkeleton<>))]
public interface ITestImplicitMethodParamsInGeneric<TV> : IDisposable
{
Task<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>> Call<TT, TU>(TT foo, TU bar, CancellationToken cancellationToken_ = default)
where TT : class where TU : class;
}
public class TestImplicitMethodParamsInGenericProxy<TV> : Proxy, ITestImplicitMethodParamsInGeneric<TV> where TV : class
{
public Task<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>> Call<TT, TU>(TT foo, TU bar, CancellationToken cancellationToken_ = default)
where TT : class where TU : class
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestImplicitMethodParamsInGeneric<TV>.Params_call<TT, TU>.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParamsInGeneric<TV>.Params_call<TT, TU>()
{Foo = foo, Bar = bar};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(16112979978201007305UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>>(d_);
return r_;
}
);
}
}
public class TestImplicitMethodParamsInGenericSkeleton<TV> : Skeleton<ITestImplicitMethodParamsInGeneric<TV>> where TV : class
{
public TestImplicitMethodParamsInGenericSkeleton()
{
SetMethodTable(Call<AnyPointer, AnyPointer>);
}
public override ulong InterfaceId => 16112979978201007305UL;
Task<AnswerOrCounterquestion> Call<TT, TU>(DeserializerState d_, CancellationToken cancellationToken_)
where TT : class where TU : class
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestImplicitMethodParamsInGeneric<TV>.Params_call<TT, TU>>(d_);
return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestGenerics<TT, TU>.WRITER>();
r_.serialize(s_);
return s_;
}
);
}
}
public static class TestImplicitMethodParamsInGeneric<TV>
where TV : class
{
public class Params_call<TT, TU> : ICapnpSerializable where TT : class where TU : class
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Foo = CapnpSerializable.Create<TT>(reader.Foo);
Bar = CapnpSerializable.Create<TU>(reader.Bar);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.Foo.SetObject(Foo);
writer.Bar.SetObject(Bar);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState Bar
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
}
}
}
public class TestGenericsUnion<TFoo, TBar> : 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<TFoo>(reader.Foo);
break;
case WHICH.Bar:
Bar = CapnpSerializable.Create<TBar>(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<WRITER>());
}
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<DynamicSerializerState>(0) : default;
set => Link(0, value);
}
public DynamicSerializerState Bar
{
get => which == WHICH.Bar ? BuildPointer<DynamicSerializerState>(0) : default;
set => Link(0, value);
}
}
}
public class TestUseGenerics : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Basic = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>>(reader.Basic);
Inner = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner>(reader.Inner);
Inner2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>>(reader.Inner2);
Unspecified = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>>(reader.Unspecified);
UnspecifiedInner = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>>(reader.UnspecifiedInner);
Default = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>>(reader.Default);
DefaultInner = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner>(reader.DefaultInner);
DefaultUser = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestUseGenerics>(reader.DefaultUser);
Wrapper = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>>(reader.Wrapper);
DefaultWrapper = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>>(reader.DefaultWrapper);
DefaultWrapper2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenericsWrapper2>(reader.DefaultWrapper2);
AliasFoo = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAllTypes>(reader.AliasFoo);
AliasInner = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner>(reader.AliasInner);
AliasInner2 = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>>(reader.AliasInner2);
AliasInner2Bind = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>>(reader.AliasInner2Bind);
AliasInner2Text = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>>(reader.AliasInner2Text);
AliasRev = reader.AliasRev;
UseAliases = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases>(reader.UseAliases);
Cap = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>>(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<WRITER>());
}
public void applyDefaults()
{
Default = Default ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>()
{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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>()
{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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{}, List = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner[]{}};
DefaultInner = DefaultInner ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>()
{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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAnyPointer, Capnproto_test.Capnp.Test.TestAllTypes>()
{}, List = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner[]{}}, Inner = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner()
{}, Inner2 = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>()
{}, Unspecified = new Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>()
{}, UnspecifiedInner = new Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>()
{}, Default = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>()
{}, DefaultInner = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner()
{}, DefaultUser = new Capnproto_test.Capnp.Test.TestUseGenerics()
{}, Wrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>()
{}, DefaultWrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{}, DefaultWrapper2 = new Capnproto_test.Capnp.Test.TestGenericsWrapper2()
{}, AliasFoo = new Capnproto_test.Capnp.Test.TestAllTypes()
{}, AliasInner = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner()
{}, AliasInner2 = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>()
{}, AliasInner2Bind = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>()
{}, AliasInner2Text = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>()
{}, AliasRev = null, UseAliases = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases()
{}, Cap = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>()
{}};
DefaultWrapper = DefaultWrapper ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{Value = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>()
{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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{}, List = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>.Inner[]{}}};
DefaultWrapper2 = DefaultWrapper2 ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper2()
{Value = new Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{Value = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>()
{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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>()
{}, List = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics<string, Capnproto_test.Capnp.Test.TestAllTypes>.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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0};
AliasInner = AliasInner ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>()
{Bar = new Capnproto_test.Capnp.Test.TestAnyPointer()
{}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner()
{}};
AliasInner2Bind = AliasInner2Bind ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>()
{Bar = new Capnproto_test.Capnp.Test.TestAnyPointer()
{}, Baz = new uint[]{12U, 34U}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner()
{}};
AliasInner2Text = AliasInner2Text ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>()
{Bar = new Capnproto_test.Capnp.Test.TestAnyPointer()
{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner()
{}};
AliasRev = AliasRev ?? "text";
UseAliases = UseAliases ?? new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.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<byte>[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Inner = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner2<AnyPointer>()
{Bar = new uint[]{}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner()
{}}, Inner2Bind = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner2<string>()
{Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner()
{}}, Inner2Text = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner2<string>()
{Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.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<byte>[]{}, 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<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.Inner()
{}}, RevFoo = new uint[]{12U, 34U, 56U}};
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer> Basic
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner Inner
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string> Inner2
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer> Unspecified
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string> UnspecifiedInner
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string> Default
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner DefaultInner
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestUseGenerics DefaultUser
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer> Wrapper
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes> 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner AliasInner
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer> AliasInner2
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>> AliasInner2Bind
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string> AliasInner2Text
{
get;
set;
}
public string AliasRev
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases UseAliases
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string> Cap
{
get;
set;
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.IInterface<IReadOnlyList<byte>> 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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER Basic => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.READER Unspecified => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>.READER UnspecifiedInner => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.READER Default => ctx.ReadStruct(5, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner.READER DefaultInner => ctx.ReadStruct(6, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER Wrapper => ctx.ReadStruct(8, Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.READER.create);
public Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.READER DefaultWrapper => ctx.ReadStruct(9, Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.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<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.READER AliasInner => ctx.ReadStruct(12, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>.READER AliasInner2 => ctx.ReadStruct(13, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>.READER AliasInner2Bind => ctx.ReadStruct(14, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.READER AliasInner2Text => ctx.ReadStruct(15, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.READER.create);
public string AliasRev => ctx.ReadText(16, "text");
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases.READER UseAliases => ctx.ReadStruct(17, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>.READER Cap => ctx.ReadStruct(18, Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>.READER.create);
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.IInterface<IReadOnlyList<byte>> GenericCap => ctx.ReadCap<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.IInterface<IReadOnlyList<byte>>>(19);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 20);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER Basic
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER>(0);
set => Link(0, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.WRITER Inner
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.WRITER>(1);
set => Link(1, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.WRITER Inner2
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.WRITER>(2);
set => Link(2, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.WRITER Unspecified
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.WRITER>(3);
set => Link(3, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>.WRITER UnspecifiedInner
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<AnyPointer, AnyPointer>.Inner2<string>.WRITER>(4);
set => Link(4, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.WRITER Default
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.WRITER>(5);
set => Link(5, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner.WRITER DefaultInner
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, string>.Inner.WRITER>(6);
set => Link(6, value);
}
public Capnproto_test.Capnp.Test.TestUseGenerics.WRITER DefaultUser
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestUseGenerics.WRITER>(7);
set => Link(7, value);
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER Wrapper
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenericsWrapper<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.WRITER>(8);
set => Link(8, value);
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.WRITER DefaultWrapper
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenericsWrapper<string, Capnproto_test.Capnp.Test.TestAllTypes>.WRITER>(9);
set => Link(9, value);
}
public Capnproto_test.Capnp.Test.TestGenericsWrapper2.WRITER DefaultWrapper2
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenericsWrapper2.WRITER>(10);
set => Link(10, value);
}
public Capnproto_test.Capnp.Test.TestAllTypes.WRITER AliasFoo
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>(11);
set => Link(11, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.WRITER AliasInner
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner.WRITER>(12);
set => Link(12, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>.WRITER AliasInner2
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<AnyPointer>.WRITER>(13);
set => Link(13, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>.WRITER AliasInner2Bind
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<IReadOnlyList<uint>>.WRITER>(14);
set => Link(14, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.WRITER AliasInner2Text
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, Capnproto_test.Capnp.Test.TestAnyPointer>.Inner2<string>.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<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases.WRITER UseAliases
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.UseAliases.WRITER>(17);
set => Link(17, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>.WRITER Cap
{
get => BuildPointer<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.ITestInterface, string>.WRITER>(18);
set => Link(18, value);
}
public Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.IInterface<IReadOnlyList<byte>> GenericCap
{
get => ReadCap<Capnproto_test.Capnp.Test.TestGenerics<Capnproto_test.Capnp.Test.TestAllTypes, IReadOnlyList<uint>>.IInterface<IReadOnlyList<byte>>>(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<WRITER>());
}
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<WRITER>());
}
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<AnyPointer>(reader.AnyKindAsStruct);
AnyStructAsStruct = CapnpSerializable.Create<AnyPointer>(reader.AnyStructAsStruct);
AnyKindAsList = CapnpSerializable.Create<AnyPointer>(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<WRITER>());
}
public void applyDefaults()
{
}
public AnyPointer AnyKindAsStruct
{
get;
set;
}
public AnyPointer AnyStructAsStruct
{
get;
set;
}
public AnyPointer AnyKindAsList
{
get;
set;
}
public IReadOnlyList<object> 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<DeserializerState> AnyListAsList => (IReadOnlyList<DeserializerState>)ctx.ReadList(3);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 4);
}
public DynamicSerializerState AnyKindAsStruct
{
get => BuildPointer<DynamicSerializerState>(0);
set => Link(0, value);
}
public DynamicSerializerState AnyStructAsStruct
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
public DynamicSerializerState AnyKindAsList
{
get => BuildPointer<DynamicSerializerState>(2);
set => Link(2, value);
}
public DynamicSerializerState AnyListAsList
{
get => BuildPointer<DynamicSerializerState>(3);
set => Link(3, value);
}
}
}
[Proxy(typeof(TestInterfaceProxy)), Skeleton(typeof(TestInterfaceSkeleton))]
public interface ITestInterface : IDisposable
{
Task<string> 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<string> Foo(uint i, bool j, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_foo.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_foo>(d_);
return (r_.X);
}
public async Task Bar(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_bar.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar()
{};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_bar>(d_);
return;
}
public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_baz.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz()
{S = s};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_baz>(d_);
return;
}
}
public class TestInterfaceSkeleton : Skeleton<ITestInterface>
{
public TestInterfaceSkeleton()
{
SetMethodTable(Foo, Bar, Baz);
}
public override ulong InterfaceId => 9865999890858873522UL;
Task<AnswerOrCounterquestion> Foo(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Params_foo>(d_);
return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.J, cancellationToken_), x =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Result_foo.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestInterface.Result_foo{X = x};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> Bar(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Bar(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Result_bar.WRITER>();
return s_;
}
async Task<AnswerOrCounterquestion> Baz(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Params_baz>(d_);
await Impl.Baz(in_.S, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Result_baz.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestAllTypes>(reader.S);
applyDefaults();
}
public void serialize(WRITER writer)
{
S?.serialize(writer.S);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestAllTypes> Grault(CancellationToken cancellationToken_ = default);
}
public class TestExtendsProxy : Proxy, ITestExtends
{
public async Task Qux(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestExtends.Params_qux.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux()
{};
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestExtends.Result_qux>(d_);
return;
}
public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>();
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestExtends.Result_corge>(d_);
return;
}
public async Task<Capnproto_test.Capnp.Test.TestAllTypes> Grault(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestExtends.Params_grault.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault()
{};
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAllTypes>(d_);
return r_;
}
public async Task<string> Foo(uint i, bool j, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_foo.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_foo>(d_);
return (r_.X);
}
public async Task Bar(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_bar.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar()
{};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_bar>(d_);
return;
}
public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_baz.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz()
{S = s};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_baz>(d_);
return;
}
}
public class TestExtendsSkeleton : Skeleton<ITestExtends>
{
public TestExtendsSkeleton()
{
SetMethodTable(Qux, Corge, Grault);
}
public override ulong InterfaceId => 16494920484927878984UL;
async Task<AnswerOrCounterquestion> Qux(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Qux(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestExtends.Result_qux.WRITER>();
return s_;
}
async Task<AnswerOrCounterquestion> Corge(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Corge(CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAllTypes>(d_), cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestExtends.Result_corge.WRITER>();
return s_;
}
Task<AnswerOrCounterquestion> Grault(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.Grault(cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestExtends.Params_qux.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux()
{};
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestExtends.Result_qux>(d_);
return;
}
public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestAllTypes.WRITER>();
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestExtends.Result_corge>(d_);
return;
}
public async Task<Capnproto_test.Capnp.Test.TestAllTypes> Grault(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestExtends.Params_grault.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault()
{};
arg_.serialize(in_);
var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAllTypes>(d_);
return r_;
}
public async Task<string> Foo(uint i, bool j, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_foo.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_foo>(d_);
return (r_.X);
}
public async Task Bar(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_bar.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar()
{};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_bar>(d_);
return;
}
public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestInterface.Params_baz.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz()
{S = s};
arg_.serialize(in_);
var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestInterface.Result_baz>(d_);
return;
}
}
public class TestExtends2Skeleton : Skeleton<ITestExtends2>
{
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<Capnproto_test.Capnp.Test.ITestInterface> 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<Capnproto_test.Capnp.Test.TestPipeline.Params_getCap.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Result_getCap>(d_);
return (r_.S, r_.OutBox);
}
);
}
public async Task TestPointers(Capnproto_test.Capnp.Test.ITestInterface cap, AnyPointer obj, IReadOnlyList<Capnproto_test.Capnp.Test.ITestInterface> list, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestPipeline.Params_testPointers.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Result_testPointers>(d_);
return;
}
public Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestPipeline.Params_getAnyCap.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Result_getAnyCap>(d_);
return (r_.S, r_.OutBox);
}
);
}
}
public class TestPipelineSkeleton : Skeleton<ITestPipeline>
{
public TestPipelineSkeleton()
{
SetMethodTable(GetCap, TestPointers, GetAnyCap);
}
public override ulong InterfaceId => 11935670180855499984UL;
Task<AnswerOrCounterquestion> GetCap(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Params_getCap>(d_);
return Impatient.MaybeTailCall(Impl.GetCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestPipeline.Result_getCap.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestPipeline.Result_getCap{S = s, OutBox = outBox};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> TestPointers(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Params_testPointers>(d_);
await Impl.TestPointers(in_.Cap, in_.Obj, in_.List, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestPipeline.Result_testPointers.WRITER>();
return s_;
}
Task<AnswerOrCounterquestion> GetAnyCap(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestPipeline.Params_getAnyCap>(d_);
return Impatient.MaybeTailCall(Impl.GetAnyCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestPipeline.Result_getAnyCap.WRITER>();
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<Capnproto_test.Capnp.Test.ITestInterface>(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<BareProxy>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<BareProxy>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.TestPipeline.Box>(reader.OutBox);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.S = S;
OutBox?.serialize(writer.OutBox);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestPipeline.Box.WRITER>(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<AnyPointer>(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<WRITER>());
}
public void applyDefaults()
{
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get;
set;
}
public AnyPointer Obj
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.ITestInterface> 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<Capnproto_test.Capnp.Test.ITestInterface>(0);
public DeserializerState Obj => ctx.StructReadPointer(1);
public IReadOnlyList<Capnproto_test.Capnp.Test.ITestInterface> List => ctx.ReadCapList<Capnproto_test.Capnp.Test.ITestInterface>(2);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 3);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(0);
set => LinkObject(0, value);
}
public DynamicSerializerState Obj
{
get => BuildPointer<DynamicSerializerState>(1);
set => Link(1, value);
}
public ListOfCapsSerializer<Capnproto_test.Capnp.Test.ITestInterface> List
{
get => BuildPointer<ListOfCapsSerializer<Capnproto_test.Capnp.Test.ITestInterface>>(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<WRITER>());
}
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<WRITER>());
}
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<BareProxy>(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<Capnproto_test.Capnp.Test.TestPipeline.AnyBox>(reader.OutBox);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.S = S;
OutBox?.serialize(writer.OutBox);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestPipeline.AnyBox.WRITER>(1);
set => Link(1, value);
}
}
}
}
[Proxy(typeof(TestCallOrderProxy)), Skeleton(typeof(TestCallOrderSkeleton))]
public interface ITestCallOrder : IDisposable
{
Task<uint> GetCallSequence(uint expected, CancellationToken cancellationToken_ = default);
}
public class TestCallOrderProxy : Proxy, ITestCallOrder
{
public async Task<uint> GetCallSequence(uint expected, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence()
{Expected = expected};
arg_.serialize(in_);
var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestCallOrder.Result_getCallSequence>(d_);
return (r_.N);
}
}
public class TestCallOrderSkeleton : Skeleton<ITestCallOrder>
{
public TestCallOrderSkeleton()
{
SetMethodTable(GetCallSequence);
}
public override ulong InterfaceId => 11594359141811814481UL;
Task<AnswerOrCounterquestion> GetCallSequence(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence>(d_);
return Impatient.MaybeTailCall(Impl.GetCallSequence(in_.Expected, cancellationToken_), n =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestCallOrder.Result_getCallSequence.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestTailCallee.TailResult> Foo(int i, string t, CancellationToken cancellationToken_ = default);
}
public class TestTailCalleeProxy : Proxy, ITestTailCallee
{
public Task<Capnproto_test.Capnp.Test.TestTailCallee.TailResult> Foo(int i, string t, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestTailCallee.Params_foo.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestTailCallee.TailResult>(d_);
return r_;
}
);
}
}
public class TestTailCalleeSkeleton : Skeleton<ITestTailCallee>
{
public TestTailCalleeSkeleton()
{
SetMethodTable(Foo);
}
public override ulong InterfaceId => 15985132292242203195UL;
Task<AnswerOrCounterquestion> Foo(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestTailCallee.Params_foo>(d_);
return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.T, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestTailCallee.TailResult.WRITER>();
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<Capnproto_test.Capnp.Test.TestTailCallee.TailResult> task)
{
return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.ITestCallOrder>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestCallOrder>(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<Capnproto_test.Capnp.Test.ITestCallOrder>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestTailCallee.TailResult> Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default);
}
public class TestTailCallerProxy : Proxy, ITestTailCaller
{
public Task<Capnproto_test.Capnp.Test.TestTailCallee.TailResult> Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestTailCaller.Params_foo.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestTailCallee.TailResult>(d_);
return r_;
}
);
}
}
public class TestTailCallerSkeleton : Skeleton<ITestTailCaller>
{
public TestTailCallerSkeleton()
{
SetMethodTable(Foo);
}
public override ulong InterfaceId => 9731139705278181429UL;
Task<AnswerOrCounterquestion> Foo(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestTailCaller.Params_foo>(d_);
return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.Callee, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestTailCallee.TailResult.WRITER>();
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestTailCallee>(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<Capnproto_test.Capnp.Test.ITestTailCallee>(0);
set => LinkObject(0, value);
}
}
}
}
[Proxy(typeof(TestHandleProxy)), Skeleton(typeof(TestHandleSkeleton))]
public interface ITestHandle : IDisposable
{
}
public class TestHandleProxy : Proxy, ITestHandle
{
}
public class TestHandleSkeleton : Skeleton<ITestHandle>
{
public TestHandleSkeleton()
{
SetMethodTable();
}
public override ulong InterfaceId => 11785461720995412501UL;
}
[Proxy(typeof(TestMoreStuffProxy)), Skeleton(typeof(TestMoreStuffSkeleton))]
public interface ITestMoreStuff : Capnproto_test.Capnp.Test.ITestCallOrder
{
Task<string> CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default);
Task<string> CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.ITestInterface> NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default);
Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default);
Task<string> CallHeld(CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.ITestInterface> GetHeld(CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.ITestCallOrder> 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<Capnproto_test.Capnp.Test.ITestHandle> GetHandle(CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.ITestMoreStuff> GetNull(CancellationToken cancellationToken_ = default);
Task<string> 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<string> CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFoo.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFoo()
{Cap = cap};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFoo>(d_);
return (r_.S);
}
public async Task<string> CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFooWhenResolved.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFooWhenResolved()
{Cap = cap};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFooWhenResolved>(d_);
return (r_.S);
}
public Task<Capnproto_test.Capnp.Test.ITestInterface> NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_neverReturn.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_neverReturn()
{Cap = cap};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(15980754968839795663UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_neverReturn>(d_);
return (r_.CapCopy);
}
);
}
public async Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_hold.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_hold()
{Cap = cap};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 3, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_hold>(d_);
return;
}
public async Task<string> CallHeld(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_callHeld.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callHeld()
{};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 4, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callHeld>(d_);
return (r_.S);
}
public Task<Capnproto_test.Capnp.Test.ITestInterface> GetHeld(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHeld.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHeld()
{};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(15980754968839795663UL, 5, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHeld>(d_);
return (r_.Cap);
}
);
}
public Task<Capnproto_test.Capnp.Test.ITestCallOrder> Echo(Capnproto_test.Capnp.Test.ITestCallOrder cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_echo.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_echo()
{Cap = cap};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(15980754968839795663UL, 6, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_echo>(d_);
return (r_.Cap);
}
);
}
public async Task ExpectCancel(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_expectCancel.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_expectCancel()
{Cap = cap};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 7, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_expectCancel>(d_);
return;
}
public async Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithDefaults.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithDefaults>(d_);
return (r_.D, r_.E);
}
public Task<Capnproto_test.Capnp.Test.ITestHandle> GetHandle(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHandle.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHandle()
{};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(15980754968839795663UL, 9, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHandle>(d_);
return (r_.Handle);
}
);
}
public Task<Capnproto_test.Capnp.Test.ITestMoreStuff> GetNull(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_getNull.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getNull()
{};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(15980754968839795663UL, 10, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getNull>(d_);
return (r_.NullCap);
}
);
}
public async Task<string> GetEnormousString(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_getEnormousString.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getEnormousString()
{};
arg_.serialize(in_);
var d_ = await Call(15980754968839795663UL, 11, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getEnormousString>(d_);
return (r_.Str);
}
public async Task MethodWithNullDefault(string a, Capnproto_test.Capnp.Test.ITestInterface b, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithNullDefault.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithNullDefault>(d_);
return;
}
public async Task<uint> GetCallSequence(uint expected, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence()
{Expected = expected};
arg_.serialize(in_);
var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestCallOrder.Result_getCallSequence>(d_);
return (r_.N);
}
}
public class TestMoreStuffSkeleton : Skeleton<ITestMoreStuff>
{
public TestMoreStuffSkeleton()
{
SetMethodTable(CallFoo, CallFooWhenResolved, NeverReturn, Hold, CallHeld, GetHeld, Echo, ExpectCancel, MethodWithDefaults, GetHandle, GetNull, GetEnormousString, MethodWithNullDefault);
}
public override ulong InterfaceId => 15980754968839795663UL;
Task<AnswerOrCounterquestion> CallFoo(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFoo>(d_);
return Impatient.MaybeTailCall(Impl.CallFoo(in_.Cap, cancellationToken_), s =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFoo.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFoo{S = s};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> CallFooWhenResolved(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFooWhenResolved>(d_);
return Impatient.MaybeTailCall(Impl.CallFooWhenResolved(in_.Cap, cancellationToken_), s =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFooWhenResolved.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFooWhenResolved{S = s};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> NeverReturn(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_neverReturn>(d_);
return Impatient.MaybeTailCall(Impl.NeverReturn(in_.Cap, cancellationToken_), capCopy =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_neverReturn.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_neverReturn{CapCopy = capCopy};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> Hold(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_hold>(d_);
await Impl.Hold(in_.Cap, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_hold.WRITER>();
return s_;
}
Task<AnswerOrCounterquestion> CallHeld(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.CallHeld(cancellationToken_), s =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_callHeld.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callHeld{S = s};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> GetHeld(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.GetHeld(cancellationToken_), cap =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHeld.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHeld{Cap = cap};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> Echo(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_echo>(d_);
return Impatient.MaybeTailCall(Impl.Echo(in_.Cap, cancellationToken_), cap =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_echo.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_echo{Cap = cap};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> ExpectCancel(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_expectCancel>(d_);
await Impl.ExpectCancel(in_.Cap, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_expectCancel.WRITER>();
return s_;
}
Task<AnswerOrCounterquestion> MethodWithDefaults(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithDefaults>(d_);
return Impatient.MaybeTailCall(Impl.MethodWithDefaults(in_.A, in_.B, in_.C, cancellationToken_), (d, e) =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithDefaults.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithDefaults{D = d, E = e};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> GetHandle(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.GetHandle(cancellationToken_), handle =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHandle.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHandle{Handle = handle};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> GetNull(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.GetNull(cancellationToken_), nullCap =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getNull.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getNull{NullCap = nullCap};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> GetEnormousString(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.GetEnormousString(cancellationToken_), str =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_getEnormousString.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getEnormousString{Str = str};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> MethodWithNullDefault(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithNullDefault>(d_);
await Impl.MethodWithNullDefault(in_.A, in_.B, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithNullDefault.WRITER>();
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<Capnproto_test.Capnp.Test.ITestInterface> task)
{
return (Capnproto_test.Capnp.Test.ITestInterface)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.ITestCallOrder> task)
{
return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.ITestCallOrder>(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<Capnproto_test.Capnp.Test.ITestHandle> task)
{
return (Capnproto_test.Capnp.Test.ITestHandle)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.ITestHandle>(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<Capnproto_test.Capnp.Test.ITestMoreStuff> task)
{
return (Capnproto_test.Capnp.Test.ITestMoreStuff)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.ITestMoreStuff>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface CapCopy
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestCallOrder>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestCallOrder Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestCallOrder>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestCallOrder>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestCallOrder Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestCallOrder>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestInterface Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestHandle>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestHandle Handle
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestHandle>(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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestMoreStuff>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap
{
get => ReadCap<Capnproto_test.Capnp.Test.ITestMoreStuff>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.ITestInterface>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing> MakeThing(CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.TestMembrane.Result> CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.TestMembrane.Result> CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.TestMembrane.IThing> Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default);
Task WaitForever(CancellationToken cancellationToken_ = default);
}
public class TestMembraneProxy : Proxy, ITestMembrane
{
public Task<Capnproto_test.Capnp.Test.TestMembrane.IThing> MakeThing(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Params_makeThing.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_makeThing()
{};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(13870398341137210380UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result_makeThing>(d_);
return (r_.Thing);
}
);
}
public async Task<Capnproto_test.Capnp.Test.TestMembrane.Result> CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Params_callPassThrough.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result>(d_);
return r_;
}
public async Task<Capnproto_test.Capnp.Test.TestMembrane.Result> CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Params_callIntercept.WRITER>();
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<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result>(d_);
return r_;
}
public Task<Capnproto_test.Capnp.Test.TestMembrane.IThing> Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Params_loopback.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_loopback()
{Thing = thing};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(13870398341137210380UL, 3, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result_loopback>(d_);
return (r_.Thing);
}
);
}
public async Task WaitForever(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Params_waitForever.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_waitForever()
{};
arg_.serialize(in_);
var d_ = await Call(13870398341137210380UL, 4, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result_waitForever>(d_);
return;
}
}
public class TestMembraneSkeleton : Skeleton<ITestMembrane>
{
public TestMembraneSkeleton()
{
SetMethodTable(MakeThing, CallPassThrough, CallIntercept, Loopback, WaitForever);
}
public override ulong InterfaceId => 13870398341137210380UL;
Task<AnswerOrCounterquestion> MakeThing(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.MakeThing(cancellationToken_), thing =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result_makeThing.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_makeThing{Thing = thing};
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> CallPassThrough(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Params_callPassThrough>(d_);
return Impatient.MaybeTailCall(Impl.CallPassThrough(in_.Thing, in_.TailCall, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result.WRITER>();
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> CallIntercept(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Params_callIntercept>(d_);
return Impatient.MaybeTailCall(Impl.CallIntercept(in_.Thing, in_.TailCall, cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result.WRITER>();
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> Loopback(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Params_loopback>(d_);
return Impatient.MaybeTailCall(Impl.Loopback(in_.Thing, cancellationToken_), thing =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result_loopback.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_loopback{Thing = thing};
r_.serialize(s_);
return s_;
}
);
}
async Task<AnswerOrCounterquestion> WaitForever(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.WaitForever(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result_waitForever.WRITER>();
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<Capnproto_test.Capnp.Test.TestMembrane.IThing> task)
{
return (Capnproto_test.Capnp.Test.TestMembrane.IThing)CapabilityReflection.CreateProxy<Capnproto_test.Capnp.Test.TestMembrane.IThing>(Impatient.GetAnswer(task).Access(Path_makeThing_Eager));
}
}
public static class TestMembrane
{
[Proxy(typeof(ThingProxy)), Skeleton(typeof(ThingSkeleton))]
public interface IThing : IDisposable
{
Task<Capnproto_test.Capnp.Test.TestMembrane.Result> PassThrough(CancellationToken cancellationToken_ = default);
Task<Capnproto_test.Capnp.Test.TestMembrane.Result> Intercept(CancellationToken cancellationToken_ = default);
}
public class ThingProxy : Proxy, IThing
{
public async Task<Capnproto_test.Capnp.Test.TestMembrane.Result> PassThrough(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_passThrough.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_passThrough()
{};
arg_.serialize(in_);
var d_ = await Call(10615798940090972439UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result>(d_);
return r_;
}
public async Task<Capnproto_test.Capnp.Test.TestMembrane.Result> Intercept(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_intercept.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_intercept()
{};
arg_.serialize(in_);
var d_ = await Call(10615798940090972439UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestMembrane.Result>(d_);
return r_;
}
}
public class ThingSkeleton : Skeleton<IThing>
{
public ThingSkeleton()
{
SetMethodTable(PassThrough, Intercept);
}
public override ulong InterfaceId => 10615798940090972439UL;
Task<AnswerOrCounterquestion> PassThrough(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.PassThrough(cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result.WRITER>();
r_.serialize(s_);
return s_;
}
);
}
Task<AnswerOrCounterquestion> Intercept(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.Intercept(cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestMembrane.Result.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing
{
get => ReadCap<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing
{
get => ReadCap<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(0);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 1);
}
public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing
{
get => ReadCap<Capnproto_test.Capnp.Test.TestMembrane.IThing>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
public void applyDefaults()
{
}
public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap
{
get;
set;
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestMembrane.IThing> 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<Capnproto_test.Capnp.Test.TestMembrane.IThing>(0);
public IReadOnlyList<Capnproto_test.Capnp.Test.TestMembrane.IThing> List => ctx.ReadCapList<Capnproto_test.Capnp.Test.TestMembrane.IThing>(1);
}
public class WRITER : SerializerState
{
public WRITER()
{
this.SetStruct(0, 2);
}
public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap
{
get => ReadCap<Capnproto_test.Capnp.Test.TestMembrane.IThing>(0);
set => LinkObject(0, value);
}
public ListOfCapsSerializer<Capnproto_test.Capnp.Test.TestMembrane.IThing> List
{
get => BuildPointer<ListOfCapsSerializer<Capnproto_test.Capnp.Test.TestMembrane.IThing>>(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<Capnproto_test.Capnp.Test.TestTransferCap.Element>(_));
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.List.Init(List, (_s1, _v1) => _v1?.serialize(_s1));
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
public void applyDefaults()
{
}
public IReadOnlyList<Capnproto_test.Capnp.Test.TestTransferCap.Element> 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<Capnproto_test.Capnp.Test.TestTransferCap.Element.READER> 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<Capnproto_test.Capnp.Test.TestTransferCap.Element.WRITER> List
{
get => BuildPointer<ListOfStructsSerializer<Capnproto_test.Capnp.Test.TestTransferCap.Element.WRITER>>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.ITestInterface>(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<Capnproto_test.Capnp.Test.TestKeywordMethods.Params_delete.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_delete()
{};
arg_.serialize(in_);
var d_ = await Call(11160837778045172988UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_delete>(d_);
return;
}
public async Task Class(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Params_class.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_class()
{};
arg_.serialize(in_);
var d_ = await Call(11160837778045172988UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_class>(d_);
return;
}
public async Task Void(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Params_void.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_void()
{};
arg_.serialize(in_);
var d_ = await Call(11160837778045172988UL, 2, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_void>(d_);
return;
}
public async Task Return(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Params_return.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_return()
{};
arg_.serialize(in_);
var d_ = await Call(11160837778045172988UL, 3, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_return>(d_);
return;
}
}
public class TestKeywordMethodsSkeleton : Skeleton<ITestKeywordMethods>
{
public TestKeywordMethodsSkeleton()
{
SetMethodTable(Delete, Class, Void, Return);
}
public override ulong InterfaceId => 11160837778045172988UL;
async Task<AnswerOrCounterquestion> Delete(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Delete(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_delete.WRITER>();
return s_;
}
async Task<AnswerOrCounterquestion> Class(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Class(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_class.WRITER>();
return s_;
}
async Task<AnswerOrCounterquestion> Void(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Void(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_void.WRITER>();
return s_;
}
async Task<AnswerOrCounterquestion> Return(DeserializerState d_, CancellationToken cancellationToken_)
{
await Impl.Return(cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestKeywordMethods.Result_return.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<TVatId> : IDisposable
{
Task<TVatId> GetCallerId(CancellationToken cancellationToken_ = default);
}
public class TestAuthenticatedBootstrapProxy<TVatId> : Proxy, ITestAuthenticatedBootstrap<TVatId> where TVatId : class
{
public Task<TVatId> GetCallerId(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap<TVatId>.Params_getCallerId.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap<TVatId>.Params_getCallerId()
{};
arg_.serialize(in_);
return Impatient.MakePipelineAware(Call(16893789964317726925UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap<TVatId>.Result_getCallerId>(d_);
return (r_.Caller);
}
);
}
}
public class TestAuthenticatedBootstrapSkeleton<TVatId> : Skeleton<ITestAuthenticatedBootstrap<TVatId>> where TVatId : class
{
public TestAuthenticatedBootstrapSkeleton()
{
SetMethodTable(GetCallerId);
}
public override ulong InterfaceId => 16893789964317726925UL;
Task<AnswerOrCounterquestion> GetCallerId(DeserializerState d_, CancellationToken cancellationToken_)
{
return Impatient.MaybeTailCall(Impl.GetCallerId(cancellationToken_), caller =>
{
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap<TVatId>.Result_getCallerId.WRITER>();
var r_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap<TVatId>.Result_getCallerId{Caller = caller};
r_.serialize(s_);
return s_;
}
);
}
}
public static class TestAuthenticatedBootstrap<TVatId>
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<WRITER>());
}
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<TVatId>(reader.Caller);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.Caller.SetObject(Caller);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<DynamicSerializerState>(0);
set => Link(0, value);
}
}
}
}
public class TestSturdyRef : ICapnpSerializable
{
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
HostId = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestSturdyRefHostId>(reader.HostId);
ObjectId = CapnpSerializable.Create<AnyPointer>(reader.ObjectId);
applyDefaults();
}
public void serialize(WRITER writer)
{
HostId?.serialize(writer.HostId);
writer.ObjectId.SetObject(ObjectId);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestSturdyRefHostId.WRITER>(0);
set => Link(0, value);
}
public DynamicSerializerState ObjectId
{
get => BuildPointer<DynamicSerializerState>(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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion.@badlyNamedGroup>(reader.BadlyNamedGroup);
break;
case WHICH.Baz:
Baz = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER>(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<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct>(reader.AnotherBadNestedFieldName);
applyDefaults();
}
public void serialize(WRITER writer)
{
writer.BadNestedFieldName = BadNestedFieldName;
AnotherBadNestedFieldName?.serialize(writer.AnotherBadNestedFieldName);
}
void ICapnpSerializable.Serialize(SerializerState arg_)
{
serialize(arg_.Rewrap<WRITER>());
}
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<Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER>(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<Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Params_badlyNamedMethod.WRITER>();
var arg_ = new Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Params_badlyNamedMethod()
{BadlyNamedParam = badlyNamedParam};
arg_.serialize(in_);
var d_ = await Call(15065286897585459595UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Result_badlyNamedMethod>(d_);
return;
}
}
public class TestNameAnnotationInterfaceSkeleton : Skeleton<ITestNameAnnotationInterface>
{
public TestNameAnnotationInterfaceSkeleton()
{
SetMethodTable(BadlyNamedMethod);
}
public override ulong InterfaceId => 15065286897585459595UL;
async Task<AnswerOrCounterquestion> BadlyNamedMethod(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create<Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Params_badlyNamedMethod>(d_);
await Impl.BadlyNamedMethod(in_.BadlyNamedParam, cancellationToken_);
var s_ = SerializerState.CreateForRpc<Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Result_badlyNamedMethod.WRITER>();
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<WRITER>());
}
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<WRITER>());
}
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);
}
}
}
}
}