From 6faafddf8019ba2b4f4f97601d24f9ef4a9b3803 Mon Sep 17 00:00:00 2001 From: Kai Jan Kriegel Date: Fri, 16 Oct 2020 21:47:03 +0200 Subject: [PATCH] added annotations to api.capnp to resolve name conflicts in csharp --- api.capnp | 14 +- api.capnp.cs | 2231 +++++++++++++++++++++++++++++++++++++++++++ auth.capnp.cs | 663 +++++++++++++ connection.capnp.cs | 386 ++++++++ csharp.capnp.cs | 17 + rust.capnp.cs | 11 + 6 files changed, 3316 insertions(+), 6 deletions(-) create mode 100644 api.capnp.cs create mode 100644 auth.capnp.cs create mode 100644 connection.capnp.cs create mode 100644 csharp.capnp.cs create mode 100644 rust.capnp.cs diff --git a/api.capnp b/api.capnp index 95601f3..b220ef4 100644 --- a/api.capnp +++ b/api.capnp @@ -25,6 +25,8 @@ using Rust = import "rust.capnp"; $Rust.parentModule("schema"); +using CSharp = import "csharp.capnp"; + struct FabAccess { permissions @0 :Permissions; # Permission subsystem to manage permissions and systems underlying the authorization process @@ -92,13 +94,13 @@ struct Machine { } read @0 :Read; - interface Read { + interface Read $CSharp.name("ReadInterface") { info @0 () -> ( minfo :MInfo ); # Check the state of a machine. } write @1 :Write; - interface Write { + interface Write $CSharp.name("WriteInterface") { use @0 () -> ( ret :GiveBack ); # Try to use a machine. Returns a NULL-ptr if the user does not have the required # permissions to use this machine @@ -115,7 +117,7 @@ struct Machine { # After a machine has been used by an user with low enough permissions it's # in the 'toCheck' state. This call then allows more priviledged users to # "check" the machine and move it to the `free` state. - interface Manage { + interface Manage $CSharp.name("ManageInterface") { ok @0 () -> (); # The machine was clean & ok. -> free notOk @1 () -> (); # The machine was left in an unacceptable state. @@ -125,7 +127,7 @@ struct Machine { admin @3 :Admin; # Administrative overrides. This is only not-NULL if you have the required permissions # to use it. - interface Admin{ + interface Admin $CSharp.name("AdminInterface") { forceSetState @0 ( state :State ) -> (); # Forcefully set a machine state forceSetUser @1 ( user :Text ) -> (); # Set the given user as current responsible } @@ -139,12 +141,12 @@ struct User { } read @0 :Read; - interface Read { + interface Read $CSharp.name("ReadInterface") { info @0 () -> ( uinfo :UserInformation ); } write @1 :Write; - interface Write { + interface Write $CSharp.name("WriteInterface") { setName @0 ( name :Text ) -> (); } } diff --git a/api.capnp.cs b/api.capnp.cs new file mode 100644 index 0000000..d5d9481 --- /dev/null +++ b/api.capnp.cs @@ -0,0 +1,2231 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9d02dc8512eb28f7UL)] + public class FabAccess : ICapnpSerializable + { + public const UInt64 typeId = 0x9d02dc8512eb28f7UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Permissions = reader.Permissions; + Machines = reader.Machines; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Permissions = Permissions; + writer.Machines = Machines; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.IPermissions Permissions + { + get; + set; + } + + public CapnpGen.IMachines Machines + { + 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 CapnpGen.IPermissions Permissions => ctx.ReadCap(0); + public CapnpGen.IMachines Machines => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public CapnpGen.IPermissions Permissions + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public CapnpGen.IMachines Machines + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL), Proxy(typeof(Machines_Proxy)), Skeleton(typeof(Machines_Skeleton))] + public interface IMachines : IDisposable + { + Task> ListMachines(CancellationToken cancellationToken_ = default); + Task GetMachine(CapnpGen.UUID uuid, CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL)] + public class Machines_Proxy : Proxy, IMachines + { + public Task> ListMachines(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machines.Params_ListMachines() + {}; + arg_?.serialize(in_); + return Impatient.MakePipelineAware(Call(12107199981289703317UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + using (d_) + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Machines); + } + } + + ); + } + + public Task GetMachine(CapnpGen.UUID uuid, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machines.Params_GetMachine() + {Uuid = uuid}; + arg_?.serialize(in_); + return Impatient.MakePipelineAware(Call(12107199981289703317UL, 1, in_.Rewrap(), false, cancellationToken_), d_ => + { + using (d_) + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Machine); + } + } + + ); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL)] + public class Machines_Skeleton : Skeleton + { + public Machines_Skeleton() + { + SetMethodTable(ListMachines, GetMachine); + } + + public override ulong InterfaceId => 12107199981289703317UL; + Task ListMachines(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + return Impatient.MaybeTailCall(Impl.ListMachines(cancellationToken_), machines => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new CapnpGen.Machines.Result_ListMachines{Machines = machines}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + Task GetMachine(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetMachine(in_.Uuid, cancellationToken_), machine => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new CapnpGen.Machines.Result_GetMachine{Machine = machine}; + r_.serialize(s_); + return s_; + } + + ); + } + } + } + + public static class Machines + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xfe982bd0aae61394UL)] + public class Params_ListMachines : ICapnpSerializable + { + public const UInt64 typeId = 0xfe982bd0aae61394UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xeb1a06e9fe8c21a7UL)] + public class Result_ListMachines : ICapnpSerializable + { + public const UInt64 typeId = 0xeb1a06e9fe8c21a7UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Machines = reader.Machines?.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Machines.Init(Machines, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Machines + { + 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 Machines => ctx.ReadList(0).Cast(CapnpGen.Machine.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public ListOfStructsSerializer Machines + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe306bedd6421f753UL)] + public class Params_GetMachine : ICapnpSerializable + { + public const UInt64 typeId = 0xe306bedd6421f753UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Uuid = CapnpSerializable.Create(reader.Uuid); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Uuid?.serialize(writer.Uuid); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.UUID Uuid + { + 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 CapnpGen.UUID.READER Uuid => ctx.ReadStruct(0, CapnpGen.UUID.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public CapnpGen.UUID.WRITER Uuid + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa12d90399e4429abUL)] + public class Result_GetMachine : ICapnpSerializable + { + public const UInt64 typeId = 0xa12d90399e4429abUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Machine = CapnpSerializable.Create(reader.Machine); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Machine?.serialize(writer.Machine); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Machine Machine + { + 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 CapnpGen.Machine.READER Machine => ctx.ReadStruct(0, CapnpGen.Machine.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public CapnpGen.Machine.WRITER Machine + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL), Proxy(typeof(Permissions_Proxy)), Skeleton(typeof(Permissions_Skeleton))] + public interface IPermissions : IDisposable + { + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL)] + public class Permissions_Proxy : Proxy, IPermissions + { + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL)] + public class Permissions_Skeleton : Skeleton + { + public Permissions_Skeleton() + { + SetMethodTable(); + } + + public override ulong InterfaceId => 10076722239111079405UL; + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xadcad5d363e81a8aUL)] + public class UUID : ICapnpSerializable + { + public const UInt64 typeId = 0xadcad5d363e81a8aUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Uuid0 = reader.Uuid0; + Uuid1 = reader.Uuid1; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Uuid0 = Uuid0; + writer.Uuid1 = Uuid1; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Uuid0 + { + get; + set; + } + + public ulong Uuid1 + { + 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 Uuid0 => ctx.ReadDataULong(0UL, 0UL); + public ulong Uuid1 => ctx.ReadDataULong(64UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 0); + } + + public ulong Uuid0 + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public ulong Uuid1 + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf6ba3aea4d4d16f1UL)] + public enum State : ushort + { + free, + inUse, + toCheck, + blocked, + disabled, + reserved + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe0941baa9afbf58bUL)] + public class Machine : ICapnpSerializable + { + public const UInt64 typeId = 0xe0941baa9afbf58bUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Read = reader.Read; + Write = reader.Write; + Manage = reader.Manage; + Getadmin = reader.Getadmin; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Read = Read; + writer.Write = Write; + writer.Manage = Manage; + writer.Getadmin = Getadmin; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Machine.IReadInterface Read + { + get; + set; + } + + public CapnpGen.Machine.IWriteInterface Write + { + get; + set; + } + + public CapnpGen.Machine.IManageInterface Manage + { + get; + set; + } + + public CapnpGen.Machine.IAdminInterface Getadmin + { + 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 CapnpGen.Machine.IReadInterface Read => ctx.ReadCap(0); + public CapnpGen.Machine.IWriteInterface Write => ctx.ReadCap(1); + public CapnpGen.Machine.IManageInterface Manage => ctx.ReadCap(2); + public CapnpGen.Machine.IAdminInterface Getadmin => ctx.ReadCap(3); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public CapnpGen.Machine.IReadInterface Read + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public CapnpGen.Machine.IWriteInterface Write + { + get => ReadCap(1); + set => LinkObject(1, value); + } + + public CapnpGen.Machine.IManageInterface Manage + { + get => ReadCap(2); + set => LinkObject(2, value); + } + + public CapnpGen.Machine.IAdminInterface Getadmin + { + get => ReadCap(3); + set => LinkObject(3, value); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf4a44636dfe61452UL)] + public class MInfo : ICapnpSerializable + { + public const UInt64 typeId = 0xf4a44636dfe61452UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + State = reader.State; + Name = reader.Name; + Description = reader.Description; + Responsible = CapnpSerializable.Create(reader.Responsible); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.State = State; + writer.Name = Name; + writer.Description = Description; + Responsible?.serialize(writer.Responsible); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.State State + { + get; + set; + } + + public string Name + { + get; + set; + } + + public string Description + { + get; + set; + } + + public CapnpGen.User Responsible + { + 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 CapnpGen.State State => (CapnpGen.State)ctx.ReadDataUShort(0UL, (ushort)0); + public string Name => ctx.ReadText(0, null); + public string Description => ctx.ReadText(1, null); + public CapnpGen.User.READER Responsible => ctx.ReadStruct(2, CapnpGen.User.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 3); + } + + public CapnpGen.State State + { + get => (CapnpGen.State)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + + public string Name + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + + public string Description + { + get => this.ReadText(1, null); + set => this.WriteText(1, value, null); + } + + public CapnpGen.User.WRITER Responsible + { + get => BuildPointer(2); + set => Link(2, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL), Proxy(typeof(ReadInterface_Proxy)), Skeleton(typeof(ReadInterface_Skeleton))] + public interface IReadInterface : IDisposable + { + Task Info(CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL)] + public class ReadInterface_Proxy : Proxy, IReadInterface + { + public Task Info(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.ReadInterface.Params_Info() + {}; + arg_?.serialize(in_); + return Impatient.MakePipelineAware(Call(11762423691857951155UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + using (d_) + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Minfo); + } + } + + ); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL)] + public class ReadInterface_Skeleton : Skeleton + { + public ReadInterface_Skeleton() + { + SetMethodTable(Info); + } + + public override ulong InterfaceId => 11762423691857951155UL; + Task Info(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + return Impatient.MaybeTailCall(Impl.Info(cancellationToken_), minfo => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new CapnpGen.Machine.ReadInterface.Result_Info{Minfo = minfo}; + r_.serialize(s_); + return s_; + } + + ); + } + } + } + + public static class ReadInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf9e67c1807786e1aUL)] + public class Params_Info : ICapnpSerializable + { + public const UInt64 typeId = 0xf9e67c1807786e1aUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xbd10571b34bd4a73UL)] + public class Result_Info : ICapnpSerializable + { + public const UInt64 typeId = 0xbd10571b34bd4a73UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Minfo = CapnpSerializable.Create(reader.Minfo); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Minfo?.serialize(writer.Minfo); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Machine.MInfo Minfo + { + 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 CapnpGen.Machine.MInfo.READER Minfo => ctx.ReadStruct(0, CapnpGen.Machine.MInfo.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public CapnpGen.Machine.MInfo.WRITER Minfo + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL), Proxy(typeof(WriteInterface_Proxy)), Skeleton(typeof(WriteInterface_Skeleton))] + public interface IWriteInterface : IDisposable + { + Task Use(CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL)] + public class WriteInterface_Proxy : Proxy, IWriteInterface + { + public Task Use(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.WriteInterface.Params_Use() + {}; + arg_?.serialize(in_); + return Impatient.MakePipelineAware(Call(13178281729664624734UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + using (d_) + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Ret); + } + } + + ); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL)] + public class WriteInterface_Skeleton : Skeleton + { + public WriteInterface_Skeleton() + { + SetMethodTable(Use); + } + + public override ulong InterfaceId => 13178281729664624734UL; + Task Use(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + return Impatient.MaybeTailCall(Impl.Use(cancellationToken_), ret => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new CapnpGen.Machine.WriteInterface.Result_Use{Ret = ret}; + r_.serialize(s_); + return s_; + } + + ); + } + } + } + + public static class WriteInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL), Proxy(typeof(GiveBack_Proxy)), Skeleton(typeof(GiveBack_Skeleton))] + public interface IGiveBack : IDisposable + { + Task Ret(CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL)] + public class GiveBack_Proxy : Proxy, IGiveBack + { + public async Task Ret(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.WriteInterface.GiveBack.Params_Ret() + {}; + arg_?.serialize(in_); + using (var d_ = await Call(11418634637528611082UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL)] + public class GiveBack_Skeleton : Skeleton + { + public GiveBack_Skeleton() + { + SetMethodTable(Ret); + } + + public override ulong InterfaceId => 11418634637528611082UL; + async Task Ret(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + await Impl.Ret(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + } + + public static class GiveBack + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8b0804e2b42e4be6UL)] + public class Params_Ret : ICapnpSerializable + { + public const UInt64 typeId = 0x8b0804e2b42e4be6UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8e964b79f80bf81fUL)] + public class Result_Ret : ICapnpSerializable + { + public const UInt64 typeId = 0x8e964b79f80bf81fUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xde1b87bdfe982445UL)] + public class Params_Use : ICapnpSerializable + { + public const UInt64 typeId = 0xde1b87bdfe982445UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf85d4304bd899236UL)] + public class Result_Use : ICapnpSerializable + { + public const UInt64 typeId = 0xf85d4304bd899236UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Ret = reader.Ret; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Ret = Ret; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Machine.WriteInterface.IGiveBack Ret + { + 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 CapnpGen.Machine.WriteInterface.IGiveBack Ret => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public CapnpGen.Machine.WriteInterface.IGiveBack Ret + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL), Proxy(typeof(ManageInterface_Proxy)), Skeleton(typeof(ManageInterface_Skeleton))] + public interface IManageInterface : IDisposable + { + Task Ok(CancellationToken cancellationToken_ = default); + Task NotOk(CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL)] + public class ManageInterface_Proxy : Proxy, IManageInterface + { + public async Task Ok(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.ManageInterface.Params_Ok() + {}; + arg_?.serialize(in_); + using (var d_ = await Call(9604481578447888234UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public async Task NotOk(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.ManageInterface.Params_NotOk() + {}; + arg_?.serialize(in_); + using (var d_ = await Call(9604481578447888234UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL)] + public class ManageInterface_Skeleton : Skeleton + { + public ManageInterface_Skeleton() + { + SetMethodTable(Ok, NotOk); + } + + public override ulong InterfaceId => 9604481578447888234UL; + async Task Ok(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + await Impl.Ok(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + async Task NotOk(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + await Impl.NotOk(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + } + + public static class ManageInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xac68cf748c1a1846UL)] + public class Params_Ok : ICapnpSerializable + { + public const UInt64 typeId = 0xac68cf748c1a1846UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd9898de6e67065ddUL)] + public class Result_Ok : ICapnpSerializable + { + public const UInt64 typeId = 0xd9898de6e67065ddUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xbf7f4129df224857UL)] + public class Params_NotOk : ICapnpSerializable + { + public const UInt64 typeId = 0xbf7f4129df224857UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xfa1c8287c2b56e7aUL)] + public class Result_NotOk : ICapnpSerializable + { + public const UInt64 typeId = 0xfa1c8287c2b56e7aUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL), Proxy(typeof(AdminInterface_Proxy)), Skeleton(typeof(AdminInterface_Skeleton))] + public interface IAdminInterface : IDisposable + { + Task ForceSetState(CapnpGen.State state, CancellationToken cancellationToken_ = default); + Task ForceSetUser(string user, CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL)] + public class AdminInterface_Proxy : Proxy, IAdminInterface + { + public async Task ForceSetState(CapnpGen.State state, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.AdminInterface.Params_ForceSetState() + {State = state}; + arg_?.serialize(in_); + using (var d_ = await Call(12245135638991944143UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public async Task ForceSetUser(string user, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.Machine.AdminInterface.Params_ForceSetUser() + {User = user}; + arg_?.serialize(in_); + using (var d_ = await Call(12245135638991944143UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL)] + public class AdminInterface_Skeleton : Skeleton + { + public AdminInterface_Skeleton() + { + SetMethodTable(ForceSetState, ForceSetUser); + } + + public override ulong InterfaceId => 12245135638991944143UL; + async Task ForceSetState(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.ForceSetState(in_.State, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + async Task ForceSetUser(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.ForceSetUser(in_.User, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + } + + public static class AdminInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe289ed169b7328a3UL)] + public class Params_ForceSetState : ICapnpSerializable + { + public const UInt64 typeId = 0xe289ed169b7328a3UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + State = reader.State; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.State = State; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.State State + { + 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 CapnpGen.State State => (CapnpGen.State)ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public CapnpGen.State State + { + get => (CapnpGen.State)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc8b8aa5279ca0f92UL)] + public class Result_ForceSetState : ICapnpSerializable + { + public const UInt64 typeId = 0xc8b8aa5279ca0f92UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x82a0a114450df663UL)] + public class Params_ForceSetUser : ICapnpSerializable + { + public const UInt64 typeId = 0x82a0a114450df663UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + User = reader.User; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.User = User; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string User + { + 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 User => ctx.ReadText(0, null); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string User + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x88e4c64abe8bd7c7UL)] + public class Result_ForceSetUser : ICapnpSerializable + { + public const UInt64 typeId = 0x88e4c64abe8bd7c7UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb061fd95c25e396cUL)] + public class User : ICapnpSerializable + { + public const UInt64 typeId = 0xb061fd95c25e396cUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Read = reader.Read; + Write = reader.Write; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Read = Read; + writer.Write = Write; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.User.IReadInterface Read + { + get; + set; + } + + public CapnpGen.User.IWriteInterface Write + { + 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 CapnpGen.User.IReadInterface Read => ctx.ReadCap(0); + public CapnpGen.User.IWriteInterface Write => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public CapnpGen.User.IReadInterface Read + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public CapnpGen.User.IWriteInterface Write + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd4d066e0b2ea00e1UL)] + public class UserInformation : ICapnpSerializable + { + public const UInt64 typeId = 0xd4d066e0b2ea00e1UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Name = reader.Name; + OriginatingWorkshop = reader.OriginatingWorkshop; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.Name = Name; + writer.OriginatingWorkshop = OriginatingWorkshop; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Id + { + get; + set; + } + + public string Name + { + get; + set; + } + + public string OriginatingWorkshop + { + 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 Id => ctx.ReadText(0, null); + public string Name => ctx.ReadText(1, null); + public string OriginatingWorkshop => ctx.ReadText(2, null); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public string Id + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + + public string Name + { + get => this.ReadText(1, null); + set => this.WriteText(1, value, null); + } + + public string OriginatingWorkshop + { + get => this.ReadText(2, null); + set => this.WriteText(2, value, null); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL), Proxy(typeof(ReadInterface_Proxy)), Skeleton(typeof(ReadInterface_Skeleton))] + public interface IReadInterface : IDisposable + { + Task Info(CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL)] + public class ReadInterface_Proxy : Proxy, IReadInterface + { + public async Task Info(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.User.ReadInterface.Params_Info() + {}; + arg_?.serialize(in_); + using (var d_ = await Call(16348026851245215808UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Uinfo); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL)] + public class ReadInterface_Skeleton : Skeleton + { + public ReadInterface_Skeleton() + { + SetMethodTable(Info); + } + + public override ulong InterfaceId => 16348026851245215808UL; + Task Info(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + return Impatient.MaybeTailCall(Impl.Info(cancellationToken_), uinfo => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new CapnpGen.User.ReadInterface.Result_Info{Uinfo = uinfo}; + r_.serialize(s_); + return s_; + } + + ); + } + } + } + + public static class ReadInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xeb98009cced0bbb6UL)] + public class Params_Info : ICapnpSerializable + { + public const UInt64 typeId = 0xeb98009cced0bbb6UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa4afb7b09e77143bUL)] + public class Result_Info : ICapnpSerializable + { + public const UInt64 typeId = 0xa4afb7b09e77143bUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Uinfo = CapnpSerializable.Create(reader.Uinfo); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Uinfo?.serialize(writer.Uinfo); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.User.UserInformation Uinfo + { + 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 CapnpGen.User.UserInformation.READER Uinfo => ctx.ReadStruct(0, CapnpGen.User.UserInformation.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public CapnpGen.User.UserInformation.WRITER Uinfo + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL), Proxy(typeof(WriteInterface_Proxy)), Skeleton(typeof(WriteInterface_Skeleton))] + public interface IWriteInterface : IDisposable + { + Task SetName(string name, CancellationToken cancellationToken_ = default); + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL)] + public class WriteInterface_Proxy : Proxy, IWriteInterface + { + public async Task SetName(string name, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new CapnpGen.User.WriteInterface.Params_SetName() + {Name = name}; + arg_?.serialize(in_); + using (var d_ = await Call(14125549901127180372UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned) + { + var r_ = CapnpSerializable.Create(d_); + return; + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL)] + public class WriteInterface_Skeleton : Skeleton + { + public WriteInterface_Skeleton() + { + SetMethodTable(SetName); + } + + public override ulong InterfaceId => 14125549901127180372UL; + async Task SetName(DeserializerState d_, CancellationToken cancellationToken_) + { + using (d_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.SetName(in_.Name, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + } + + public static class WriteInterface + { + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8dbb37a5114e330fUL)] + public class Params_SetName : ICapnpSerializable + { + public const UInt64 typeId = 0x8dbb37a5114e330fUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + 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 Name => ctx.ReadText(0, null); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Name + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x896d7ef9e99ad470UL)] + public class Result_SetName : ICapnpSerializable + { + public const UInt64 typeId = 0x896d7ef9e99ad470UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + } + + public static partial class PipeliningSupportExtensions_api + { + static readonly MemberAccessPath Path__Machines_getMachine_Machine_Getadmin = new MemberAccessPath(0U, 3U); + public static CapnpGen.Machine.IAdminInterface Machine_Getadmin(this Task task) + { + async Task AwaitProxy() => (await task).Machine?.Getadmin; + return (CapnpGen.Machine.IAdminInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path__Machines_getMachine_Machine_Getadmin, AwaitProxy())); + } + + static readonly MemberAccessPath Path__Machines_getMachine_Machine_Manage = new MemberAccessPath(0U, 2U); + public static CapnpGen.Machine.IManageInterface Machine_Manage(this Task task) + { + async Task AwaitProxy() => (await task).Machine?.Manage; + return (CapnpGen.Machine.IManageInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path__Machines_getMachine_Machine_Manage, AwaitProxy())); + } + + static readonly MemberAccessPath Path__Machines_getMachine_Machine_Write = new MemberAccessPath(0U, 1U); + public static CapnpGen.Machine.IWriteInterface Machine_Write(this Task task) + { + async Task AwaitProxy() => (await task).Machine?.Write; + return (CapnpGen.Machine.IWriteInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path__Machines_getMachine_Machine_Write, AwaitProxy())); + } + + static readonly MemberAccessPath Path__Machines_getMachine_Machine_Read = new MemberAccessPath(0U, 0U); + public static CapnpGen.Machine.IReadInterface Machine_Read(this Task task) + { + async Task AwaitProxy() => (await task).Machine?.Read; + return (CapnpGen.Machine.IReadInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path__Machines_getMachine_Machine_Read, AwaitProxy())); + } + + static readonly MemberAccessPath Path_Machine_Read_info_Minfo_Responsible_Write = new MemberAccessPath(0U, 2U, 1U); + public static CapnpGen.User.IWriteInterface Minfo_Responsible_Write(this Task task) + { + async Task AwaitProxy() => (await task).Minfo?.Responsible?.Write; + return (CapnpGen.User.IWriteInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path_Machine_Read_info_Minfo_Responsible_Write, AwaitProxy())); + } + + static readonly MemberAccessPath Path_Machine_Read_info_Minfo_Responsible_Read = new MemberAccessPath(0U, 2U, 0U); + public static CapnpGen.User.IReadInterface Minfo_Responsible_Read(this Task task) + { + async Task AwaitProxy() => (await task).Minfo?.Responsible?.Read; + return (CapnpGen.User.IReadInterface)CapabilityReflection.CreateProxy(Impatient.Access(task, Path_Machine_Read_info_Minfo_Responsible_Read, AwaitProxy())); + } + } +} \ No newline at end of file diff --git a/auth.capnp.cs b/auth.capnp.cs new file mode 100644 index 0000000..dfb274f --- /dev/null +++ b/auth.capnp.cs @@ -0,0 +1,663 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd82dcd751f51b615UL)] + public class AuthMessage : ICapnpSerializable + { + public const UInt64 typeId = 0xd82dcd751f51b615UL; + public enum WHICH : ushort + { + Mechanisms = 0, + Request = 1, + Challenge = 2, + Response = 3, + Outcome = 4, + Abort = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Mechanisms: + Mechanisms = reader.Mechanisms; + break; + case WHICH.Request: + Request = CapnpSerializable.Create(reader.Request); + break; + case WHICH.Challenge: + Challenge = reader.Challenge; + break; + case WHICH.Response: + Response = reader.Response; + break; + case WHICH.Outcome: + Outcome = CapnpSerializable.Create(reader.Outcome); + break; + case WHICH.Abort: + which = reader.which; + 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.Mechanisms: + _content = null; + break; + case WHICH.Request: + _content = null; + break; + case WHICH.Challenge: + _content = null; + break; + case WHICH.Response: + _content = null; + break; + case WHICH.Outcome: + _content = null; + break; + case WHICH.Abort: + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Mechanisms: + writer.Mechanisms.Init(Mechanisms); + break; + case WHICH.Request: + Request?.serialize(writer.Request); + break; + case WHICH.Challenge: + writer.Challenge.Init(Challenge); + break; + case WHICH.Response: + writer.Response.Init(Response); + break; + case WHICH.Outcome: + Outcome?.serialize(writer.Outcome); + break; + case WHICH.Abort: + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Mechanisms + { + get => _which == WHICH.Mechanisms ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Mechanisms; + _content = value; + } + } + + public CapnpGen.Request Request + { + get => _which == WHICH.Request ? (CapnpGen.Request)_content : null; + set + { + _which = WHICH.Request; + _content = value; + } + } + + public IReadOnlyList Challenge + { + get => _which == WHICH.Challenge ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Challenge; + _content = value; + } + } + + public IReadOnlyList Response + { + get => _which == WHICH.Response ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Response; + _content = value; + } + } + + public CapnpGen.Outcome Outcome + { + get => _which == WHICH.Outcome ? (CapnpGen.Outcome)_content : null; + set + { + _which = WHICH.Outcome; + _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 IReadOnlyList Mechanisms => which == WHICH.Mechanisms ? ctx.ReadList(0).CastText2() : default; + public CapnpGen.Request.READER Request => which == WHICH.Request ? ctx.ReadStruct(0, CapnpGen.Request.READER.create) : default; + public IReadOnlyList Challenge => which == WHICH.Challenge ? ctx.ReadList(0).CastByte() : default; + public IReadOnlyList Response => which == WHICH.Response ? ctx.ReadList(0).CastByte() : default; + public CapnpGen.Outcome.READER Outcome => which == WHICH.Outcome ? ctx.ReadStruct(0, CapnpGen.Outcome.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 ListOfTextSerializer Mechanisms + { + get => which == WHICH.Mechanisms ? BuildPointer(0) : default; + set => Link(0, value); + } + + public CapnpGen.Request.WRITER Request + { + get => which == WHICH.Request ? BuildPointer(0) : default; + set => Link(0, value); + } + + public ListOfPrimitivesSerializer Challenge + { + get => which == WHICH.Challenge ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public ListOfPrimitivesSerializer Response + { + get => which == WHICH.Response ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public CapnpGen.Outcome.WRITER Outcome + { + get => which == WHICH.Outcome ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x80d8dfaa4dbfbb83UL)] + public class Request : ICapnpSerializable + { + public const UInt64 typeId = 0x80d8dfaa4dbfbb83UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Mechanism = reader.Mechanism; + InitialResponse = CapnpSerializable.Create(reader.InitialResponse); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Mechanism = Mechanism; + InitialResponse?.serialize(writer.InitialResponse); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Mechanism + { + get; + set; + } + + public CapnpGen.Request.initialResponse InitialResponse + { + 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 Mechanism => ctx.ReadText(0, null); + public initialResponse.READER InitialResponse => new initialResponse.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public string Mechanism + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + + public initialResponse.WRITER InitialResponse + { + get => Rewrap(); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xcb5a6f246a9c7196UL)] + public class initialResponse : ICapnpSerializable + { + public const UInt64 typeId = 0xcb5a6f246a9c7196UL; + public enum WHICH : ushort + { + None = 0, + Initial = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.None: + which = reader.which; + break; + case WHICH.Initial: + Initial = reader.Initial; + 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.Initial: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.None: + break; + case WHICH.Initial: + writer.Initial.Init(Initial); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Initial + { + get => _which == WHICH.Initial ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Initial; + _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 IReadOnlyList Initial => which == WHICH.Initial ? ctx.ReadList(1).CastByte() : 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 ListOfPrimitivesSerializer Initial + { + get => which == WHICH.Initial ? BuildPointer>(1) : default; + set => Link(1, value); + } + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9f2f3c9cd9974434UL)] + public class Outcome : ICapnpSerializable + { + public const UInt64 typeId = 0x9f2f3c9cd9974434UL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheResult = reader.TheResult; + TheAction = reader.TheAction; + HelpText = reader.HelpText; + AdditionalData = CapnpSerializable.Create(reader.AdditionalData); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TheResult = TheResult; + writer.TheAction = TheAction; + writer.HelpText = HelpText; + AdditionalData?.serialize(writer.AdditionalData); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Outcome.Result TheResult + { + get; + set; + } + + public CapnpGen.Outcome.Action TheAction + { + get; + set; + } + + public string HelpText + { + get; + set; + } + + public CapnpGen.Outcome.additionalData AdditionalData + { + 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 CapnpGen.Outcome.Result TheResult => (CapnpGen.Outcome.Result)ctx.ReadDataUShort(0UL, (ushort)0); + public CapnpGen.Outcome.Action TheAction => (CapnpGen.Outcome.Action)ctx.ReadDataUShort(16UL, (ushort)0); + public string HelpText => ctx.ReadText(0, null); + public additionalData.READER AdditionalData => new additionalData.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public CapnpGen.Outcome.Result TheResult + { + get => (CapnpGen.Outcome.Result)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + + public CapnpGen.Outcome.Action TheAction + { + get => (CapnpGen.Outcome.Action)this.ReadDataUShort(16UL, (ushort)0); + set => this.WriteData(16UL, (ushort)value, (ushort)0); + } + + public string HelpText + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + + public additionalData.WRITER AdditionalData + { + get => Rewrap(); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xcd5312ea76df43c1UL)] + public class additionalData : ICapnpSerializable + { + public const UInt64 typeId = 0xcd5312ea76df43c1UL; + public enum WHICH : ushort + { + None = 0, + Additional = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.None: + which = reader.which; + break; + case WHICH.Additional: + Additional = reader.Additional; + 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.Additional: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.None: + break; + case WHICH.Additional: + writer.Additional.Init(Additional); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Additional + { + get => _which == WHICH.Additional ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Additional; + _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 IReadOnlyList Additional => which == WHICH.Additional ? ctx.ReadList(1).CastByte() : 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 ListOfPrimitivesSerializer Additional + { + get => which == WHICH.Additional ? BuildPointer>(1) : default; + set => Link(1, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf76eb72a8d2bf5f3UL)] + public enum Result : ushort + { + successful, + badMechanism, + unwilling, + invalidCredentials, + unauthorized, + malformedAuthZid, + failed + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xbc1167ff63f623d0UL)] + public enum Action : ushort + { + unset, + retry, + wait, + permanent + } + } +} \ No newline at end of file diff --git a/connection.capnp.cs b/connection.capnp.cs new file mode 100644 index 0000000..c05e497 --- /dev/null +++ b/connection.capnp.cs @@ -0,0 +1,386 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9363e93d60b35057UL)] + public class Message : ICapnpSerializable + { + public const UInt64 typeId = 0x9363e93d60b35057UL; + public enum WHICH : ushort + { + Greet = 0, + Leave = 1, + Auth = 2, + Api = 3, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Greet: + Greet = CapnpSerializable.Create(reader.Greet); + break; + case WHICH.Leave: + Leave = CapnpSerializable.Create(reader.Leave); + break; + case WHICH.Auth: + Auth = CapnpSerializable.Create(reader.Auth); + break; + case WHICH.Api: + Api = CapnpSerializable.Create(reader.Api); + 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.Greet: + _content = null; + break; + case WHICH.Leave: + _content = null; + break; + case WHICH.Auth: + _content = null; + break; + case WHICH.Api: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Greet: + Greet?.serialize(writer.Greet); + break; + case WHICH.Leave: + Leave?.serialize(writer.Leave); + break; + case WHICH.Auth: + Auth?.serialize(writer.Auth); + break; + case WHICH.Api: + Api?.serialize(writer.Api); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Greeting Greet + { + get => _which == WHICH.Greet ? (CapnpGen.Greeting)_content : null; + set + { + _which = WHICH.Greet; + _content = value; + } + } + + public CapnpGen.Leave Leave + { + get => _which == WHICH.Leave ? (CapnpGen.Leave)_content : null; + set + { + _which = WHICH.Leave; + _content = value; + } + } + + public CapnpGen.AuthMessage Auth + { + get => _which == WHICH.Auth ? (CapnpGen.AuthMessage)_content : null; + set + { + _which = WHICH.Auth; + _content = value; + } + } + + public CapnpGen.FabAccess Api + { + get => _which == WHICH.Api ? (CapnpGen.FabAccess)_content : null; + set + { + _which = WHICH.Api; + _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 CapnpGen.Greeting.READER Greet => which == WHICH.Greet ? ctx.ReadStruct(0, CapnpGen.Greeting.READER.create) : default; + public CapnpGen.Leave.READER Leave => which == WHICH.Leave ? ctx.ReadStruct(0, CapnpGen.Leave.READER.create) : default; + public CapnpGen.AuthMessage.READER Auth => which == WHICH.Auth ? ctx.ReadStruct(0, CapnpGen.AuthMessage.READER.create) : default; + public CapnpGen.FabAccess.READER Api => which == WHICH.Api ? ctx.ReadStruct(0, CapnpGen.FabAccess.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 CapnpGen.Greeting.WRITER Greet + { + get => which == WHICH.Greet ? BuildPointer(0) : default; + set => Link(0, value); + } + + public CapnpGen.Leave.WRITER Leave + { + get => which == WHICH.Leave ? BuildPointer(0) : default; + set => Link(0, value); + } + + public CapnpGen.AuthMessage.WRITER Auth + { + get => which == WHICH.Auth ? BuildPointer(0) : default; + set => Link(0, value); + } + + public CapnpGen.FabAccess.WRITER Api + { + get => which == WHICH.Api ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd7c6c8a7ec8a94ffUL)] + public class Greeting : ICapnpSerializable + { + public const UInt64 typeId = 0xd7c6c8a7ec8a94ffUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Host = reader.Host; + Program = reader.Program; + Major = reader.Major; + Minor = reader.Minor; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Host = Host; + writer.Program = Program; + writer.Major = Major; + writer.Minor = Minor; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Host + { + get; + set; + } + + public string Program + { + get; + set; + } + + public uint Major + { + get; + set; + } + + public uint Minor + { + 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, null); + public string Program => ctx.ReadText(1, null); + public uint Major => ctx.ReadDataUInt(0UL, 0U); + public uint Minor => ctx.ReadDataUInt(32UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public string Host + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + + public string Program + { + get => this.ReadText(1, null); + set => this.WriteText(1, value, null); + } + + public uint Major + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public uint Minor + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc4edbaef246784cbUL)] + public class Leave : ICapnpSerializable + { + public const UInt64 typeId = 0xc4edbaef246784cbUL; + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheReason = reader.TheReason; + Message = reader.Message; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TheReason = TheReason; + writer.Message = Message; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public CapnpGen.Leave.Reason TheReason + { + get; + set; + } + + public string Message + { + 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 CapnpGen.Leave.Reason TheReason => (CapnpGen.Leave.Reason)ctx.ReadDataUShort(0UL, (ushort)0); + public string Message => ctx.ReadText(0, null); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public CapnpGen.Leave.Reason TheReason + { + get => (CapnpGen.Leave.Reason)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + + public string Message + { + get => this.ReadText(0, null); + set => this.WriteText(0, value, null); + } + } + + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e0e07e2ab5f7b2UL)] + public enum Reason : ushort + { + other, + incompatible + } + } +} \ No newline at end of file diff --git a/csharp.capnp.cs b/csharp.capnp.cs new file mode 100644 index 0000000..1092533 --- /dev/null +++ b/csharp.capnp.cs @@ -0,0 +1,17 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Annotations +{ + [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xeb0d831668c6eda5UL)] + public enum TypeVisibility : ushort + { + @public, + @internal + } +} \ No newline at end of file diff --git a/rust.capnp.cs b/rust.capnp.cs new file mode 100644 index 0000000..e8a1ee2 --- /dev/null +++ b/rust.capnp.cs @@ -0,0 +1,11 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ +} \ No newline at end of file