public new static Type1 Read(UnsafeReader reader) { Assert.AreEqual("type1", reader.ReadString()); return(new Type1 { Mark = Guid.NewGuid() }); }
private bool ReadMsg() { long maxSeqnAtStart = myMaxReceivedSeqn; myMsgLengthBuffer.Lo = myMsgLengthBuffer.Hi = 0; if (!myMsgLengthBuffer.Read(ref myPkgBuffer, ReceiveFromPkgBuffer)) { return(false); } Int32 len = UnsafeReader.ReadInt32FromBytes(myMsgLengthBuffer.Data); var msgBuffer = new BufferWindow(len); if (!msgBuffer.Read(ref myPkgBuffer, ReceiveFromPkgBuffer)) { Log.Warn("{0}: Can't read message with len={1} from the wire because connection was shut down", Id, len); return(false); } if (myMaxReceivedSeqn > maxSeqnAtStart) { myAcktor.SendAsync(myMaxReceivedSeqn); } Receive(msgBuffer.Data); ReadBytesCount += len + sizeof(Int32 /*len*/); return(true); }
public static RdList <V> Read(SerializationCtx ctx, UnsafeReader reader, CtxReadDelegate <V> readValue, CtxWriteDelegate <V> writeValue) { var nextVersion = reader.ReadLong(); var id = reader.ReadRdId(); return(new RdList <V>(readValue, writeValue, nextVersion).WithId(id)); }
private static IHierarchyElement ReadHieraerchyElement(UnsafeReader reader) { switch (reader.ReadInt32()) { case 0: return(GameObjectHierarchy.Read(reader)); case 1: return(ComponentHierarchy.Read(reader)); case 2: return(PrefabInstanceHierarchy.Read(reader)); case 3: return(ScriptComponentHierarchy.Read(reader)); case 4: return(StrippedHierarchyElement.Read(reader)); case 5: return(TransformHierarchy.Read(reader)); default: throw new InvalidOperationException("Unknown type"); } }
private static UnityEventHandlerCacheItem Read(UnsafeReader reader) { var assetGuid = reader.ReadString(); var referenceShortName = reader.ReadString(); return(new UnityEventHandlerCacheItem(assetGuid, referenceShortName)); }
public override void OnWireReceived(UnsafeReader reader) { var version = reader.ReadInt(); var value = ReadValueDelegate(SerializationContext, reader); var rejected = IsMaster && version < myMasterVersion; if (LogReceived.IsTraceEnabled()) { LogReceived.Trace("property `{0}` ({1}):: oldver = {2}, newver = {3}, value = {4}{5}", Location, RdId, myMasterVersion, version, value.PrintToString(), rejected ? " REJECTED" : ""); } if (rejected) { return; } myMasterVersion = version; using (UsingDebugInfo()) { myProperty.Value = value; } }
public static Filter Read(UnsafeReader reader) { var name = reader.ReadString(); var offset = reader.ReadInt(); return(new Filter(name, offset)); }
private static AngularJsCacheItems Read(UnsafeReader reader) { var directives = reader.ReadCollection(Directive.Read, count => new List <Directive>(count)); var filters = reader.ReadCollection(Filter.Read, count => new List <Filter>(count)); return(new AngularJsCacheItems(directives, filters)); }
//received response from wire public void OnWireReceived(UnsafeReader reader) { var resultFromWire = RdTaskResult <TRes> .Read(myCall.ReadResponseDelegate, myCall.SerializationContext, reader); if (RdReactiveBase.LogReceived.IsTraceEnabled()) { RdReactiveBase.LogReceived.Trace($"call {myCall.Location} ({myCall.RdId}) received response for task '{RdId}' : {resultFromWire.PrintToString()}"); } Scheduler.Queue(() => { using (myCall.UsingDebugInfo()) { if (ResultInternal.SetIfEmpty(resultFromWire)) { return; } } //trace if (RdReactiveBase.LogReceived.IsTraceEnabled()) { RdReactiveBase.LogReceived.Trace($"call {myCall.Location} ({myCall.RdId}) response for task '{RdId}' was dropped, because task already has result: {Result.Value}"); } myLifetimeDef.Terminate(); //todo not true in case of bindable entities }); }
public static TransformHierarchy Read(UnsafeReader reader) { return(new TransformHierarchy(HierarchyReferenceUtil.ReadLocalReferenceFrom(reader), HierarchyReferenceUtil.ReadLocalReferenceFrom(reader), HierarchyReferenceUtil.ReadLocalReferenceFrom(reader), reader.ReadInt32())); }
public static Base Read(UnsafeReader reader) { Assert.AreEqual("base", reader.ReadString()); return(new Base { Mark = Guid.NewGuid() }); }
public SpecflowStepsDefinitionsCacheEntries Unmarshal(UnsafeReader reader) { var entries = new SpecflowStepsDefinitionsCacheEntries(); var classCount = reader.ReadInt(); for (var i = 0; i < classCount; i++) { var className = reader.ReadString(); var cacheClassEntry = new SpecflowStepDefinitionCacheClassEntry(className); var methodCount = reader.ReadInt(); for (var j = 0; j < methodCount; j++) { var methodName = reader.ReadString(); var methodCacheEntry = cacheClassEntry.AddMethod(methodName); var stepCount = reader.ReadInt(); for (var k = 0; k < stepCount; k++) { var type = reader.ReadInt(); var pattern = reader.ReadString(); methodCacheEntry.AddStep((GherkinStepKind)type, pattern); } } entries.Add(cacheClassEntry); } return(entries); }
public T ReadValue(SerializationCtx context, UnsafeReader reader) { var hasValue = reader.ReadBool(); if (!hasValue) { return(default);
public static ScriptComponentHierarchy Read(UnsafeReader reader) { return(new ScriptComponentHierarchy( HierarchyReferenceUtil.ReadLocalReferenceFrom(reader), HierarchyReferenceUtil.ReadLocalReferenceFrom(reader), HierarchyReferenceUtil.ReadExternalReferenceFrom(reader))); }
public static RdEndpoint <TReq, TRes> Read(SerializationCtx ctx, UnsafeReader reader, CtxReadDelegate <TReq> readRequest, CtxWriteDelegate <TReq> writeRequest, CtxReadDelegate <TRes> readResponse, CtxWriteDelegate <TRes> writeResponse) { var id = reader.ReadRdId(); return(new RdEndpoint <TReq, TRes>(readRequest, writeRequest, readResponse, writeResponse).WithId(id)); // throw new InvalidOperationException("Deserialization of RdEndpoint is not allowed, the only valid option is to create RdEndpoint with constructor."); }
private static unsafe bool TryReadInt(UnsafeReader reader, out int step) { if (!reader.IsEmpty) { var a = reader.Current; if (a >= '0' && a <= '9') { reader.MoveNext(); step = a - '0'; if (!reader.IsEmpty) { var b = reader.Current; if (b >= '0' && b <= '9') { reader.MoveNext(); step = (step * 10) + (b - '0'); } } return(true); } } step = 0; return(false); }
public override void OnWireReceived(UnsafeReader reader) //endpoint's side { var taskId = RdId.Read(reader); var wiredTask = new WiredRdTask <TReq, TRes> .Endpoint(myBindLifetime, this, taskId, myCancellationScheduler ?? SynchronousScheduler.Instance); //subscribe for lifetime cancellation var externalCancellation = wiredTask.Lifetime; using (UsingDebugInfo()) //now supports only sync handlers { RdTask <TRes> rdTask; try { var value = ReadRequestDelegate(SerializationContext, reader); ReceiveTrace?.Log($"{wiredTask} :: received request: {value.PrintToString()}"); var handler = Handler; if (handler == null) { var message = $"Handler is not set for {wiredTask} :: received request: {value.PrintToString()}"; ourLogReceived.Error(message); rdTask = RdTask <TRes> .Faulted(new Exception(message)); } else { try { rdTask = handler(externalCancellation, value); } catch (Exception ex) { rdTask = RdTask <TRes> .Faulted(ex); } } } catch (Exception e) { rdTask = RdTask <TRes> .Faulted(new Exception($"Unexpected exception in {wiredTask}", e)); } rdTask.Result.Advise(Lifetime.Eternal, result => { try { if (result.Status == RdTaskStatus.Success) { AssertNullability(result.Result); } wiredTask.ResultInternal.SetIfEmpty(result); } catch (Exception ee) { ourLogSend.Error($"Problem when responding to `{wiredTask}`", ee); wiredTask.Set(new RdFault(ee)); } }); } }
public override void OnWireReceived(UnsafeReader reader) { var contextBase = RdContextBase.Read(SerializationContext, reader); contextBase.RegisterOn(this); myCounterpartHandlers.Add(myHandlersMap[contextBase]); }
private static AsmDefCacheItem Read(UnsafeReader reader) { var name = reader.ReadString(); var declarationOffset = reader.ReadInt(); var references = UnsafeMarshallers.StringArrayMarshaller.Unmarshal(reader); return(new AsmDefCacheItem(name, declarationOffset, references)); }
public static RdFault Read(SerializationCtx ctx, UnsafeReader reader) { var typeFqn = reader.ReadString(); var message = reader.ReadString(); var body = reader.ReadString(); return(new RdFault(typeFqn, message, body)); }
public override void OnWireReceived(UnsafeReader reader) { var value = myReadValue(SerializationContext, reader); ReceiveTrace?.Log($"{this} :: value = {value.PrintToString()}"); using (UsingDebugInfo()) mySignal.Fire(value); }
public override void OnWireReceived(UnsafeReader reader) { var taskId = RdId.Read(reader); var value = ReadRequestDelegate(SerializationContext, reader); if (LogReceived.IsTraceEnabled()) { LogReceived.Trace("endpoint `{0}`::({1}), taskId={2}, request = {3}", Location, RdId, taskId, value.PrintToString()); } RdTask <TRes> rdTask; using (UsingDebugInfo()) //now supports only sync handlers { try { rdTask = Handler(myBindLifetime, value); } catch (OperationCanceledException) { rdTask = RdTask <TRes> .Cancelled(); } catch (Exception e) { rdTask = RdTask <TRes> .Faulted(e); } } rdTask.Result.Advise(myBindLifetime, result => { if (LogSend.IsTraceEnabled()) { LogSend.Trace("endpoint `{0}`::({1}), taskId={2}, response = {3}", Location, RdId, taskId, result.PrintToString()); } RdTaskResult <TRes> validatedResult; try { if (result.Status == RdTaskStatus.Success) { AssertNullability(result.Result); } validatedResult = result; } catch (Exception e) { LogSend.Error(e); validatedResult = RdTaskResult <TRes> .Faulted(e); } Wire.Send(RdId, (writer) => { taskId.Write(writer); RdTaskResult <TRes> .Write(WriteResponseDelegate, SerializationContext, writer, validatedResult); }); }); }
public static AnimatorStateScriptUsage ReadFrom([NotNull] UnsafeReader reader) { var animatorStateReference = HierarchyReferenceUtil.ReadLocalReferenceFrom(reader); var animatorStateName = reader.ReadString(); var stateMachineBehavioursAnchors = ReadStateMachineBehavioursAnchors(reader); return(new AnimatorStateScriptUsage(animatorStateReference, animatorStateName ?? "", stateMachineBehavioursAnchors)); }
private static ComponentHierarchyElement Read(UnsafeReader reader) { return(new ComponentHierarchyElement( FileID.ReadFrom(reader), FileID.ReadFrom(reader), FileID.ReadFrom(reader), FileID.ReadFrom(reader), reader.ReadBool())); }
public static T ReadEnum <T>(SerializationCtx ctx, UnsafeReader reader) where T : #if !NET35 unmanaged, #endif Enum { Assertion.Assert(typeof(T).IsSubclassOf(typeof(Enum)), "{0}", typeof(T)); return(Cast32BitEnum <T> .FromInt(reader.ReadInt())); }
public T ReadInterned <T>(UnsafeReader stream, string internKey, CtxReadDelegate <T> readValueDelegate) { if (!InternRoots.TryGetValue(internKey, out var interningRoot)) { return(readValueDelegate(this, stream)); } return(interningRoot.UnIntern <T>(stream.ReadInt() ^ 1)); }
public static Parameter Read(UnsafeReader reader) { var name = reader.ReadString(); var type = reader.ReadString(); var isOptional = reader.ReadBoolean(); var description = reader.ReadString(); var defaultValue = reader.ReadString(); return new Parameter(name, type, isOptional, description, defaultValue); }
public static LocalReference ReadLocalReferenceFrom(UnsafeReader reader) { var id = reader.ReadInt(); if (id != 0) { throw new InvalidOperationException($"Expected local reference, found {id}"); } return(new LocalReference(AssetUtils.ReadOWORD(reader), reader.ReadLong())); }
public static ExternalReference ReadExternalReferenceFrom(UnsafeReader reader) { var id = reader.ReadInt(); if (id != 1) { throw new InvalidOperationException($"Expected external reference, found {id}"); } return(new ExternalReference(reader.ReadGuid(), reader.ReadLong())); }
public SpecflowSettings Unmarshal(UnsafeReader reader) { var settings = new SpecflowSettings(); settings.Language.Feature = reader.ReadString(); settings.Language.Tool = reader.ReadString(); settings.BindingCulture.Name = reader.ReadString(); return(settings); }
public static Directive Read(UnsafeReader reader) { var originalName = reader.ReadString(); var name = reader.ReadString(); var restrictions = reader.ReadString(); var tags = reader.ReadArray(UnsafeReader.StringDelegate); var offset = reader.ReadInt(); var parameters = reader.ReadCollection(Parameter.Read, count => new List<Parameter>(count)); return new Directive(originalName, name, restrictions, tags, offset, parameters); }
private static void ParseRule(UnsafeReader reader, int min, int max) { if (ParseListItem(reader, min, max)) { for (; reader.MoveNextIf(',') && ParseListItem(reader, min, max);) { ; } } }
private static AngularJsCacheItems Read(UnsafeReader reader) { var directives = reader.ReadCollection(Directive.Read, count => new List<Directive>(count)); var filters = reader.ReadCollection(Filter.Read, count => new List<Filter>(count)); return new AngularJsCacheItems(directives, filters); }
public static Filter Read(UnsafeReader reader) { var name = reader.ReadString(); var offset = reader.ReadInt(); return new Filter(name, offset); }