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