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());