void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Param1 = CapnpSerializable.Create <TT>(reader.Param1);
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Infos = reader.Infos?.ToReadOnlyList(_ => CapnpSerializable.Create <Mas.Schema.Common.IdInformation>(_));
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
List = reader.List?.ToReadOnlyList(_ => CapnpSerializable.Create <Mas.Schema.Soil.SoilCharacteristicModifier.Data>(_));
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
SturdyRef = CapnpSerializable.Create <TSturdyRef>(reader.SturdyRef);
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Data = CapnpSerializable.Create <TPayload>(reader.Data);
NoFurtherJobs = reader.NoFurtherJobs;
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Method = reader.Method;
Request = CapnpSerializable.Create <TRequest>(reader.Request);
applyDefaults();
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Properties = reader.Properties?.ToReadOnlyList(_ => CapnpSerializable.Create <Mas.Schema.Soil.Layer.Property>(_));
Size = reader.Size;
Description = reader.Description;
applyDefaults();
}
async Task <AnswerOrCounterquestion> MethodA(DeserializerState d_, CancellationToken cancellationToken_)
{
var in_ = CapnpSerializable.Create <CapnpGen.GenericA <TT> .Params_methodA>(d_);
await Impl.MethodA(in_.Param1, cancellationToken_);
var s_ = SerializerState.CreateForRpc <CapnpGen.GenericA <TT> .Result_methodA.WRITER>();
return(s_);
}
async Task <AnswerOrCounterquestion> SetTimeout(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
var in_ = CapnpSerializable.Create <Mas.Schema.Service.Admin.Params_SetTimeout>(d_);
await Impl.SetTimeout(in_.Seconds, cancellationToken_);
var s_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Result_SetTimeout.WRITER>();
return(s_);
}
}
async Task <AnswerOrCounterquestion> UpdateIdentity(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
var in_ = CapnpSerializable.Create <Mas.Schema.Service.Admin.Params_UpdateIdentity>(d_);
await Impl.UpdateIdentity(in_.OldId, in_.NewInfo, cancellationToken_);
var s_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Result_UpdateIdentity.WRITER>();
return(s_);
}
}
async Task <AnswerOrCounterquestion> SetupPorts(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
var in_ = CapnpSerializable.Create <Mas.Schema.Fbp.Component.Params_SetupPorts>(d_);
await Impl.SetupPorts(in_.InPorts, in_.OutPorts, cancellationToken_);
var s_ = SerializerState.CreateForRpc <Mas.Schema.Fbp.Component.Result_SetupPorts.WRITER>();
return(s_);
}
}
public void Issue45()
{
var input = CodeGeneratorSteps.LoadResource("Issue45.capnp.bin");
using (input)
{
var frame = Framing.ReadSegments(input);
var ds = DeserializerState.CreateRoot(frame);
var cgr = CapnpSerializable.Create <CodeGeneratorRequest>(ds);
Assert.IsTrue(cgr.Nodes.Count > 0);
}
}
public async Task Stop(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Fbp.Component.Params_Stop.WRITER>();
var arg_ = new Mas.Schema.Fbp.Component.Params_Stop()
{
};
arg_?.serialize(in_);
using (var d_ = await Call(15499137556701095600UL, 1, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Fbp.Component.Result_Stop>(d_);
return;
}
}
public async Task <Mas.Schema.Crop.Cultivar> Cultivar(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Crop.Crop.Params_Cultivar.WRITER>();
var arg_ = new Mas.Schema.Crop.Crop.Params_Cultivar()
{
};
arg_?.serialize(in_);
using (var d_ = await Call(16757216515467467908UL, 1, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Crop.Crop.Result_Cultivar>(d_);
return(r_.Cult);
}
}
public async Task <long> MethodA(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <CapnpGen.Issue25A.Params_methodA.WRITER>();
var arg_ = new CapnpGen.Issue25A.Params_methodA()
{
};
arg_.serialize(in_);
var d_ = await Call(12726067773386434894UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create <CapnpGen.Issue25A.Result_methodA>(d_);
return(r_.Result);
}
public async Task <Mas.Schema.Common.IdInformation> Info(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Common.Identifiable.Params_Info.WRITER>();
var arg_ = new Mas.Schema.Common.Identifiable.Params_Info()
{
};
arg_?.serialize(in_);
using (var d_ = await Call(12875740530987518165UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Common.IdInformation>(d_);
return(r_);
}
}
public async Task <IReadOnlyList <Mas.Schema.Common.IdInformation> > Identities(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Params_Identities.WRITER>();
var arg_ = new Mas.Schema.Service.Admin.Params_Identities()
{
};
arg_?.serialize(in_);
using (var d_ = await Call(18357226832451728969UL, 3, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Service.Admin.Result_Identities>(d_);
return(r_.Infos);
}
}
public async Task Stop(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Params_Stop.WRITER>();
var arg_ = new Mas.Schema.Service.Admin.Params_Stop()
{
};
arg_?.serialize(in_);
using (var d_ = await Call(18357226832451728969UL, 2, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Service.Admin.Result_Stop>(d_);
return;
}
}
public async Task SetupPorts(IReadOnlyList <Mas.Schema.Fbp.Component.NameToPort> inPorts, IReadOnlyList <Mas.Schema.Fbp.Component.NameToPort> outPorts, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Fbp.Component.Params_SetupPorts.WRITER>();
var arg_ = new Mas.Schema.Fbp.Component.Params_SetupPorts()
{
InPorts = inPorts, OutPorts = outPorts
};
arg_?.serialize(in_);
using (var d_ = await Call(15499137556701095600UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Fbp.Component.Result_SetupPorts>(d_);
return;
}
}
public async Task UpdateIdentity(string oldId, Mas.Schema.Common.IdInformation newInfo, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Params_UpdateIdentity.WRITER>();
var arg_ = new Mas.Schema.Service.Admin.Params_UpdateIdentity()
{
OldId = oldId, NewInfo = newInfo
};
arg_?.serialize(in_);
using (var d_ = await Call(18357226832451728969UL, 4, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Service.Admin.Result_UpdateIdentity>(d_);
return;
}
}
public async Task <(string, bool, bool)> ImportData(string id, IReadOnlyList <byte> dwla, IReadOnlyList <byte> dwlb, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Model.Weberest.DWLABImport.Params_ImportData.WRITER>();
var arg_ = new Mas.Schema.Model.Weberest.DWLABImport.Params_ImportData()
{
Id = id, Dwla = dwla, Dwlb = dwlb
};
arg_?.serialize(in_);
using (var d_ = await Call(11647625426448067183UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Model.Weberest.DWLABImport.Result_ImportData>(d_);
return(r_.Id, r_.SuccessA, r_.SuccessB);
}
}
public async Task <string> Method(string @param, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Rpc.Test.A.Params_Method.WRITER>();
var arg_ = new Mas.Rpc.Test.A.Params_Method()
{
Param = @param
};
arg_?.serialize(in_);
using (var d_ = await Call(13447466392595712079UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
{
var r_ = CapnpSerializable.Create <Mas.Rpc.Test.A.Result_Method>(d_);
return(r_.Res);
}
}
public async Task MethodA(TT param1, CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <CapnpGen.GenericA <TT> .Params_methodA.WRITER>();
var arg_ = new CapnpGen.GenericA <TT> .Params_methodA()
{
Param1 = param1
};
arg_.serialize(in_);
var d_ = await Call(10341943558714247093UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_).WhenReturned;
var r_ = CapnpSerializable.Create <CapnpGen.GenericA <TT> .Result_methodA>(d_);
return;
}
Task <AnswerOrCounterquestion> ImportData(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
var in_ = CapnpSerializable.Create <Mas.Schema.Model.Weberest.DWLABImport.Params_ImportData>(d_);
return(Impatient.MaybeTailCall(Impl.ImportData(in_.Id, in_.Dwla, in_.Dwlb, cancellationToken_), (id, successA, successB) =>
{
var s_ = SerializerState.CreateForRpc <Mas.Schema.Model.Weberest.DWLABImport.Result_ImportData.WRITER>();
var r_ = new Mas.Schema.Model.Weberest.DWLABImport.Result_ImportData {
Id = id, SuccessA = successA, SuccessB = successB
};
r_.serialize(s_);
return s_;
}
));
}
}
Task <AnswerOrCounterquestion> Method(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
var in_ = CapnpSerializable.Create <Mas.Rpc.Test.A.Params_Method>(d_);
return(Impatient.MaybeTailCall(Impl.Method(in_.Param, cancellationToken_), res =>
{
var s_ = SerializerState.CreateForRpc <Mas.Rpc.Test.A.Result_Method.WRITER>();
var r_ = new Mas.Rpc.Test.A.Result_Method {
Res = res
};
r_.serialize(s_);
return s_;
}
));
}
}
public void OnCallFromAlice(CallContext callContext)
{
// is a Persistent interface
if (callContext.InterfaceId == PersistentInterfaceId)
{
var result = CapnpSerializable.Create <Mas.Rpc.Persistence.Persistent.Result_Save>(callContext.OutArgs);
var res = _registry.Restorer.Save(new BareProxy((ConsumedCapability)callContext.Bob));
result.SturdyRef = res.SturdyRef;
result.UnsaveSR = res.UnsaveSR;
var resultWriter = SerializerState.CreateForRpc <Mas.Rpc.Persistence.Persistent.Result_Save.WRITER>();
result.serialize(resultWriter);
callContext.OutArgs = resultWriter;
callContext.ReturnToAlice();
}
else
{
callContext.ForwardToBob();
}
}
public Task <object> Parameters(CancellationToken cancellationToken_ = default)
{
var in_ = SerializerState.CreateForRpc <Mas.Schema.Crop.Crop.Params_Parameters.WRITER>();
var arg_ = new Mas.Schema.Crop.Crop.Params_Parameters()
{
};
arg_?.serialize(in_);
return(Impatient.MakePipelineAware(Call(16757216515467467908UL, 0, in_.Rewrap <DynamicSerializerState>(), false, cancellationToken_), d_ =>
{
using (d_)
{
var r_ = CapnpSerializable.Create <Mas.Schema.Crop.Crop.Result_Parameters>(d_);
return (r_.Params);
}
}
));
}
