static void Main(string[] args)
{
Stream input;
if (args.Length > 0)
{
input = new FileStream(args[0], FileMode.Open, FileAccess.Read);
}
else
{
input = Console.OpenStandardInput();
}
WireFrame segments;
using (input)
{
segments = Framing.ReadSegments(input);
}
var dec = DeserializerState.CreateRoot(segments);
var reader = Schema.CodeGeneratorRequest.Reader.Create(dec);
var model = Model.SchemaModel.Create(reader);
var codeGen = new Generator.CodeGenerator(model, new Generator.GeneratorOptions());
codeGen.Generate();
}
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_);
Infos = reader.Infos?.ToReadOnlyList(_ => CapnpSerializable.Create <Mas.Schema.Common.IdInformation>(_));
applyDefaults();
}
private IEnumerable <T> ReadImpl <T>(Type type, bool buffered)
{
if (reader == null)
{
throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
}
if (IsConsumed)
{
throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
}
var typedIdentity = identity.ForGrid(type, gridIndex);
CacheInfo cache = addToCache ? GetCacheInfo(typedIdentity, null, addToCache) : null;
var deserializer = cache?.Deserializer ?? default(DeserializerState);
int hash = GetColumnHash(reader);
if (deserializer.Func == null || deserializer.Hash != hash)
{
deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
if (cache != null)
{
cache.Deserializer = deserializer;
}
}
IsConsumed = true;
var result = ReadDeferred <T>(gridIndex, deserializer.Func, type);
return(buffered ? result?.ToList() : result);
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Param1 = CapnpSerializable.Create <TT>(reader.Param1);
applyDefaults();
}
public void ListOfULongs()
{
var mb = MessageBuilder.Create(1);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
int count = 345;
ds.SetListOfValues(64, count);
for (int i = 0; i < count; i++)
{
ds.ListWriteValue(i, (ulong)i);
}
DeserializerState d = ds;
Assert.AreEqual(count, d.ListElementCount);
var ulongs = d.RequireList().CastULong();
for (int i = 0; i < count; i++)
{
Assert.AreEqual((ulong)i, ulongs[i]);
}
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
var dummy = ulongs[-1];
});
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
var dummy = ulongs[count];
});
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Cult = reader.Cult;
applyDefaults();
}
public void ListOfBytesAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(8, 10);
ds.ListWriteValue(1, (byte)0x11);
ds.ListWriteValue(2, (byte)0x22);
ds.ListWriteValue(3, (byte)0x33);
ds.ListWriteValue(4, (byte)0x44);
ds.ListWriteValue(5, (byte)0x55);
ds.ListWriteValue(6, (byte)0x66);
ds.ListWriteValue(7, (byte)0x77);
ds.ListWriteValue(8, (byte)0x88);
ds.ListWriteValue(9, (byte)0x99);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(10, asListOfStructs.Count);
Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind);
Assert.AreEqual((byte)0x00, asListOfStructs[0].ReadDataByte(0));
Assert.AreEqual((byte)0x11, asListOfStructs[1].ReadDataByte(0));
Assert.AreEqual((byte)0x22, asListOfStructs[2].ReadDataByte(0));
Assert.AreEqual((byte)0x33, asListOfStructs[3].ReadDataByte(0));
Assert.AreEqual((byte)0x44, asListOfStructs[4].ReadDataByte(0));
Assert.AreEqual((byte)0x55, asListOfStructs[5].ReadDataByte(0));
Assert.AreEqual((byte)0x66, asListOfStructs[6].ReadDataByte(0));
Assert.AreEqual((byte)0x77, asListOfStructs[7].ReadDataByte(0));
Assert.AreEqual((byte)0x88, asListOfStructs[8].ReadDataByte(0));
Assert.AreEqual((byte)0x99, asListOfStructs[9].ReadDataByte(0));
}
public void NestedLists()
{
var expected = new int[][] {
new int[] { 1, 2, 3 },
new int[] { 4, 5 },
new int[] { 6 }
};
var b = MessageBuilder.Create();
var dss = b.CreateObject <DynamicSerializerState>();
dss.SetObject(expected);
DeserializerState d = dss;
var ld = d.RequireList();
Assert.ThrowsException <NotSupportedException>(() => ld.CastText());
var result = ld.Cast2D <int>();
Assert.AreEqual(3, result.Count);
for (int i = 0; i < result.Count; i++)
{
CollectionAssert.AreEqual(expected[i], result[i].ToArray());
}
Assert.ThrowsException <NotSupportedException>(() => ld.Cast2D <decimal>());
}
public void MessageDisembargo()
{
var mb = MessageBuilder.Create();
{
var w = mb.BuildRoot <Message.WRITER>();
w.which = Message.WHICH.Disembargo;
var ctx = w.Disembargo.Context;
ctx.which = Disembargo.context.WHICH.SenderLoopback;
ctx.SenderLoopback = 1234567u;
var tgt = w.Disembargo.Target;
tgt.which = MessageTarget.WHICH.PromisedAnswer;
tgt.PromisedAnswer.QuestionId = 7654321u;
}
var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame));
{
Assert.AreEqual(Message.WHICH.Disembargo, r.which);
Assert.AreEqual(Disembargo.context.WHICH.SenderLoopback, r.Disembargo.Context.which);
Assert.AreEqual(1234567u, r.Disembargo.Context.SenderLoopback);
Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Disembargo.Target.which);
Assert.AreEqual(7654321u, r.Disembargo.Target.PromisedAnswer.QuestionId);
}
}
public void RequireCap2()
{
DeserializerState d = default;
d.Kind = ObjectKind.Capability;
Assert.ThrowsException <InvalidOperationException>(() => d.RequireCap <ITestInterface>());
}
public void StructWithLists()
{
var mb = MessageBuilder.Create(8);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
{
ds.SetStruct(0, 2);
ds.WriteText(0, "Lorem ipsum");
var los = ds.BuildPointer(1);
los.SetListOfStructs(3, 1, 1);
var e0 = los.ListBuildStruct(0);
e0.WriteData(0, long.MinValue);
e0.WriteText(0, long.MinValue.ToString());
var e1 = los.ListBuildStruct(1);
e1.WriteData(0, 0L);
e1.WriteText(0, 0L.ToString());
var e2 = los.ListBuildStruct(2);
e2.WriteData(0, long.MaxValue);
e2.WriteText(0, long.MaxValue.ToString());
}
{
DeserializerState d = ds;
Assert.AreEqual(ObjectKind.Struct, d.Kind);
Assert.AreEqual("Lorem ipsum", d.ReadText(0));
var los = d.ReadListOfStructs(1, _ => _);
Assert.AreEqual(3, los.Count);
Assert.AreEqual(long.MinValue, los[0].ReadDataLong(0));
Assert.AreEqual(long.MinValue.ToString(), los[0].ReadText(0));
Assert.AreEqual(0L, los[1].ReadDataLong(0));
Assert.AreEqual(0L.ToString(), los[1].ReadText(0));
Assert.AreEqual(long.MaxValue, los[2].ReadDataLong(0));
Assert.AreEqual(long.MaxValue.ToString(), los[2].ReadText(0));
}
}
private async Task <T> ReadRowAsyncImplViaDbReader <T>(DbDataReader reader, Type type, Row row)
{
if (reader == null)
{
throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
}
if (IsConsumed)
{
throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
}
IsConsumed = true;
T result = default(T);
if (await reader.ReadAsync(cancel).ConfigureAwait(false) && reader.FieldCount != 0)
{
var typedIdentity = identity.ForGrid(type, gridIndex);
CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
var deserializer = cache.Deserializer;
int hash = GetColumnHash(reader);
if (deserializer.Func == null || deserializer.Hash != hash)
{
deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
cache.Deserializer = deserializer;
}
result = (T)deserializer.Func(reader);
if ((row & Row.Single) != 0 && await reader.ReadAsync(cancel).ConfigureAwait(false))
{
ThrowMultipleRows(row);
}
while (await reader.ReadAsync(cancel).ConfigureAwait(false)) /* ignore subsequent rows */ } {
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
Seconds = reader.Seconds;
applyDefaults();
}
public void ListOfEmpty()
{
var expected = new TestEnum[] { TestEnum.bar, TestEnum.baz, TestEnum.corge };
var b = MessageBuilder.Create();
var loes = b.CreateObject <ListOfEmptySerializer>();
loes.Init(12345678);
DeserializerState d = loes;
var ld = d.RequireList();
Assert.AreEqual(ListKind.ListOfEmpty, ld.Kind);
if (!(ld is ListOfEmptyDeserializer loed))
{
Assert.Fail("List did not deserialize back to ListOfEmptyDeserializer");
return;
}
Assert.AreEqual(12345678, loed.Count);
Assert.ThrowsException <IndexOutOfRangeException>(() => { var _ = loed[-1]; });
Assert.ThrowsException <IndexOutOfRangeException>(() => { var _ = loed[12345678]; });
_ = loed[12345677];
var kind = loed.Cast(_ => _.Kind).Take(1).Single();
Assert.AreEqual(ObjectKind.Nil, kind);
}
public void MessageReturn()
{
var mb = MessageBuilder.Create();
{
var w = mb.BuildRoot <Message.WRITER>();
w.which = Message.WHICH.Return;
w.Return.which = Return.WHICH.Results;
w.Return.Results.CapTable.Init(1);
w.Return.Results.CapTable[0].which = CapDescriptor.WHICH.SenderHosted;
w.Return.Results.CapTable[0].SenderHosted = 0x22222222;
var content = w.Return.Results.Content.Rewrap <DynamicSerializerState>();
content.SetStruct(2, 0);
content.WriteData(0, double.MinValue);
content.WriteData(64, double.MaxValue);
Assert.IsTrue(w.Return.ReleaseParamCaps);
w.Return.ReleaseParamCaps = false;
}
var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame));
{
Assert.AreEqual(Message.WHICH.Return, r.which);
Assert.AreEqual(Return.WHICH.Results, r.Return.which);
Assert.AreEqual(1, r.Return.Results.CapTable.Count);
Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, r.Return.Results.CapTable[0].which);
Assert.AreEqual(0x22222222u, r.Return.Results.CapTable[0].SenderHosted);
Assert.AreEqual(double.MinValue, r.Return.Results.Content.ReadDataDouble(0));
Assert.AreEqual(double.MaxValue,
r.Return.Results.Content.ReadDataDouble(64));
Assert.IsFalse(r.Return.ReleaseParamCaps);
}
}
public void Issue20()
{
RpcRequest <ArithmeticOperationRequest> rpcRequest = new RpcRequest <ArithmeticOperationRequest>();
rpcRequest.Method = "AddTwoNumbers";
ArithmeticOperationRequest request = new ArithmeticOperationRequest();
request.NumA = 5;
request.NumB = 8;
rpcRequest.Request = request;
var msg = MessageBuilder.Create();
var root = msg.BuildRoot <RpcRequest <ArithmeticOperationRequest> .WRITER>();
rpcRequest.serialize(root);
var mems = new MemoryStream();
var pump = new FramePump(mems);
pump.Send(msg.Frame);
mems.Seek(0, SeekOrigin.Begin);
var frame = Framing.ReadSegments(mems);
var deserializer = DeserializerState.CreateRoot(frame);
var mainRequest = new RpcRequest <ArithmeticOperationRequest> .READER(deserializer);
var innerRequest = new ArithmeticOperationRequest.READER(mainRequest.Request);
Console.WriteLine("Method Name: " + mainRequest.Method);
Console.WriteLine("NumA: " + innerRequest.NumA.ToString());
Console.WriteLine("NumB: " + innerRequest.NumB.ToString());
}
public void MessageAccept()
{
var mb = MessageBuilder.Create();
{
var w = mb.BuildRoot <Message.WRITER>();
w.which = Message.WHICH.Accept;
Assert.AreEqual(Message.WHICH.Accept, w.which);
w.Accept.Embargo = true;
Assert.IsTrue(w.Accept.Embargo);
w.Accept.Provision.SetStruct(2, 0);
w.Accept.Provision.WriteData(0, long.MinValue);
w.Accept.Provision.WriteData(64, long.MaxValue);
Assert.AreEqual(long.MinValue, w.Accept.Provision.ReadDataLong(0));
Assert.AreEqual(long.MaxValue, w.Accept.Provision.ReadDataLong(64));
w.Accept.QuestionId = 0x87654321u;
Assert.AreEqual(0x87654321u, w.Accept.QuestionId);
}
var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame));
Assert.AreEqual(Message.WHICH.Accept, r.which);
Assert.IsTrue(r.Accept.Embargo);
Assert.AreEqual(ObjectKind.Struct, r.Accept.Provision.Kind);
Assert.AreEqual(long.MinValue, r.Accept.Provision.ReadDataLong(0));
Assert.AreEqual(long.MaxValue, r.Accept.Provision.ReadDataLong(64));
Assert.AreEqual(0x87654321u, r.Accept.QuestionId);
}
public void MessageProvide()
{
var mb = MessageBuilder.Create();
{
var w = mb.BuildRoot <Message.WRITER>();
w.which = Message.WHICH.Provide;
w.Provide.QuestionId = 0xbbbbbbbb;
w.Provide.Recipient.SetStruct(1, 0);
w.Provide.Recipient.WriteData(0, -1);
w.Provide.Target.which = MessageTarget.WHICH.PromisedAnswer;
w.Provide.Target.PromisedAnswer.QuestionId = 0xcccccccc;
w.Provide.Target.PromisedAnswer.Transform.Init(1);
w.Provide.Target.PromisedAnswer.Transform[0].which = PromisedAnswer.Op.WHICH.Noop;
}
var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame));
{
Assert.AreEqual(Message.WHICH.Provide, r.which);
Assert.AreEqual(0xbbbbbbbb, r.Provide.QuestionId);
Assert.AreEqual(-1, r.Provide.Recipient.ReadDataInt(0));
Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Provide.Target.which);
Assert.AreEqual(0xcccccccc, r.Provide.Target.PromisedAnswer.QuestionId);
Assert.AreEqual(1, r.Provide.Target.PromisedAnswer.Transform.Count);
Assert.AreEqual(PromisedAnswer.Op.WHICH.Noop, r.Provide.Target.PromisedAnswer.Transform[0].which);
}
}
public void MessageJoin()
{
var mb = MessageBuilder.Create();
{
var w = mb.BuildRoot <Message.WRITER>();
w.which = Message.WHICH.Join;
w.Join.KeyPart.SetStruct(2, 0);
w.Join.KeyPart.WriteData(0, long.MinValue);
w.Join.KeyPart.WriteData(64, long.MaxValue);
w.Join.QuestionId = 0x88888888;
w.Join.Target.which = MessageTarget.WHICH.ImportedCap;
w.Join.Target.ImportedCap = 0x99999999;
}
var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame));
{
Assert.AreEqual(Message.WHICH.Join, r.which);
Assert.AreEqual(ObjectKind.Struct, r.Join.KeyPart.Kind);
Assert.AreEqual(long.MinValue, r.Join.KeyPart.ReadDataLong(0));
Assert.AreEqual(long.MaxValue, r.Join.KeyPart.ReadDataLong(64));
Assert.AreEqual(0x88888888, r.Join.QuestionId);
Assert.AreEqual(MessageTarget.WHICH.ImportedCap, r.Join.Target.which);
Assert.AreEqual(0x99999999, r.Join.Target.ImportedCap);
}
}
public void ListOfSBytesAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(8, 10);
ds.ListWriteValue(1, (sbyte)-1);
ds.ListWriteValue(2, (sbyte)-2);
ds.ListWriteValue(3, (sbyte)-3);
ds.ListWriteValue(4, (sbyte)-4);
ds.ListWriteValue(5, (sbyte)-5);
ds.ListWriteValue(6, (sbyte)-6);
ds.ListWriteValue(7, (sbyte)-7);
ds.ListWriteValue(8, (sbyte)-8);
ds.ListWriteValue(9, (sbyte)-9);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(10, asListOfStructs.Count);
Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind);
Assert.AreEqual((sbyte)0, asListOfStructs[0].ReadDataSByte(0));
Assert.AreEqual((sbyte)-1, asListOfStructs[1].ReadDataSByte(0));
Assert.AreEqual((sbyte)-2, asListOfStructs[2].ReadDataSByte(0));
Assert.AreEqual((sbyte)-3, asListOfStructs[3].ReadDataSByte(0));
Assert.AreEqual((sbyte)-4, asListOfStructs[4].ReadDataSByte(0));
Assert.AreEqual((sbyte)-5, asListOfStructs[5].ReadDataSByte(0));
Assert.AreEqual((sbyte)-6, asListOfStructs[6].ReadDataSByte(0));
Assert.AreEqual((sbyte)-7, asListOfStructs[7].ReadDataSByte(0));
Assert.AreEqual((sbyte)-8, asListOfStructs[8].ReadDataSByte(0));
Assert.AreEqual((sbyte)-9, asListOfStructs[9].ReadDataSByte(0));
}
private T ReadFirstOrDefaultImpl <T>(Type type)
{
if (reader == null)
{
throw new ObjectDisposedException(GetType().FullName, "The reader has been disposed; this can happen after all data has been consumed");
}
if (IsConsumed)
{
throw new InvalidOperationException("Query results must be consumed in the correct order, and each result can only be consumed once");
}
IsConsumed = true;
T result = default(T);
if (reader.Read())
{
var typedIdentity = identity.ForGrid(type, gridIndex);
CacheInfo cache = GetCacheInfo(typedIdentity, null, addToCache);
var deserializer = cache.Deserializer;
int hash = GetColumnHash(reader);
if (deserializer.Func == null || deserializer.Hash != hash)
{
deserializer = new DeserializerState(hash, GetDeserializer(type, reader, 0, -1, false));
cache.Deserializer = deserializer;
}
result = (T)deserializer.Func(reader);
while (reader.Read())
{
}
}
NextResult();
return(result);
}
public void NestedLists3DVoid()
{
var expected = new int[][] {
new int[] { 1, 2, 3 },
new int[] { 4, 5 },
new int[] { 6 }
};
var b = MessageBuilder.Create();
var s = b.CreateObject <ListOfPointersSerializer <ListOfPointersSerializer <ListOfEmptySerializer> > >();
s.Init(expected.Length);
for (int i = 0; i < expected.Length; i++)
{
s[i].Init(expected[i], (l, j) => l.Init(j));
}
DeserializerState d = s;
var voids = d.RequireList().CastVoid3D();
Assert.AreEqual(expected.Length, voids.Count);
for (int i = 0; i < expected.Length; i++)
{
CollectionAssert.AreEqual(expected[i], voids[i].ToArray());
}
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
List = reader.List?.ToReadOnlyList(_ => CapnpSerializable.Create <Mas.Schema.Soil.SoilCharacteristicModifier.Data>(_));
applyDefaults();
}
public void List2D()
{
var mb = MessageBuilder.Create(128);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
int w = 4;
int h = 5;
ds.SetListOfPointers(w);
for (int i = 0; i < w; i++)
{
var p = ds.BuildPointer(i);
p.SetListOfValues(32, h);
for (int j = 0; j < h; j++)
{
p.ListWriteValue(j, i - j);
}
}
DeserializerState d = ds;
var matrix = d.RequireList().Cast2D <int>();
Assert.AreEqual(matrix.Count, w);
for (int i = 0; i < w; i++)
{
var v = matrix[i];
Assert.AreEqual(h, v.Count);
for (int j = 0; j < h; j++)
{
Assert.AreEqual(i - j, v[j]);
}
}
}
public async override Task <AnswerOrCounterquestion> Invoke(
ulong interfaceId, ushort methodId, DeserializerState args,
CancellationToken cancellationToken = default)
{
var promisedAnswer = Proxy.Call(interfaceId, methodId, (DynamicSerializerState)args, false);
if (promisedAnswer is PendingQuestion pendingQuestion && pendingQuestion.RpcEndpoint == Impatient.AskingEndpoint)
{
async void SetupCancellation()
{
try
{
using (var registration = cancellationToken.Register(promisedAnswer.Dispose))
{
await promisedAnswer.WhenReturned;
}
}
catch
{
}
}
SetupCancellation();
return(pendingQuestion);
}
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_);
Data = CapnpSerializable.Create <TPayload>(reader.Data);
NoFurtherJobs = reader.NoFurtherJobs;
applyDefaults();
}
public TestCallContext(ulong interfaceId, ushort methodId, DeserializerState args, CancellationToken ct)
{
InterfaceId = interfaceId;
MethodId = methodId;
Args = args;
Ct = ct;
Result = new TaskCompletionSource <AnswerOrCounterquestion>();
}
public override Task <AnswerOrCounterquestion> Invoke(ulong interfaceId, ushort methodId,
DeserializerState args, CancellationToken cancellationToken = default(CancellationToken))
{
var cc = new CallContext(interfaceId, methodId, args, cancellationToken);
Assert.IsTrue(_ccs.Post(cc));
return(cc.Result.Task);
}
