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 SpecflowStepsUsagesCacheEntries Unmarshal(UnsafeReader reader) { var entries = new SpecflowStepsUsagesCacheEntries(); var count = reader.ReadInt(); for (var i = 0; i < count; i++) { var type = reader.ReadInt(); var stepText = reader.ReadString(); entries.Add(new SpecflowStepUsageCacheEntry((GherkinStepKind)type, stepText)); } return(entries); }
private static object Read(UnsafeReader reader) { var target = HierarchyReferenceUtil.ReadReferenceFrom(reader); var path = reader.ReadString(); var value = reader.ReadPolymorphic <IAssetValue>(); var range = new TextRange(reader.ReadInt(), reader.ReadInt()); IHierarchyReference objectReference = null; if (reader.ReadBool()) { objectReference = HierarchyReferenceUtil.ReadReferenceFrom(reader); } return(new PrefabModification(target, path, value, range, objectReference)); }
public LinkedNamesData Unmarshal([NotNull] UnsafeReader reader) { var linkData = new LinkedNamesData(); var count = reader.ReadInt(); for (var i = 0; i < count; i++) { var sourceType = reader.ReadString(); var listCount = reader.ReadInt(); var linkedTypes = Enumerable.Range(start: 0, count: listCount).Select(x => reader.ReadString()); linkData.AddValueRange(sourceType, linkedTypes); } return(linkData); }
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 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 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 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 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 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())); }
private static LocalList <long> ReadAnchors([NotNull] UnsafeReader reader) { var stateMachineBehavioursAnchorsCount = reader.ReadInt(); var stateMachineBehavioursAnchors = new LocalList <long>(stateMachineBehavioursAnchorsCount); for (var i = 0; i < stateMachineBehavioursAnchorsCount; i++) { stateMachineBehavioursAnchors.Add(reader.ReadLong()); } return(stateMachineBehavioursAnchors); }
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)); }
public static UnityEventData ReadFrom(UnsafeReader reader) { var name = reader.ReadString(); var location = HierarchyReferenceUtil.ReadLocalReferenceFrom(reader); var scriptReference = HierarchyReferenceUtil.ReadExternalReferenceFrom(reader); var count = reader.ReadInt(); var calls = new List <AssetMethodUsages>(); for (int i = 0; i < count; i++) { calls.Add(AssetMethodUsages.ReadFrom(reader)); } return(new UnityEventData(name, location, scriptReference, calls)); }
public static IHierarchyReference ReadReferenceFrom(UnsafeReader reader) { var id = reader.ReadInt(); if (id == 0) { return(new LocalReference(AssetUtils.ReadOWORD(reader), reader.ReadLong())); } if (id == 1) { return(new ExternalReference(reader.ReadGuid(), reader.ReadLong())); } throw new InvalidOperationException($"Unknown reference type, {id}"); }
public static RdTaskResult <T> Read(CtxReadDelegate <T> readDelegate, SerializationCtx ctx, UnsafeReader reader) { var status = (RdTaskStatus)reader.ReadInt(); switch (status) { case RdTaskStatus.Success: return(Success(readDelegate(ctx, reader))); case RdTaskStatus.Canceled: return(Cancelled()); case RdTaskStatus.Faulted: return(Faulted(RdFault.Read(ctx, reader))); default: throw new ArgumentOutOfRangeException($"Unknown status of {nameof(RdTaskStatus)}: {status}"); } }
public static AnimationUsage ReadFrom([NotNull] UnsafeReader reader) { var animationReference = HierarchyReferenceUtil.ReadLocalReferenceFrom(reader); var animationName = reader.ReadString(); var sampleRate = reader.ReadInt(); var functionName = reader.ReadString(); if (animationName is null || functionName is null) { return(null); } var time = reader.ReadDouble(); var guid = reader.ReadGuid(); return(new AnimationUsage(animationReference, animationName, sampleRate, functionName, time, guid)); }
public T Read <T>(SerializationCtx ctx, UnsafeReader reader, [CanBeNull] CtxReadDelegate <T> unknownInstanceReader = null) { bool TryGetReader(RdId rdId, out CtxReadDelegate <object> readDelegate) { lock (myLock) return(myReaders.TryGetValue(rdId, out readDelegate)); } #if !NET35 myBackgroundRegistrar.WaitForEmpty(); #endif var typeId = RdId.Read(reader); if (typeId.IsNil) { return(default(T)); } var size = reader.ReadInt(); if (!TryGetReader(typeId, out var ctxReadDelegate)) { if (unknownInstanceReader == null) { myRegistrar?.TryRegister(typeId, this); myRegistrar?.TryRegister(typeof(T), this); if (!TryGetReader(typeId, out ctxReadDelegate)) { var realType = myTypeMapping.SingleOrDefault(c => Equals(c.Value, typeId)); //ok because it's rarely needed throw new KeyNotFoundException(string.Format("There is no readers found. Requested type '{0}'. Real type {1}", typeof(T).FullName, realType)); } } else { var objectStart = reader.Position; var result = unknownInstanceReader(ctx, reader); var bytesRead = reader.Position - objectStart; reader.Skip(size - bytesRead); return(result); } } var uncasted = ctxReadDelegate(ctx, reader); Assertion.Assert(uncasted is T, "Bad cast for id {0}. Expected: {1}, actual: {2}", typeId, typeof(T).Name, uncasted.GetType().Name); return((T)uncasted); }
public override void OnWireReceived(UnsafeReader reader) { var version = reader.ReadInt(); var value = ReadValueDelegate(SerializationContext, reader); var rejected = IsMaster && version < myMasterVersion; ReceiveTrace?.Log($"{this} :: oldver = {myMasterVersion}, newver = {version}, value = {value.PrintToString()}{(rejected ? " REJECTED" : "")}"); if (rejected) { return; } myMasterVersion = version; using (UsingDebugInfo()) { myProperty.Value = value; } }
public override void OnWireReceived(UnsafeReader reader) { var remoteState = (ExtState)reader.ReadInt(); ReceiveTrace?.Log($"Ext {Location} ({RdId}) : {remoteState}"); switch (remoteState) { case ExtState.Ready: SendState(myExtWire.RealWire, ExtState.ReceivedCounterPart); myExtWire.Connected.Set(true); break; case ExtState.ReceivedCounterPart: myExtWire.Connected.Set(true); //don't set anything if already set break; case ExtState.Disconnected: myExtWire.Connected.Set(false); break; default: throw new ArgumentOutOfRangeException("Unsupported state: " + remoteState); } var counterpartSerializationHash = reader.ReadLong(); if (counterpartSerializationHash != SerializationHash) { base.Proto.Scheduler.Queue(() => { base.Proto.OutOfSyncModels.Add(this); }); if (base.Proto is Protocol p && p.ThrowErrorOnOutOfSyncModels) { Assertion.Fail($"{this} : SerializationHash doesn't match to counterpart: maybe you forgot to generate models?" + $"Our: `${SerializationHash}` counterpart: {counterpartSerializationHash}"); } } }
public override void OnWireReceived(UnsafeReader stream) { var kind = (AddRemove)stream.ReadInt(); var value = ReadValueDelegate(SerializationContext, stream); ReceiveTrace?.Log($"{this} :: {kind} :: {value.PrintToString()}"); using (UsingDebugInfo()) { switch (kind) { case AddRemove.Add: mySet.Add(value); break; case AddRemove.Remove: mySet.Remove(value); break; default: throw new ArgumentOutOfRangeException(); } } }
public override void OnWireReceived(UnsafeReader stream) { var kind = (AddRemove)stream.ReadInt(); var value = ReadValueDelegate(SerializationContext, stream); LogSend.Trace("Set `{0}` ({1}) :: {2} :: {3}", Location, RdId, kind, value.PrintToString()); using (UsingDebugInfo()) { switch (kind) { case AddRemove.Add: mySet.Add(value); break; case AddRemove.Remove: mySet.Remove(value); break; default: throw new ArgumentOutOfRangeException(); } } }
public static T ReadEnum <T>(SerializationCtx ctx, UnsafeReader reader) { Assertion.Assert(typeof(T).IsSubclassOf(typeof(Enum)), "{0}", typeof(T)); return((T)Enum.ToObject(typeof(T), reader.ReadInt())); //memory traffic }
public static InjectedHlslLocationInfo Read(UnsafeReader reader) { return(new InjectedHlslLocationInfo(UnsafeMarshallers.FileSystemPathMarshaller.Unmarshal(reader), new TextRange(reader.ReadInt(), reader.ReadInt()), reader.ReadEnum(InjectedHlslProgramType.Uknown))); }
private static object Read(UnsafeReader reader) => new Int2Value(reader.ReadInt(), reader.ReadInt());
public override void OnWireReceived(UnsafeReader stream) { var header = stream.ReadLong(); var opType = header & ((1 << versionedFlagShift) - 1); var version = header >> versionedFlagShift; var index = stream.ReadInt(); var kind = (AddUpdateRemove)opType; V value = default(V); var isPut = kind == AddUpdateRemove.Add || kind == AddUpdateRemove.Update; if (isPut) { value = ReadValueDelegate(SerializationContext, stream); } LogReceived.Trace("list `{0}` ({1}) :: {2} :: index={3} :: version = {4}{5}", Location, RdId, kind, index , version , isPut ? " :: value = " + value.PrintToString() : ""); if (version != myNextVersion) { Assertion.Fail("Version conflict for {0} Expected version {1} received {2}. Are you modifying a list from two sides?", Location, myNextVersion, version); } myNextVersion++; using (UsingDebugInfo()) { switch (kind) { case AddUpdateRemove.Add: if (index < 0) { myList.Add(value); } else { myList.Insert(index, value); } break; case AddUpdateRemove.Update: // ReSharper disable once AssignNullToNotNullAttribute myList[index] = value; break; case AddUpdateRemove.Remove: myList.RemoveAt(index); break; default: throw new ArgumentOutOfRangeException(kind.ToString()); } } }
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); }
public override void OnWireReceived(UnsafeReader stream) { var header = stream.ReadInt(); var msgVersioned = (header >> versionedFlagShift) != 0; var opType = header & ((1 << versionedFlagShift) - 1); var version = msgVersioned ? stream.ReadLong() : 0L; var key = ReadKeyDelegate(SerializationContext, stream); if (opType == Ack) { string error = null; if (!msgVersioned) { error = "Received ACK while msg hasn't versioned flag set"; } else if (!IsMaster) { error = "Received ACK when not a Master"; } else if (!myPendingForAck.TryGetValue(key, out var pendingVersion)) { error = "No pending for ACK"; } else if (pendingVersion < version) { error = $"Pending version `{pendingVersion}` < ACK version `{version}`"; } // Good scenario else if (pendingVersion == version) { myPendingForAck.Remove(key); } //else do nothing, silently drop var isError = !string.IsNullOrEmpty(error); if (ourLogReceived.IsTraceEnabled() || isError) { ourLogReceived.LogFormat(isError ? LoggingLevel.ERROR : LoggingLevel.TRACE, "{0} :: ACK :: key = {1} :: version = {2}{3}", this, key.PrintToString(), version, isError ? " >> " + error : ""); } } else { using (UsingDebugInfo()) { var kind = (AddUpdateRemove)opType; switch (kind) { case AddUpdateRemove.Add: case AddUpdateRemove.Update: var value = ReadValueDelegate(SerializationContext, stream); ReceiveTrace?.Log($"{this} :: {kind} :: key = {key.PrintToString()}" + (msgVersioned ? " :: version = " + version : "") + $" :: value = {value.PrintToString()}" ); if (msgVersioned || !IsMaster || !myPendingForAck.ContainsKey(key)) { myMap[key] = value; } else { ReceiveTrace?.Log(">> CHANGE IGNORED"); } break; case AddUpdateRemove.Remove: ReceiveTrace?.Log($"{this} :: {kind} :: key = {key.PrintToString()}" + (msgVersioned ? " :: version = " + version : "") ); if (msgVersioned || !IsMaster || !myPendingForAck.ContainsKey(key)) { myMap.Remove(key); } else { ReceiveTrace?.Log(">> CHANGE IGNORED"); } break; default: throw new ArgumentOutOfRangeException(kind.ToString()); } } if (msgVersioned) { Wire.Send(RdId, (innerWriter) => { innerWriter.Write((1 << versionedFlagShift) | Ack); innerWriter.Write(version); WriteKeyDelegate.Invoke(SerializationContext, innerWriter, key); SendTrace?.Log($"{this} :: ACK :: key = {key.PrintToString()} :: version = {version}"); }); if (IsMaster) { ourLogReceived.Error("Both ends are masters: {0}", Location); } } } }
public static Filter Read(UnsafeReader reader) { var name = reader.ReadString(); var offset = reader.ReadInt(); return new Filter(name, offset); }
public static InternId Read(UnsafeReader reader) => new InternId(reader.ReadInt());