internal ListOfPrimitivesDeserializer(ref DeserializerState state, ListKind kind) :
base(ref state)
{
_kind = kind;
var binCoder = PrimitiveCoder.Get <T>();
}
/// <summary>
/// Constructs a state representing a message root object.
/// </summary>
/// <param name="frame">the message</param>
/// <returns></returns>
public static DeserializerState CreateRoot(WireFrame frame)
{
var state = new DeserializerState(frame.Segments);
state.DecodePointer(0);
return(state);
}
void ICapnpSerializable.Deserialize(DeserializerState arg_)
{
var reader = READER.create(arg_);
SealFor = CapnpSerializable.Create <TOwner>(reader.SealFor);
applyDefaults();
}
public object Create(DeserializerState state)
{
var result = new T();
if (state.Kind != ObjectKind.Nil)
{
result.Deserialize(state);
}
return(result);
}
static object?CreateFromAny(DeserializerState state)
{
switch (state.Kind)
{
case ObjectKind.Capability: return(state.RequireCap <Rpc.BareProxy>());
case ObjectKind.Nil: return(null);
default: return(state);
}
}
/// <summary>
/// Constructs a domain object from a given deserializer state.
/// </summary>
/// <typeparam name="T">Type of domain object to construct. Must be one of the following:
/// <list type="bullet">
/// <item><description>Type implementing <see cref="ICapnpSerializable"/>. The type must must have a public parameterless constructor.</description></item>
/// <item><description>A capability interface (<seealso cref="Rpc.InvalidCapabilityInterfaceException"/> for further explanation)</description></item>
/// <item><description><see cref="string"/></description></item>
/// <item><description>IReadOnlyList<bool>, IReadOnlyList<sbyte>, IReadOnlyList<byte></description></item>
/// <item><description>IReadOnlyList<short>, IReadOnlyList<ushort>, IReadOnlyList<int></description></item>
/// <item><description>IReadOnlyList<uint>, IReadOnlyList<long>, IReadOnlyList<ulong></description></item>
/// <item><description>IReadOnlyList<float>, IReadOnlyList<double></description></item>
/// <item><description>IReadOnlyList<T> whereby T is one of the things listed here.</description></item>
/// </list>
/// </typeparam>
/// <param name="state">deserializer state to construct from</param>
/// <returns>The domain object instance. Nullability note: The returned reference may be null if
/// <paramref name="state"/> represents the nil object.</returns>
/// <exception cref="ArgumentException">Cannot construct object of type <typeparamref name="T"/></exception>
/// <remarks>Note that capability ownership is moved to the domain object</remarks>
public static T?Create <T>(DeserializerState state)
where T : class
{
try
{
return((T?)GetSerializer(typeof(T))(state));
}
catch (TargetInvocationException ex)
{
throw new ArgumentException("Failed to construct domain object", ex);
}
}
Task <AnswerOrCounterquestion> Save(DeserializerState d_, CancellationToken cancellationToken_)
{
using (d_)
{
return(Impatient.MaybeTailCall(Impl.Save(CapnpSerializable.Create <Capnp.Persistent <TSturdyRef, TOwner> .SaveParams>(d_), cancellationToken_), r_ =>
{
var s_ = SerializerState.CreateForRpc <Capnp.Persistent <TSturdyRef, TOwner> .SaveResults.WRITER>();
r_.serialize(s_);
return s_;
}
));
}
}
/// <summary>
/// Attempts to interpret this instance as List(U) whereby U is a struct, applying a selector function to each element.
/// </summary>
/// <param name="cons">Selector function</param>
/// <returns>The desired representation</returns>
public override IReadOnlyList <U> Cast <U>(Func <DeserializerState, U> cons)
{
switch (Marshal.SizeOf <T>())
{
case 1: return(PrimitiveCast <byte>().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))));
case 2: return(PrimitiveCast <ushort>().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))));
case 4: return(PrimitiveCast <uint>().LazyListSelect(x => cons(DeserializerState.MakeValueState(x))));
case 8: return(new ListOfULongAsStructView <U>(PrimitiveCast <ulong>(), cons));
default:
throw new InvalidProgramException("This program path should not be reachable");
}
}
public object Create(DeserializerState state)
{
return(state.RequireList().Cast(_elementSerializer));
}
/// <summary>
/// Constructs a domain object from a given deserializer state.
/// </summary>
/// <typeparam name="T">Type of domain object to construct. Must be one of the following:
/// <list type="bullet">
/// <item><description>Type implementing <see cref="ICapnpSerializable"/>. The type must must have a public parameterless constructor.</description></item>
/// <item><description>A capability interface (<seealso cref="Rpc.InvalidCapabilityInterfaceException"/> for further explanation)</description></item>
/// <item><description><see cref="String"/></description></item>
/// <item><description><code>IReadOnlyList{Boolean}</code></description></item>
/// <item><description><code>IReadOnlyList{SByte}"</code></description></item>
/// <item><description><code>IReadOnlyList{Byte}"</code></description></item>
/// <item><description><code>IReadOnlyList{Int16}"</code></description></item>
/// <item><description><code>IReadOnlyList{UInt16}"</code></description></item>
/// <item><description><code>IReadOnlyList{Int32}"</code></description></item>
/// <item><description><code>IReadOnlyList{UInt32}"</code></description></item>
/// <item><description><code>IReadOnlyList{Int64}"</code></description></item>
/// <item><description><code>IReadOnlyList{UInt64}"</code></description></item>
/// <item><description><code>IReadOnlyList{Single}"</code></description></item>
/// <item><description><code>IReadOnlyList{Double}"</code></description></item>
/// <item><description><code>IReadOnlyList{T}</code> whereby T is one of the things listed here.</description></item>
/// </list>
/// </typeparam>
/// <param name="state">deserializer state to construct from</param>
/// <returns>The domain object instance. Nullability note: The returned reference will be null if (and only if) <typeparamref name="T"/> is a capability interface and
/// <paramref name="state"/> represents the nil object (obtained from a null pointer). For all other types, when the state is nil,
/// the method still constructs a valid but "empty" object instance (such as domain object without any properties set, empty string, empty list etc.)</returns>
public static T?Create <T>(DeserializerState state)
where T : class
{
return((T?)GetSerializer(typeof(T))(state));
}
internal ListOfCapsDeserializer(ref DeserializerState state) : base(ref state)
{
Rpc.CapabilityReflection.ValidateCapabilityInterface(typeof(T));
}
/// <summary>
/// Performs a deep copy of an existing deserializer state into another serializer state.
/// This implementation does not analyze the source object graph and therefore cannot detect multiple references to the same object.
/// Such cases will result in object duplication.
/// </summary>
/// <param name="from">source state</param>
/// <param name="to">target state</param>
/// <exception cref="ArgumentNullException"><paramref name="to"/> is null.</exception>
/// <exception cref="InvalidOperationException">Target state was already set to a different object type than the source state.</exception>
/// <exception cref="DeserializationException">Security violation due to amplification attack or stack overflow DoS attack,
/// or illegal pointer detected during deserialization.</exception>
public static void DeepCopy(DeserializerState from, SerializerState to)
{
if (to == null)
{
throw new ArgumentNullException(nameof(to));
}
if (from.Caps != null && to.Caps != null)
{
to.Caps.Clear();
to.Caps.AddRange(from.Caps);
}
var ds = to.Rewrap <DynamicSerializerState>();
IReadOnlyList <DeserializerState> items;
switch (from.Kind)
{
case ObjectKind.Struct:
ds.SetStruct(from.StructDataCount, from.StructPtrCount);
ds.Allocate();
from.StructDataSection.CopyTo(ds.StructDataSection);
for (int i = 0; i < from.StructPtrCount; i++)
{
DeepCopy(from.StructReadPointer(i), ds.BuildPointer(i));
}
break;
case ObjectKind.ListOfBits:
ds.SetListOfValues(1, from.ListElementCount);
from.RawData.CopyTo(ds.RawData);
break;
case ObjectKind.ListOfBytes:
ds.SetListOfValues(8, from.ListElementCount);
from.RawData.CopyTo(ds.RawData);
break;
case ObjectKind.ListOfEmpty:
ds.SetListOfValues(0, from.ListElementCount);
break;
case ObjectKind.ListOfInts:
ds.SetListOfValues(32, from.ListElementCount);
from.RawData.CopyTo(ds.RawData);
break;
case ObjectKind.ListOfLongs:
ds.SetListOfValues(64, from.ListElementCount);
from.RawData.CopyTo(ds.RawData);
break;
case ObjectKind.ListOfShorts:
ds.SetListOfValues(16, from.ListElementCount);
from.RawData.CopyTo(ds.RawData);
break;
case ObjectKind.ListOfPointers:
ds.SetListOfPointers(from.ListElementCount);
items = (IReadOnlyList <DeserializerState>)from.RequireList();
for (int i = 0; i < from.ListElementCount; i++)
{
DeepCopy(items[i], ds.BuildPointer(i));
}
break;
case ObjectKind.ListOfStructs:
ds.SetListOfStructs(from.ListElementCount, from.StructDataCount, from.StructPtrCount);
items = (IReadOnlyList <DeserializerState>)from.RequireList();
for (int i = 0; i < from.ListElementCount; i++)
{
DeepCopy(items[i], ds.ListBuildStruct(i));
}
break;
case ObjectKind.Capability:
ds.SetCapability(from.CapabilityIndex);
break;
}
to.InheritFrom(ds);
}
public static READER create(DeserializerState ctx) => new READER(ctx);
public READER(DeserializerState ctx)
{
this.ctx = ctx;
}
public object?Create(DeserializerState state)
{
return(state.RequireCap <T>());
}
internal ListDeserializer(ref DeserializerState state)
{
State = state;
}
internal ListOfBitsDeserializer(ref DeserializerState context, bool defaultValue) :
base(ref context)
{
_defaultValue = defaultValue;
}
public IReadOnlyList <T> Create(DeserializerState state)
{
return(state.RequireList().Cast(_elementSerializer));
}
