public object Deserialize(IParser parser, Type type) { if (parser == null) { throw new ArgumentNullException("reader"); } if (type == null) { throw new ArgumentNullException("type"); } bool flag = parser.Allow <StreamStart>() != null; bool flag2 = parser.Allow <DocumentStart>() != null; object result = null; if (!parser.Accept <DocumentEnd>() && !parser.Accept <StreamEnd>()) { using (SerializerState serializerState = new SerializerState()) { result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer); serializerState.OnDeserialization(); } } if (flag2) { parser.Expect <DocumentEnd>(); } if (flag) { parser.Expect <StreamEnd>(); } return(result); }
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { NodeEvent nodeEvent = parser.Peek <NodeEvent>(); Type typeFromEvent = GetTypeFromEvent(nodeEvent, expectedType); try { foreach (INodeDeserializer deserializer in deserializers) { if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value)) { return(TypeConverter.ChangeType(value, expectedType)); } } } catch (YamlException) { throw; } catch (Exception innerException) { throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", innerException); } throw new YamlException(nodeEvent.Start, nodeEvent.End, $"No node deserializer was able to deserialize the node into type {expectedType.AssemblyQualifiedName}"); }
internal static void SerializeObject(Object obj, WriteOnlyDatagram datagram, SerializerState state) { if (obj == null) { datagram.WriteUInt((uint)SerializedTypeCode.Null, 8); } else if (obj is String) { datagram.WriteUInt((uint)SerializedTypeCode.String, 8); datagram.WriteString(obj as String); } else if (obj is MISP.ScriptList) { datagram.WriteUInt((uint)SerializedTypeCode.List, 8); var filteredList = new MISP.ScriptList( (obj as MISP.ScriptList).Where((o) => IsSerializableType(o))); datagram.WriteUInt((uint)filteredList.Count, 16); foreach (var item in filteredList) SerializeObject(item, datagram, state); } else if (obj is int) { datagram.WriteUInt((uint)SerializedTypeCode.Integer, 8); datagram.WriteUInt((uint)(obj as int?).Value, 32); } else if (obj is MISP.GenericScriptObject) { state.WriteObject(obj as MISP.GenericScriptObject, datagram); } }
public PolymorphicComplexBuilder(Type type, SerializerState state) { _typeDescriptionsByHashCode = new AdaptiveHashtable <TypeDescriptionWithIndex>(); var typeDescriptions = new Dictionary <int, TypeDescriptionWithIndex>(); foreach (var description in state.GetDescriptionsForDerivedTypes(type)) { _typeDescriptionsByHashCode.AddValue( (uint)RuntimeHelpers.GetHashCode(description.Type), new TypeDescriptionWithIndex { Description = description }); if (!typeDescriptions.ContainsKey(description.Type.GetHashCode())) { typeDescriptions.Add(description.Type.GetHashCode(), new TypeDescriptionWithIndex { Description = description }); } } _typeDescriptionsByIndex = new TypeDescription[typeDescriptions.Count]; var index = (byte)0; foreach (var item in typeDescriptions) { item.Value.Index = index; var val = _typeDescriptionsByHashCode.TryGetValue((uint)RuntimeHelpers.GetHashCode(item.Value.Description.Type)); Debug.Assert(val != null, "Type should exist in the type descriptions hash"); val.Index = index; _typeDescriptionsByIndex[index++] = item.Value.Description; } }
public static void EnsureAllocated(SerializerState serializer) { if (!serializer.IsAllocated) { throw new InvalidOperationException("Call Init() first"); } }
public object?DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { parser.Accept <NodeEvent>(out var nodeEvent); var nodeType = GetTypeFromEvent(nodeEvent, expectedType); try { foreach (var deserializer in deserializers) { if (deserializer.Deserialize(parser, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value)) { return(TypeConverter.ChangeType(value, expectedType)); } } } catch (YamlException) { throw; } catch (Exception ex) { throw new YamlException( nodeEvent?.Start ?? Mark.Empty, nodeEvent?.End ?? Mark.Empty, "Exception during deserialization", ex ); } throw new YamlException( nodeEvent?.Start ?? Mark.Empty, nodeEvent?.End ?? Mark.Empty, $"No node deserializer was able to deserialize the node into type {expectedType.AssemblyQualifiedName}" ); }
public static void Deserialize(MISP.GenericScriptObject into, ReadOnlyDatagram from, Database database) { var state = new SerializerState(); state.referencedObjects.Add(0, into); while (from.More) impleDeserialize(from, state, database); }
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { var nodeEvent = reader.Peek <NodeEvent>(); var nodeType = GetTypeFromEvent(nodeEvent, expectedType); try { foreach (var deserializer in deserializers) { object value; if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value)) { return(value); } } } catch (YamlException) { throw; } catch (Exception ex) { throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex); } throw new YamlException( nodeEvent.Start, nodeEvent.End, string.Format( "No node deserializer was able to deserialize the node into type {0}", expectedType.AssemblyQualifiedName ) ); }
public void InterceptClientSideShortCall() { var policy = new MyPolicy("a"); (var server, var client) = SetupClientServerPair(); using (server) using (client) { //client.WhenConnected.Wait(); var counters = new Counters(); server.Main = new TestInterfaceImpl(counters); using (var main = policy.Attach(client.GetMain <ITestInterface>())) { var request1 = main.Foo(321, false, default); Assert.IsTrue(policy.Calls.TryReceive(out var cc)); Assert.IsFalse(request1.IsCompleted); var rw = SerializerState.CreateForRpc <Capnproto_test.Capnp.Test.TestInterface.Result_Foo.WRITER>(); rw.X = "bar"; cc.OutArgs = rw; cc.ReturnToAlice(); Assert.IsTrue(request1.IsCompleted); Assert.AreEqual("bar", request1.Result); } } }
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { var nodeEvent = reader.Peek<NodeEvent>(); var nodeType = GetTypeFromEvent(nodeEvent, expectedType); try { foreach (var deserializer in deserializers) { object value; if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value)) { return value; } } } catch (YamlException) { throw; } catch (Exception ex) { throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex); } throw new YamlException( nodeEvent.Start, nodeEvent.End, string.Format( "No node deserializer was able to deserialize the node into type {0}", expectedType.AssemblyQualifiedName ) ); }
public object Deserialize(EventReader reader, Type type) { if (reader == null) { throw new ArgumentNullException("reader"); } if (type == null) { throw new ArgumentNullException("type"); } bool flag = reader.Allow <StreamStart>() != null; bool flag2 = reader.Allow <DocumentStart>() != null; object obj2 = null; if (!reader.Accept <DocumentEnd>() && !reader.Accept <StreamEnd>()) { using (SerializerState state = new SerializerState()) { obj2 = this.valueDeserializer.DeserializeValue(reader, type, state, this.valueDeserializer); state.OnDeserialization(); } } if (flag2) { reader.Expect <DocumentEnd>(); } if (flag) { reader.Expect <StreamEnd>(); } return(obj2); }
public void DeserializerStateBadConv() { SerializerState s = null; Assert.ThrowsException <ArgumentNullException>(() => (DeserializerState)s); s = new DynamicSerializerState(); Assert.ThrowsException <InvalidOperationException>(() => (DeserializerState)s); }
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> Stop(DeserializerState d_, CancellationToken cancellationToken_) { using (d_) { await Impl.Stop(cancellationToken_); var s_ = SerializerState.CreateForRpc <Mas.Schema.Service.Admin.Result_Stop.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_); } }
internal override MemberDescription[] GetDescriptions(SerializerState state) { var piMap = Type.GetTypeInfo().GetProperties(BindingFlags.Public | BindingFlags.Instance) .ToDictionary(pi => pi.Name); return(Type.GetTypeInfo().GetConstructors()[0] .GetParameters() .Select(p => new PropertyDescription(piMap[p.Name], state) { NestedTypeDescription = Serializer.GetTypeDescription(p.ParameterType, state) }).ToArray()); }
public static WriteOnlyDatagram Serialize(MISP.ScriptObject obj) { var r = new WriteOnlyDatagram(); var state = new SerializerState(); state.referencedObjects.Add(obj); state.referencedObjectsIDs.Add(obj, 0); for (int i = 0; i < state.referencedObjects.Count; ++i) impleSerialize(state.referencedObjects[i], i, r, state); return r; }
internal TypeDescription(ushort typeId, Type type, SerializerState state) { TypeId = typeId; Type = type; _isInitialized = new Lazy <bool>(() => { InitDescriptions(state); InitSerializers(); InitDeserializer(); return(true); }); }
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { object value; var alias = reader.Allow <AnchorAlias>(); if (alias != null) { var aliasState = state.Get <AliasState>(); ValuePromise valuePromise; if (!aliasState.TryGetValue(alias.Value, out valuePromise)) { valuePromise = new ValuePromise(alias); aliasState.Add(alias.Value, valuePromise); } return(valuePromise.HasValue ? valuePromise.Value : valuePromise); } string anchor = null; var nodeEvent = reader.Peek <NodeEvent>(); if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor)) { anchor = nodeEvent.Anchor; } value = innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer); if (anchor != null) { var aliasState = state.Get <AliasState>(); ValuePromise valuePromise; if (!aliasState.TryGetValue(anchor, out valuePromise)) { aliasState.Add(anchor, new ValuePromise(value)); } else if (!valuePromise.HasValue) { valuePromise.Value = value; } else { throw new DuplicateAnchorException(nodeEvent.Start, nodeEvent.End, string.Format( "Anchor '{0}' already defined", anchor )); } } return(value); }
/// <summary> /// AWARENESS: not thread safe /// </summary> /// <param name="reader"></param> /// <param name="expectedType"></param> /// <param name="state"></param> /// <param name="nestedObjectDeserializer"></param> /// <returns></returns> public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { object value = _innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer); if (value is string str && str.Trim() == Constants.ContentPlaceholder) { ContainPlaceholder = true; return(_replacer); } return(value); }
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 SerializerState(SerializationSettings settings, SerializerState previousState) { this.PreviousState = previousState; this.Settings = settings; this.Buffer = BufferPool.Retain(); this.ObjectReferences = new Dictionary <object, int>(); this.ObjectInstances = new List <object>(); this.IsText = Settings.Flags.HasFlag(SerializationFlags.Text); this.WriteOnlyChanged = settings.Flags.HasFlag(SerializationFlags.WriteOnlyChanged); this.LocalOffset = Int32.MaxValue; Retain(); }
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 <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 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; } }
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_; } )); } }
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { object value; var alias = parser.Allow <AnchorAlias>(); if (alias != null) { var aliasState = state.Get <AliasState>(); ValuePromise valuePromise; if (!aliasState.TryGetValue(alias.Value, out valuePromise)) { valuePromise = new ValuePromise(alias); aliasState.Add(alias.Value, valuePromise); } return(valuePromise.HasValue ? valuePromise.Value : valuePromise); } string anchor = null; var nodeEvent = parser.Peek <NodeEvent>(); if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor)) { anchor = nodeEvent.Anchor; } value = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer); if (anchor != null) { var aliasState = state.Get <AliasState>(); ValuePromise valuePromise; if (!aliasState.TryGetValue(anchor, out valuePromise)) { aliasState.Add(anchor, new ValuePromise(value)); } else if (!valuePromise.HasValue) { valuePromise.Value = value; } else { aliasState[anchor] = new ValuePromise(value); } } return(value); }
internal override void InitDescriptions(SerializerState state) { _descriptions = GetDescriptions(state); _orderMapping = new Dictionary <string, int>(); for (var i = 0; i < _descriptions.Length; i++) { _orderMapping[_descriptions[i].Name] = i; } foreach (var description in _descriptions) { description.NestedTypeDescription?.InitDescriptions(state); } }
private void KeepOriginalState(SerializerState state, byte[] bytes) { if (this.OriginalState != null) { this.OriginalState.Release(); } this.OriginalState = state; if (this.OriginalState != null) { this.OriginalState.Retain(); } this.OriginalBytes = bytes; }
Task <AnswerOrCounterquestion> MethodA(DeserializerState d_, CancellationToken cancellationToken_) { return(Impatient.MaybeTailCall(Impl.MethodA(cancellationToken_), result => { var s_ = SerializerState.CreateForRpc <CapnpGen.Issue25A.Result_methodA.WRITER>(); var r_ = new CapnpGen.Issue25A.Result_methodA { Result = result }; r_.serialize(s_); return s_; } )); }
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; } }
/// <summary> /// AWARENESS: not thread safe /// </summary> /// <param name="reader"></param> /// <param name="expectedType"></param> /// <param name="state"></param> /// <param name="nestedObjectDeserializer"></param> /// <returns></returns> public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { object value = _innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer); var str = value as string; if (str != null && str.Trim() == Constants.ContentPlaceholder) { ContainPlaceholder = true; return(_replacer); } return(value); }
internal static void impleSerialize(MISP.ScriptObject obj, int index, WriteOnlyDatagram datagram, SerializerState state) { datagram.WriteUInt((uint)index, 16); var propList = obj.ListProperties(); var filteredList = new List<Object>( propList.Where((o) => { return IsSerializableType(obj.GetLocalProperty(o as String)); })); datagram.WriteUInt((uint)filteredList.Count, 16); foreach (var item in filteredList) { datagram.WriteString(item as String); SerializeObject(obj.GetLocalProperty(item as String), datagram, state); } }
public object DeserializeValue (EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { var nodeEvent = reader.Peek<NodeEvent>(); var nodeType = GetTypeFromEvent(nodeEvent, expectedType); foreach (var deserializer in deserializers) { object value; if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value)) { return value; } } throw new SerializationException( string.Format( "No node deserializer was able to deserialize the node at {0} into type {1}", reader.Parser.Current.Start, expectedType.AssemblyQualifiedName ) ); }
internal static void impleDeserialize(ReadOnlyDatagram datagram, SerializerState state, Database database) { uint index = 0; if (!datagram.ReadUInt(out index, 16)) throw new DeserializeError(); MISP.GenericScriptObject into = null; if (state.referencedObjects.ContainsKey(index)) into = state.referencedObjects[index]; else { into = new MISP.GenericScriptObject(); state.referencedObjects.Add(index, into); } uint propertyCount = 0; if (!datagram.ReadUInt(out propertyCount, 16)) throw new DeserializeError(); for (int i = 0; i < propertyCount; ++i) { String propertyName = ""; Object value = null; if (!datagram.ReadString(out propertyName)) throw new DeserializeError(); value = DeserializeObject(datagram, state, database); into.SetProperty(propertyName, value); } }
internal static Object DeserializeObject(ReadOnlyDatagram datagram, SerializerState state, Database database) { uint rawTypeCode = 0; if (!datagram.ReadUInt(out rawTypeCode, 8)) throw new DeserializeError(); switch ((SerializedTypeCode)rawTypeCode) { case SerializedTypeCode.Null: return null; case SerializedTypeCode.Integer: { uint value = 0; if (!datagram.ReadUInt(out value, 32)) throw new DeserializeError(); return (int)value; } case SerializedTypeCode.String: { String value = ""; if (!datagram.ReadString(out value)) throw new DeserializeError(); return value; } case SerializedTypeCode.List: { uint length = 0; if (!datagram.ReadUInt(out length, 16)) throw new DeserializeError(); var result = new MISP.ScriptList(); for (int i = 0; i < length; ++i) result.Add(DeserializeObject(datagram, state, database)); return result; } case SerializedTypeCode.InternalObject: return state.ReadObject(datagram, SerializedTypeCode.InternalObject, database); case SerializedTypeCode.NamedObject: return state.ReadObject(datagram, SerializedTypeCode.NamedObject, database); default: throw new DeserializeError(); } }