mirror of
https://github.com/FabInfra/capnproto-dotnetcore_Runtime.git
synced 2025-03-12 14:51:41 +01:00
2641 lines
82 KiB
C#
2641 lines
82 KiB
C#
using Capnp;
|
|
using Capnp.Rpc;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Capnp.Rpc
|
|
{
|
|
public class Message : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
Unimplemented = 0,
|
|
Abort = 1,
|
|
Call = 2,
|
|
Return = 3,
|
|
Finish = 4,
|
|
Resolve = 5,
|
|
Release = 6,
|
|
ObsoleteSave = 7,
|
|
Bootstrap = 8,
|
|
ObsoleteDelete = 9,
|
|
Provide = 10,
|
|
Accept = 11,
|
|
Join = 12,
|
|
Disembargo = 13,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.Unimplemented:
|
|
Unimplemented = CapnpSerializable.Create<Capnp.Rpc.Message>(reader.Unimplemented);
|
|
break;
|
|
case WHICH.Abort:
|
|
Abort = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Abort);
|
|
break;
|
|
case WHICH.Call:
|
|
Call = CapnpSerializable.Create<Capnp.Rpc.Call>(reader.Call);
|
|
break;
|
|
case WHICH.Return:
|
|
Return = CapnpSerializable.Create<Capnp.Rpc.Return>(reader.Return);
|
|
break;
|
|
case WHICH.Finish:
|
|
Finish = CapnpSerializable.Create<Capnp.Rpc.Finish>(reader.Finish);
|
|
break;
|
|
case WHICH.Resolve:
|
|
Resolve = CapnpSerializable.Create<Capnp.Rpc.Resolve>(reader.Resolve);
|
|
break;
|
|
case WHICH.Release:
|
|
Release = CapnpSerializable.Create<Capnp.Rpc.Release>(reader.Release);
|
|
break;
|
|
case WHICH.ObsoleteSave:
|
|
ObsoleteSave = CapnpSerializable.Create<AnyPointer>(reader.ObsoleteSave);
|
|
break;
|
|
case WHICH.Bootstrap:
|
|
Bootstrap = CapnpSerializable.Create<Capnp.Rpc.Bootstrap>(reader.Bootstrap);
|
|
break;
|
|
case WHICH.ObsoleteDelete:
|
|
ObsoleteDelete = CapnpSerializable.Create<AnyPointer>(reader.ObsoleteDelete);
|
|
break;
|
|
case WHICH.Provide:
|
|
Provide = CapnpSerializable.Create<Capnp.Rpc.Provide>(reader.Provide);
|
|
break;
|
|
case WHICH.Accept:
|
|
Accept = CapnpSerializable.Create<Capnp.Rpc.Accept>(reader.Accept);
|
|
break;
|
|
case WHICH.Join:
|
|
Join = CapnpSerializable.Create<Capnp.Rpc.Join>(reader.Join);
|
|
break;
|
|
case WHICH.Disembargo:
|
|
Disembargo = CapnpSerializable.Create<Capnp.Rpc.Disembargo>(reader.Disembargo);
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.Unimplemented:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Abort:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Call:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Return:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Finish:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Resolve:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Release:
|
|
_content = null;
|
|
break;
|
|
case WHICH.ObsoleteSave:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Bootstrap:
|
|
_content = null;
|
|
break;
|
|
case WHICH.ObsoleteDelete:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Provide:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Accept:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Join:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Disembargo:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.Unimplemented:
|
|
Unimplemented?.serialize(writer.Unimplemented);
|
|
break;
|
|
case WHICH.Abort:
|
|
Abort?.serialize(writer.Abort);
|
|
break;
|
|
case WHICH.Call:
|
|
Call?.serialize(writer.Call);
|
|
break;
|
|
case WHICH.Return:
|
|
Return?.serialize(writer.Return);
|
|
break;
|
|
case WHICH.Finish:
|
|
Finish?.serialize(writer.Finish);
|
|
break;
|
|
case WHICH.Resolve:
|
|
Resolve?.serialize(writer.Resolve);
|
|
break;
|
|
case WHICH.Release:
|
|
Release?.serialize(writer.Release);
|
|
break;
|
|
case WHICH.ObsoleteSave:
|
|
writer.ObsoleteSave.SetObject(ObsoleteSave);
|
|
break;
|
|
case WHICH.Bootstrap:
|
|
Bootstrap?.serialize(writer.Bootstrap);
|
|
break;
|
|
case WHICH.ObsoleteDelete:
|
|
writer.ObsoleteDelete.SetObject(ObsoleteDelete);
|
|
break;
|
|
case WHICH.Provide:
|
|
Provide?.serialize(writer.Provide);
|
|
break;
|
|
case WHICH.Accept:
|
|
Accept?.serialize(writer.Accept);
|
|
break;
|
|
case WHICH.Join:
|
|
Join?.serialize(writer.Join);
|
|
break;
|
|
case WHICH.Disembargo:
|
|
Disembargo?.serialize(writer.Disembargo);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public Capnp.Rpc.Message Unimplemented
|
|
{
|
|
get => _which == WHICH.Unimplemented ? (Capnp.Rpc.Message)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Unimplemented;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Exception Abort
|
|
{
|
|
get => _which == WHICH.Abort ? (Capnp.Rpc.Exception)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Abort;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Call Call
|
|
{
|
|
get => _which == WHICH.Call ? (Capnp.Rpc.Call)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Call;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Return Return
|
|
{
|
|
get => _which == WHICH.Return ? (Capnp.Rpc.Return)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Return;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Finish Finish
|
|
{
|
|
get => _which == WHICH.Finish ? (Capnp.Rpc.Finish)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Finish;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Resolve Resolve
|
|
{
|
|
get => _which == WHICH.Resolve ? (Capnp.Rpc.Resolve)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Resolve;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Release Release
|
|
{
|
|
get => _which == WHICH.Release ? (Capnp.Rpc.Release)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Release;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public AnyPointer ObsoleteSave
|
|
{
|
|
get => _which == WHICH.ObsoleteSave ? (AnyPointer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ObsoleteSave;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Bootstrap Bootstrap
|
|
{
|
|
get => _which == WHICH.Bootstrap ? (Capnp.Rpc.Bootstrap)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Bootstrap;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public AnyPointer ObsoleteDelete
|
|
{
|
|
get => _which == WHICH.ObsoleteDelete ? (AnyPointer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ObsoleteDelete;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Provide Provide
|
|
{
|
|
get => _which == WHICH.Provide ? (Capnp.Rpc.Provide)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Provide;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Accept Accept
|
|
{
|
|
get => _which == WHICH.Accept ? (Capnp.Rpc.Accept)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Accept;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Join Join
|
|
{
|
|
get => _which == WHICH.Join ? (Capnp.Rpc.Join)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Join;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Disembargo Disembargo
|
|
{
|
|
get => _which == WHICH.Disembargo ? (Capnp.Rpc.Disembargo)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Disembargo;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0);
|
|
public Capnp.Rpc.Message.READER Unimplemented => which == WHICH.Unimplemented ? ctx.ReadStruct(0, Capnp.Rpc.Message.READER.create) : default;
|
|
public Capnp.Rpc.Exception.READER Abort => which == WHICH.Abort ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
|
|
public Capnp.Rpc.Call.READER Call => which == WHICH.Call ? ctx.ReadStruct(0, Capnp.Rpc.Call.READER.create) : default;
|
|
public Capnp.Rpc.Return.READER Return => which == WHICH.Return ? ctx.ReadStruct(0, Capnp.Rpc.Return.READER.create) : default;
|
|
public Capnp.Rpc.Finish.READER Finish => which == WHICH.Finish ? ctx.ReadStruct(0, Capnp.Rpc.Finish.READER.create) : default;
|
|
public Capnp.Rpc.Resolve.READER Resolve => which == WHICH.Resolve ? ctx.ReadStruct(0, Capnp.Rpc.Resolve.READER.create) : default;
|
|
public Capnp.Rpc.Release.READER Release => which == WHICH.Release ? ctx.ReadStruct(0, Capnp.Rpc.Release.READER.create) : default;
|
|
public DeserializerState ObsoleteSave => which == WHICH.ObsoleteSave ? ctx.StructReadPointer(0) : default;
|
|
public Capnp.Rpc.Bootstrap.READER Bootstrap => which == WHICH.Bootstrap ? ctx.ReadStruct(0, Capnp.Rpc.Bootstrap.READER.create) : default;
|
|
public DeserializerState ObsoleteDelete => which == WHICH.ObsoleteDelete ? ctx.StructReadPointer(0) : default;
|
|
public Capnp.Rpc.Provide.READER Provide => which == WHICH.Provide ? ctx.ReadStruct(0, Capnp.Rpc.Provide.READER.create) : default;
|
|
public Capnp.Rpc.Accept.READER Accept => which == WHICH.Accept ? ctx.ReadStruct(0, Capnp.Rpc.Accept.READER.create) : default;
|
|
public Capnp.Rpc.Join.READER Join => which == WHICH.Join ? ctx.ReadStruct(0, Capnp.Rpc.Join.READER.create) : default;
|
|
public Capnp.Rpc.Disembargo.READER Disembargo => which == WHICH.Disembargo ? ctx.ReadStruct(0, Capnp.Rpc.Disembargo.READER.create) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(0U, (ushort)0);
|
|
set => this.WriteData(0U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public Capnp.Rpc.Message.WRITER Unimplemented
|
|
{
|
|
get => which == WHICH.Unimplemented ? BuildPointer<Capnp.Rpc.Message.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Exception.WRITER Abort
|
|
{
|
|
get => which == WHICH.Abort ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Call.WRITER Call
|
|
{
|
|
get => which == WHICH.Call ? BuildPointer<Capnp.Rpc.Call.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Return.WRITER Return
|
|
{
|
|
get => which == WHICH.Return ? BuildPointer<Capnp.Rpc.Return.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Finish.WRITER Finish
|
|
{
|
|
get => which == WHICH.Finish ? BuildPointer<Capnp.Rpc.Finish.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Resolve.WRITER Resolve
|
|
{
|
|
get => which == WHICH.Resolve ? BuildPointer<Capnp.Rpc.Resolve.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Release.WRITER Release
|
|
{
|
|
get => which == WHICH.Release ? BuildPointer<Capnp.Rpc.Release.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public DynamicSerializerState ObsoleteSave
|
|
{
|
|
get => which == WHICH.ObsoleteSave ? BuildPointer<DynamicSerializerState>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Bootstrap.WRITER Bootstrap
|
|
{
|
|
get => which == WHICH.Bootstrap ? BuildPointer<Capnp.Rpc.Bootstrap.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public DynamicSerializerState ObsoleteDelete
|
|
{
|
|
get => which == WHICH.ObsoleteDelete ? BuildPointer<DynamicSerializerState>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Provide.WRITER Provide
|
|
{
|
|
get => which == WHICH.Provide ? BuildPointer<Capnp.Rpc.Provide.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Accept.WRITER Accept
|
|
{
|
|
get => which == WHICH.Accept ? BuildPointer<Capnp.Rpc.Accept.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Join.WRITER Join
|
|
{
|
|
get => which == WHICH.Join ? BuildPointer<Capnp.Rpc.Join.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Disembargo.WRITER Disembargo
|
|
{
|
|
get => which == WHICH.Disembargo ? BuildPointer<Capnp.Rpc.Disembargo.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Bootstrap : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
DeprecatedObjectId = CapnpSerializable.Create<AnyPointer>(reader.DeprecatedObjectId);
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
writer.DeprecatedObjectId.SetObject(DeprecatedObjectId);
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public AnyPointer DeprecatedObjectId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public DeserializerState DeprecatedObjectId => ctx.StructReadPointer(0);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public DynamicSerializerState DeprecatedObjectId
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(0);
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Call : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
|
|
InterfaceId = reader.InterfaceId;
|
|
MethodId = reader.MethodId;
|
|
Params = CapnpSerializable.Create<Capnp.Rpc.Payload>(reader.Params);
|
|
SendResultsTo = CapnpSerializable.Create<Capnp.Rpc.Call.@sendResultsTo>(reader.SendResultsTo);
|
|
AllowThirdPartyTailCall = reader.AllowThirdPartyTailCall;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
Target?.serialize(writer.Target);
|
|
writer.InterfaceId = InterfaceId;
|
|
writer.MethodId = MethodId;
|
|
Params?.serialize(writer.Params);
|
|
SendResultsTo?.serialize(writer.SendResultsTo);
|
|
writer.AllowThirdPartyTailCall = AllowThirdPartyTailCall;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget Target
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public ulong InterfaceId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public ushort MethodId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.Payload Params
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.Call.@sendResultsTo SendResultsTo
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool AllowThirdPartyTailCall
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
= false;
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
|
|
public ulong InterfaceId => ctx.ReadDataULong(64UL, 0UL);
|
|
public ushort MethodId => ctx.ReadDataUShort(32UL, (ushort)0);
|
|
public Capnp.Rpc.Payload.READER Params => ctx.ReadStruct(1, Capnp.Rpc.Payload.READER.create);
|
|
public @sendResultsTo.READER SendResultsTo => new @sendResultsTo.READER(ctx);
|
|
public bool AllowThirdPartyTailCall => ctx.ReadDataBool(128UL, false);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(3, 3);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget.WRITER Target
|
|
{
|
|
get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public ulong InterfaceId
|
|
{
|
|
get => this.ReadDataULong(64UL, 0UL);
|
|
set => this.WriteData(64UL, value, 0UL);
|
|
}
|
|
|
|
public ushort MethodId
|
|
{
|
|
get => this.ReadDataUShort(32UL, (ushort)0);
|
|
set => this.WriteData(32UL, value, (ushort)0);
|
|
}
|
|
|
|
public Capnp.Rpc.Payload.WRITER Params
|
|
{
|
|
get => BuildPointer<Capnp.Rpc.Payload.WRITER>(1);
|
|
set => Link(1, value);
|
|
}
|
|
|
|
public @sendResultsTo.WRITER SendResultsTo
|
|
{
|
|
get => Rewrap<@sendResultsTo.WRITER>();
|
|
}
|
|
|
|
public bool AllowThirdPartyTailCall
|
|
{
|
|
get => this.ReadDataBool(128UL, false);
|
|
set => this.WriteData(128UL, value, false);
|
|
}
|
|
}
|
|
|
|
public class @sendResultsTo : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
Caller = 0,
|
|
Yourself = 1,
|
|
ThirdParty = 2,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.Caller:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.Yourself:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.ThirdParty:
|
|
ThirdParty = CapnpSerializable.Create<AnyPointer>(reader.ThirdParty);
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.Caller:
|
|
break;
|
|
case WHICH.Yourself:
|
|
break;
|
|
case WHICH.ThirdParty:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.Caller:
|
|
break;
|
|
case WHICH.Yourself:
|
|
break;
|
|
case WHICH.ThirdParty:
|
|
writer.ThirdParty.SetObject(ThirdParty);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public AnyPointer ThirdParty
|
|
{
|
|
get => _which == WHICH.ThirdParty ? (AnyPointer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ThirdParty;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0);
|
|
public DeserializerState ThirdParty => which == WHICH.ThirdParty ? ctx.StructReadPointer(2) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(48U, (ushort)0);
|
|
set => this.WriteData(48U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public DynamicSerializerState ThirdParty
|
|
{
|
|
get => which == WHICH.ThirdParty ? BuildPointer<DynamicSerializerState>(2) : default;
|
|
set => Link(2, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Return : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
Results = 0,
|
|
Exception = 1,
|
|
Canceled = 2,
|
|
ResultsSentElsewhere = 3,
|
|
TakeFromOtherQuestion = 4,
|
|
AcceptFromThirdParty = 5,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.Results:
|
|
Results = CapnpSerializable.Create<Capnp.Rpc.Payload>(reader.Results);
|
|
break;
|
|
case WHICH.Exception:
|
|
Exception = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Exception);
|
|
break;
|
|
case WHICH.Canceled:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.ResultsSentElsewhere:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.TakeFromOtherQuestion:
|
|
TakeFromOtherQuestion = reader.TakeFromOtherQuestion;
|
|
break;
|
|
case WHICH.AcceptFromThirdParty:
|
|
AcceptFromThirdParty = CapnpSerializable.Create<AnyPointer>(reader.AcceptFromThirdParty);
|
|
break;
|
|
}
|
|
|
|
AnswerId = reader.AnswerId;
|
|
ReleaseParamCaps = reader.ReleaseParamCaps;
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.Results:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Exception:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Canceled:
|
|
break;
|
|
case WHICH.ResultsSentElsewhere:
|
|
break;
|
|
case WHICH.TakeFromOtherQuestion:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.AcceptFromThirdParty:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.Results:
|
|
Results?.serialize(writer.Results);
|
|
break;
|
|
case WHICH.Exception:
|
|
Exception?.serialize(writer.Exception);
|
|
break;
|
|
case WHICH.Canceled:
|
|
break;
|
|
case WHICH.ResultsSentElsewhere:
|
|
break;
|
|
case WHICH.TakeFromOtherQuestion:
|
|
writer.TakeFromOtherQuestion = TakeFromOtherQuestion.Value;
|
|
break;
|
|
case WHICH.AcceptFromThirdParty:
|
|
writer.AcceptFromThirdParty.SetObject(AcceptFromThirdParty);
|
|
break;
|
|
}
|
|
|
|
writer.AnswerId = AnswerId;
|
|
writer.ReleaseParamCaps = ReleaseParamCaps;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint AnswerId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool ReleaseParamCaps
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
= true;
|
|
public Capnp.Rpc.Payload Results
|
|
{
|
|
get => _which == WHICH.Results ? (Capnp.Rpc.Payload)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Results;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Exception Exception
|
|
{
|
|
get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Exception;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public uint? TakeFromOtherQuestion
|
|
{
|
|
get => _which == WHICH.TakeFromOtherQuestion ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.TakeFromOtherQuestion;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public AnyPointer AcceptFromThirdParty
|
|
{
|
|
get => _which == WHICH.AcceptFromThirdParty ? (AnyPointer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.AcceptFromThirdParty;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0);
|
|
public uint AnswerId => ctx.ReadDataUInt(0UL, 0U);
|
|
public bool ReleaseParamCaps => ctx.ReadDataBool(32UL, true);
|
|
public Capnp.Rpc.Payload.READER Results => which == WHICH.Results ? ctx.ReadStruct(0, Capnp.Rpc.Payload.READER.create) : default;
|
|
public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
|
|
public uint TakeFromOtherQuestion => which == WHICH.TakeFromOtherQuestion ? ctx.ReadDataUInt(64UL, 0U) : default;
|
|
public DeserializerState AcceptFromThirdParty => which == WHICH.AcceptFromThirdParty ? ctx.StructReadPointer(0) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(2, 1);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(48U, (ushort)0);
|
|
set => this.WriteData(48U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public uint AnswerId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public bool ReleaseParamCaps
|
|
{
|
|
get => this.ReadDataBool(32UL, true);
|
|
set => this.WriteData(32UL, value, true);
|
|
}
|
|
|
|
public Capnp.Rpc.Payload.WRITER Results
|
|
{
|
|
get => which == WHICH.Results ? BuildPointer<Capnp.Rpc.Payload.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Exception.WRITER Exception
|
|
{
|
|
get => which == WHICH.Exception ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public uint TakeFromOtherQuestion
|
|
{
|
|
get => which == WHICH.TakeFromOtherQuestion ? this.ReadDataUInt(64UL, 0U) : default;
|
|
set => this.WriteData(64UL, value, 0U);
|
|
}
|
|
|
|
public DynamicSerializerState AcceptFromThirdParty
|
|
{
|
|
get => which == WHICH.AcceptFromThirdParty ? BuildPointer<DynamicSerializerState>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Finish : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
ReleaseResultCaps = reader.ReleaseResultCaps;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
writer.ReleaseResultCaps = ReleaseResultCaps;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool ReleaseResultCaps
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
= true;
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public bool ReleaseResultCaps => ctx.ReadDataBool(32UL, true);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 0);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public bool ReleaseResultCaps
|
|
{
|
|
get => this.ReadDataBool(32UL, true);
|
|
set => this.WriteData(32UL, value, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Resolve : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
Cap = 0,
|
|
Exception = 1,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.Cap:
|
|
Cap = CapnpSerializable.Create<Capnp.Rpc.CapDescriptor>(reader.Cap);
|
|
break;
|
|
case WHICH.Exception:
|
|
Exception = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Exception);
|
|
break;
|
|
}
|
|
|
|
PromiseId = reader.PromiseId;
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.Cap:
|
|
_content = null;
|
|
break;
|
|
case WHICH.Exception:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.Cap:
|
|
Cap?.serialize(writer.Cap);
|
|
break;
|
|
case WHICH.Exception:
|
|
Exception?.serialize(writer.Exception);
|
|
break;
|
|
}
|
|
|
|
writer.PromiseId = PromiseId;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint PromiseId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.CapDescriptor Cap
|
|
{
|
|
get => _which == WHICH.Cap ? (Capnp.Rpc.CapDescriptor)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Cap;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.Exception Exception
|
|
{
|
|
get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Exception;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0);
|
|
public uint PromiseId => ctx.ReadDataUInt(0UL, 0U);
|
|
public Capnp.Rpc.CapDescriptor.READER Cap => which == WHICH.Cap ? ctx.ReadStruct(0, Capnp.Rpc.CapDescriptor.READER.create) : default;
|
|
public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(32U, (ushort)0);
|
|
set => this.WriteData(32U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public uint PromiseId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.CapDescriptor.WRITER Cap
|
|
{
|
|
get => which == WHICH.Cap ? BuildPointer<Capnp.Rpc.CapDescriptor.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.Exception.WRITER Exception
|
|
{
|
|
get => which == WHICH.Exception ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Release : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
Id = reader.Id;
|
|
ReferenceCount = reader.ReferenceCount;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.Id = Id;
|
|
writer.ReferenceCount = ReferenceCount;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint Id
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public uint ReferenceCount
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint Id => ctx.ReadDataUInt(0UL, 0U);
|
|
public uint ReferenceCount => ctx.ReadDataUInt(32UL, 0U);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 0);
|
|
}
|
|
|
|
public uint Id
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public uint ReferenceCount
|
|
{
|
|
get => this.ReadDataUInt(32UL, 0U);
|
|
set => this.WriteData(32UL, value, 0U);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Disembargo : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
|
|
Context = CapnpSerializable.Create<Capnp.Rpc.Disembargo.@context>(reader.Context);
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
Target?.serialize(writer.Target);
|
|
Context?.serialize(writer.Context);
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget Target
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.Disembargo.@context Context
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
|
|
public @context.READER Context => new @context.READER(ctx);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget.WRITER Target
|
|
{
|
|
get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public @context.WRITER Context
|
|
{
|
|
get => Rewrap<@context.WRITER>();
|
|
}
|
|
}
|
|
|
|
public class @context : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
SenderLoopback = 0,
|
|
ReceiverLoopback = 1,
|
|
Accept = 2,
|
|
Provide = 3,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.SenderLoopback:
|
|
SenderLoopback = reader.SenderLoopback;
|
|
break;
|
|
case WHICH.ReceiverLoopback:
|
|
ReceiverLoopback = reader.ReceiverLoopback;
|
|
break;
|
|
case WHICH.Accept:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.Provide:
|
|
Provide = reader.Provide;
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.SenderLoopback:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.ReceiverLoopback:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.Accept:
|
|
break;
|
|
case WHICH.Provide:
|
|
_content = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.SenderLoopback:
|
|
writer.SenderLoopback = SenderLoopback.Value;
|
|
break;
|
|
case WHICH.ReceiverLoopback:
|
|
writer.ReceiverLoopback = ReceiverLoopback.Value;
|
|
break;
|
|
case WHICH.Accept:
|
|
break;
|
|
case WHICH.Provide:
|
|
writer.Provide = Provide.Value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint? SenderLoopback
|
|
{
|
|
get => _which == WHICH.SenderLoopback ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.SenderLoopback;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public uint? ReceiverLoopback
|
|
{
|
|
get => _which == WHICH.ReceiverLoopback ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ReceiverLoopback;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public uint? Provide
|
|
{
|
|
get => _which == WHICH.Provide ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.Provide;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0);
|
|
public uint SenderLoopback => which == WHICH.SenderLoopback ? ctx.ReadDataUInt(0UL, 0U) : default;
|
|
public uint ReceiverLoopback => which == WHICH.ReceiverLoopback ? ctx.ReadDataUInt(0UL, 0U) : default;
|
|
public uint Provide => which == WHICH.Provide ? ctx.ReadDataUInt(0UL, 0U) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(32U, (ushort)0);
|
|
set => this.WriteData(32U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public uint SenderLoopback
|
|
{
|
|
get => which == WHICH.SenderLoopback ? this.ReadDataUInt(0UL, 0U) : default;
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public uint ReceiverLoopback
|
|
{
|
|
get => which == WHICH.ReceiverLoopback ? this.ReadDataUInt(0UL, 0U) : default;
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public uint Provide
|
|
{
|
|
get => which == WHICH.Provide ? this.ReadDataUInt(0UL, 0U) : default;
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Provide : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
|
|
Recipient = CapnpSerializable.Create<AnyPointer>(reader.Recipient);
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
Target?.serialize(writer.Target);
|
|
writer.Recipient.SetObject(Recipient);
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget Target
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public AnyPointer Recipient
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
|
|
public DeserializerState Recipient => ctx.StructReadPointer(1);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 2);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget.WRITER Target
|
|
{
|
|
get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public DynamicSerializerState Recipient
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(1);
|
|
set => Link(1, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Accept : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
Provision = CapnpSerializable.Create<AnyPointer>(reader.Provision);
|
|
Embargo = reader.Embargo;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
writer.Provision.SetObject(Provision);
|
|
writer.Embargo = Embargo;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public AnyPointer Provision
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool Embargo
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public DeserializerState Provision => ctx.StructReadPointer(0);
|
|
public bool Embargo => ctx.ReadDataBool(32UL, false);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public DynamicSerializerState Provision
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public bool Embargo
|
|
{
|
|
get => this.ReadDataBool(32UL, false);
|
|
set => this.WriteData(32UL, value, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Join : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
|
|
KeyPart = CapnpSerializable.Create<AnyPointer>(reader.KeyPart);
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
Target?.serialize(writer.Target);
|
|
writer.KeyPart.SetObject(KeyPart);
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget Target
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public AnyPointer KeyPart
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
|
|
public DeserializerState KeyPart => ctx.StructReadPointer(1);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 2);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.MessageTarget.WRITER Target
|
|
{
|
|
get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public DynamicSerializerState KeyPart
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(1);
|
|
set => Link(1, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MessageTarget : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
ImportedCap = 0,
|
|
PromisedAnswer = 1,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.ImportedCap:
|
|
ImportedCap = reader.ImportedCap;
|
|
break;
|
|
case WHICH.PromisedAnswer:
|
|
PromisedAnswer = CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer>(reader.PromisedAnswer);
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.ImportedCap:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.PromisedAnswer:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.ImportedCap:
|
|
writer.ImportedCap = ImportedCap.Value;
|
|
break;
|
|
case WHICH.PromisedAnswer:
|
|
PromisedAnswer?.serialize(writer.PromisedAnswer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint? ImportedCap
|
|
{
|
|
get => _which == WHICH.ImportedCap ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ImportedCap;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.PromisedAnswer PromisedAnswer
|
|
{
|
|
get => _which == WHICH.PromisedAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.PromisedAnswer;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0);
|
|
public uint ImportedCap => which == WHICH.ImportedCap ? ctx.ReadDataUInt(0UL, 0U) : default;
|
|
public Capnp.Rpc.PromisedAnswer.READER PromisedAnswer => which == WHICH.PromisedAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(32U, (ushort)0);
|
|
set => this.WriteData(32U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public uint ImportedCap
|
|
{
|
|
get => which == WHICH.ImportedCap ? this.ReadDataUInt(0UL, 0U) : default;
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.PromisedAnswer.WRITER PromisedAnswer
|
|
{
|
|
get => which == WHICH.PromisedAnswer ? BuildPointer<Capnp.Rpc.PromisedAnswer.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Payload : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
Content = CapnpSerializable.Create<AnyPointer>(reader.Content);
|
|
CapTable = reader.CapTable.ToReadOnlyList(_ => CapnpSerializable.Create<Capnp.Rpc.CapDescriptor>(_));
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.Content.SetObject(Content);
|
|
writer.CapTable.Init(CapTable, (_s1, _v1) => _v1?.serialize(_s1));
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public AnyPointer Content
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public IReadOnlyList<Capnp.Rpc.CapDescriptor> CapTable
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public DeserializerState Content => ctx.StructReadPointer(0);
|
|
public IReadOnlyList<Capnp.Rpc.CapDescriptor.READER> CapTable => ctx.ReadList(1).Cast(Capnp.Rpc.CapDescriptor.READER.create);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(0, 2);
|
|
}
|
|
|
|
public DynamicSerializerState Content
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public ListOfStructsSerializer<Capnp.Rpc.CapDescriptor.WRITER> CapTable
|
|
{
|
|
get => BuildPointer<ListOfStructsSerializer<Capnp.Rpc.CapDescriptor.WRITER>>(1);
|
|
set => Link(1, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CapDescriptor : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
None = 0,
|
|
SenderHosted = 1,
|
|
SenderPromise = 2,
|
|
ReceiverHosted = 3,
|
|
ReceiverAnswer = 4,
|
|
ThirdPartyHosted = 5,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.None:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.SenderHosted:
|
|
SenderHosted = reader.SenderHosted;
|
|
break;
|
|
case WHICH.SenderPromise:
|
|
SenderPromise = reader.SenderPromise;
|
|
break;
|
|
case WHICH.ReceiverHosted:
|
|
ReceiverHosted = reader.ReceiverHosted;
|
|
break;
|
|
case WHICH.ReceiverAnswer:
|
|
ReceiverAnswer = CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer>(reader.ReceiverAnswer);
|
|
break;
|
|
case WHICH.ThirdPartyHosted:
|
|
ThirdPartyHosted = CapnpSerializable.Create<Capnp.Rpc.ThirdPartyCapDescriptor>(reader.ThirdPartyHosted);
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.None:
|
|
break;
|
|
case WHICH.SenderHosted:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.SenderPromise:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.ReceiverHosted:
|
|
_content = 0;
|
|
break;
|
|
case WHICH.ReceiverAnswer:
|
|
_content = null;
|
|
break;
|
|
case WHICH.ThirdPartyHosted:
|
|
_content = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.None:
|
|
break;
|
|
case WHICH.SenderHosted:
|
|
writer.SenderHosted = SenderHosted.Value;
|
|
break;
|
|
case WHICH.SenderPromise:
|
|
writer.SenderPromise = SenderPromise.Value;
|
|
break;
|
|
case WHICH.ReceiverHosted:
|
|
writer.ReceiverHosted = ReceiverHosted.Value;
|
|
break;
|
|
case WHICH.ReceiverAnswer:
|
|
ReceiverAnswer?.serialize(writer.ReceiverAnswer);
|
|
break;
|
|
case WHICH.ThirdPartyHosted:
|
|
ThirdPartyHosted?.serialize(writer.ThirdPartyHosted);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint? SenderHosted
|
|
{
|
|
get => _which == WHICH.SenderHosted ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.SenderHosted;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public uint? SenderPromise
|
|
{
|
|
get => _which == WHICH.SenderPromise ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.SenderPromise;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public uint? ReceiverHosted
|
|
{
|
|
get => _which == WHICH.ReceiverHosted ? (uint? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ReceiverHosted;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.PromisedAnswer ReceiverAnswer
|
|
{
|
|
get => _which == WHICH.ReceiverAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ReceiverAnswer;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public Capnp.Rpc.ThirdPartyCapDescriptor ThirdPartyHosted
|
|
{
|
|
get => _which == WHICH.ThirdPartyHosted ? (Capnp.Rpc.ThirdPartyCapDescriptor)_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.ThirdPartyHosted;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0);
|
|
public uint SenderHosted => which == WHICH.SenderHosted ? ctx.ReadDataUInt(32UL, 0U) : default;
|
|
public uint SenderPromise => which == WHICH.SenderPromise ? ctx.ReadDataUInt(32UL, 0U) : default;
|
|
public uint ReceiverHosted => which == WHICH.ReceiverHosted ? ctx.ReadDataUInt(32UL, 0U) : default;
|
|
public Capnp.Rpc.PromisedAnswer.READER ReceiverAnswer => which == WHICH.ReceiverAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default;
|
|
public Capnp.Rpc.ThirdPartyCapDescriptor.READER ThirdPartyHosted => which == WHICH.ThirdPartyHosted ? ctx.ReadStruct(0, Capnp.Rpc.ThirdPartyCapDescriptor.READER.create) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(0U, (ushort)0);
|
|
set => this.WriteData(0U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public uint SenderHosted
|
|
{
|
|
get => which == WHICH.SenderHosted ? this.ReadDataUInt(32UL, 0U) : default;
|
|
set => this.WriteData(32UL, value, 0U);
|
|
}
|
|
|
|
public uint SenderPromise
|
|
{
|
|
get => which == WHICH.SenderPromise ? this.ReadDataUInt(32UL, 0U) : default;
|
|
set => this.WriteData(32UL, value, 0U);
|
|
}
|
|
|
|
public uint ReceiverHosted
|
|
{
|
|
get => which == WHICH.ReceiverHosted ? this.ReadDataUInt(32UL, 0U) : default;
|
|
set => this.WriteData(32UL, value, 0U);
|
|
}
|
|
|
|
public Capnp.Rpc.PromisedAnswer.WRITER ReceiverAnswer
|
|
{
|
|
get => which == WHICH.ReceiverAnswer ? BuildPointer<Capnp.Rpc.PromisedAnswer.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public Capnp.Rpc.ThirdPartyCapDescriptor.WRITER ThirdPartyHosted
|
|
{
|
|
get => which == WHICH.ThirdPartyHosted ? BuildPointer<Capnp.Rpc.ThirdPartyCapDescriptor.WRITER>(0) : default;
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PromisedAnswer : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
QuestionId = reader.QuestionId;
|
|
Transform = reader.Transform.ToReadOnlyList(_ => CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer.Op>(_));
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.QuestionId = QuestionId;
|
|
writer.Transform.Init(Transform, (_s1, _v1) => _v1?.serialize(_s1));
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public IReadOnlyList<Capnp.Rpc.PromisedAnswer.Op> Transform
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
|
|
public IReadOnlyList<Capnp.Rpc.PromisedAnswer.Op.READER> Transform => ctx.ReadList(0).Cast(Capnp.Rpc.PromisedAnswer.Op.READER.create);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public uint QuestionId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
|
|
public ListOfStructsSerializer<Capnp.Rpc.PromisedAnswer.Op.WRITER> Transform
|
|
{
|
|
get => BuildPointer<ListOfStructsSerializer<Capnp.Rpc.PromisedAnswer.Op.WRITER>>(0);
|
|
set => Link(0, value);
|
|
}
|
|
}
|
|
|
|
public class Op : ICapnpSerializable
|
|
{
|
|
public enum WHICH : ushort
|
|
{
|
|
Noop = 0,
|
|
GetPointerField = 1,
|
|
undefined = 65535
|
|
}
|
|
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
switch (reader.which)
|
|
{
|
|
case WHICH.Noop:
|
|
which = reader.which;
|
|
break;
|
|
case WHICH.GetPointerField:
|
|
GetPointerField = reader.GetPointerField;
|
|
break;
|
|
}
|
|
|
|
applyDefaults();
|
|
}
|
|
|
|
private WHICH _which = WHICH.undefined;
|
|
private object _content;
|
|
public WHICH which
|
|
{
|
|
get => _which;
|
|
set
|
|
{
|
|
if (value == _which)
|
|
return;
|
|
_which = value;
|
|
switch (value)
|
|
{
|
|
case WHICH.Noop:
|
|
break;
|
|
case WHICH.GetPointerField:
|
|
_content = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.which = which;
|
|
switch (which)
|
|
{
|
|
case WHICH.Noop:
|
|
break;
|
|
case WHICH.GetPointerField:
|
|
writer.GetPointerField = GetPointerField.Value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public ushort? GetPointerField
|
|
{
|
|
get => _which == WHICH.GetPointerField ? (ushort? )_content : null;
|
|
set
|
|
{
|
|
_which = WHICH.GetPointerField;
|
|
_content = value;
|
|
}
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0);
|
|
public ushort GetPointerField => which == WHICH.GetPointerField ? ctx.ReadDataUShort(16UL, (ushort)0) : default;
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 0);
|
|
}
|
|
|
|
public WHICH which
|
|
{
|
|
get => (WHICH)this.ReadDataUShort(0U, (ushort)0);
|
|
set => this.WriteData(0U, (ushort)value, (ushort)0);
|
|
}
|
|
|
|
public ushort GetPointerField
|
|
{
|
|
get => which == WHICH.GetPointerField ? this.ReadDataUShort(16UL, (ushort)0) : default;
|
|
set => this.WriteData(16UL, value, (ushort)0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ThirdPartyCapDescriptor : ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
Id = CapnpSerializable.Create<AnyPointer>(reader.Id);
|
|
VineId = reader.VineId;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.Id.SetObject(Id);
|
|
writer.VineId = VineId;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public AnyPointer Id
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public uint VineId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public DeserializerState Id => ctx.StructReadPointer(0);
|
|
public uint VineId => ctx.ReadDataUInt(0UL, 0U);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public DynamicSerializerState Id
|
|
{
|
|
get => BuildPointer<DynamicSerializerState>(0);
|
|
set => Link(0, value);
|
|
}
|
|
|
|
public uint VineId
|
|
{
|
|
get => this.ReadDataUInt(0UL, 0U);
|
|
set => this.WriteData(0UL, value, 0U);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Exception : System.Exception, ICapnpSerializable
|
|
{
|
|
void ICapnpSerializable.Deserialize(DeserializerState arg_)
|
|
{
|
|
var reader = READER.create(arg_);
|
|
Reason = reader.Reason;
|
|
ObsoleteIsCallersFault = reader.ObsoleteIsCallersFault;
|
|
ObsoleteDurability = reader.ObsoleteDurability;
|
|
TheType = reader.TheType;
|
|
applyDefaults();
|
|
}
|
|
|
|
public void serialize(WRITER writer)
|
|
{
|
|
writer.Reason = Reason;
|
|
writer.ObsoleteIsCallersFault = ObsoleteIsCallersFault;
|
|
writer.ObsoleteDurability = ObsoleteDurability;
|
|
writer.TheType = TheType;
|
|
}
|
|
|
|
void ICapnpSerializable.Serialize(SerializerState arg_)
|
|
{
|
|
serialize(arg_.Rewrap<WRITER>());
|
|
}
|
|
|
|
public void applyDefaults()
|
|
{
|
|
}
|
|
|
|
public string Reason
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool ObsoleteIsCallersFault
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public ushort ObsoleteDurability
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Capnp.Rpc.Exception.Type TheType
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public struct READER
|
|
{
|
|
readonly DeserializerState ctx;
|
|
public READER(DeserializerState ctx)
|
|
{
|
|
this.ctx = ctx;
|
|
}
|
|
|
|
public static READER create(DeserializerState ctx) => new READER(ctx);
|
|
public static implicit operator DeserializerState(READER reader) => reader.ctx;
|
|
public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
|
|
public string Reason => ctx.ReadText(0, "");
|
|
public bool ObsoleteIsCallersFault => ctx.ReadDataBool(0UL, false);
|
|
public ushort ObsoleteDurability => ctx.ReadDataUShort(16UL, (ushort)0);
|
|
public Capnp.Rpc.Exception.Type TheType => (Capnp.Rpc.Exception.Type)ctx.ReadDataUShort(32UL, (ushort)0);
|
|
}
|
|
|
|
public class WRITER : SerializerState
|
|
{
|
|
public WRITER()
|
|
{
|
|
this.SetStruct(1, 1);
|
|
}
|
|
|
|
public string Reason
|
|
{
|
|
get => this.ReadText(0, "");
|
|
set => this.WriteText(0, value, "");
|
|
}
|
|
|
|
public bool ObsoleteIsCallersFault
|
|
{
|
|
get => this.ReadDataBool(0UL, false);
|
|
set => this.WriteData(0UL, value, false);
|
|
}
|
|
|
|
public ushort ObsoleteDurability
|
|
{
|
|
get => this.ReadDataUShort(16UL, (ushort)0);
|
|
set => this.WriteData(16UL, value, (ushort)0);
|
|
}
|
|
|
|
public Capnp.Rpc.Exception.Type TheType
|
|
{
|
|
get => (Capnp.Rpc.Exception.Type)this.ReadDataUShort(32UL, (ushort)0);
|
|
set => this.WriteData(32UL, (ushort)value, (ushort)0);
|
|
}
|
|
}
|
|
|
|
public enum Type : ushort
|
|
{
|
|
failed,
|
|
overloaded,
|
|
disconnected,
|
|
unimplemented
|
|
}
|
|
}
|
|
} |