private fsResult InternalDeserialize_1_CycleReference(Type overrideConverterType, fsData data, Type storageType, ref object result, out List <fsObjectProcessor> processors)
{
// We handle object references first because we could be
// deserializing a cyclic type that is inherited. If that is the
// case, then if we handle references after inheritances we will try
// to create an object instance for an abstract/interface type.
// While object construction should technically be two-pass, we can
// do it in one pass because of how serialization happens. We
// traverse the serialization graph in the same order during
// serialization and deserialization, so the first time we encounter
// an object it'll always be the definition. Any times after that it
// will be a reference. Because of this, if we encounter a reference
// then we will have *always* already encountered the definition for
// it.
if (IsObjectReference(data))
{
var refId = int.Parse(data.AsDictionary[Key_ObjectReference].AsString);
result = _references.GetReferenceObject(refId);
processors = GetProcessors(result.GetType());
return(fsResult.Success);
}
return(InternalDeserialize_2_Version(overrideConverterType, data, storageType, ref result, out processors));
}
private fsResult InternalDeserialize_1_CycleReference(Type overrideConverterType, fsData data, Type storageType, ref object result, out List <fsObjectProcessor> processors)
{
// We handle object references first because we could be
// deserializing a cyclic type that is inherited. If that is the
// case, then if we handle references after inheritances we will try
// to create an object instance for an abstract/interface type.
// First check to see if this is a Unity object. If so, we need to look up the reference in
// the list provided to us by the caller.
if (IsUnityObjectReference(data))
{
if (_unityReferences.Enabled)
{
int refId = (int)data.AsDictionary[Key_UnityObjectReference].AsInt64;
result = _unityReferences.GetUnityObject(refId);
processors = GetProcessors(null);
return(fsResult.Success);
}
else
{
result = null;
processors = GetProcessors(null);
return(fsResult.Fail("Data was serialized with UnityReferences but none were provided for deserialization"));
}
}
// While object construction should technically be two-pass, we can
// do it in one pass because of how serialization happens. We
// traverse the serialization graph in the same order during
// serialization and deserialization, so the first time we encounter
// an object it'll always be the definition. Any times after that it
// will be a reference. Because of this, if we encounter a reference
// then we will have *always* already encountered the definition for
// it.
if (IsObjectReference(data))
{
int refId = int.Parse(data.AsDictionary[Key_ObjectReference].AsString);
result = _references.GetReferenceObject(refId);
processors = GetProcessors(result.GetType());
return(fsResult.Success);
}
return(InternalDeserialize_2_Version(overrideConverterType, data, storageType, ref result, out processors));
}
private fsResult InternalDeserialize_1_CycleReference(fsData data, Type storageType, ref object result)
{
// We handle object references first because we could be deserializing a cyclic type that is
// inherited. If that is the case, then if we handle references after inheritances we will try
// to create an object instance for an abstract/interface type.
// While object construction should technically be two-pass, we can do it in
// one pass because of how serialization happens. We traverse the serialization
// graph in the same order during serialization and deserialization, so the first
// time we encounter an object it'll always be the definition. Any times after that
// it will be a reference. Because of this, if we encounter a reference then we
// will have *always* already encountered the definition for it.
if (IsObjectReference(data))
{
int refId = int.Parse(data.AsDictionary[Key_ObjectReference].AsString);
result = _references.GetReferenceObject(refId);
return(fsResult.Success);
}
return(InternalDeserialize_2_Version(data, storageType, ref result));
}
private fsResult InternalDeserialize_1_CycleReference(Type overrideConverterType, fsData data, Type storageType, ref object result, out List <fsObjectProcessor> processors)
{
// We handle object references first because we could be deserializing a cyclic type that is
// inherited. If that is the case, then if we handle references after inheritances we will try
// to create an object instance for an abstract/interface type.
//継承された循環型を逆シリアル化することができるので、最初にオブジェクト参照を処理します。 その場合、継承の後に参照を処理する場合、抽象/インタフェース型のオブジェクトインスタンスを作成しようとします。
// While object construction should technically be two-pass, we can do it in
// one pass because of how serialization happens. We traverse the serialization
// graph in the same order during serialization and deserialization, so the first
// time we encounter an object it'll always be the definition. Any times after that
// it will be a reference. Because of this, if we encounter a reference then we
// will have *always* already encountered the definition for it.
// オブジェクトの構築は技術的には2パスでなければならないが、シリアライゼーションの仕組みのために1パスで行うことができる。 シリアライゼーションとデシリアライゼーションでは、シリアライゼーショングラフを同じ順序でトラバースします。最初にオブジェクトに遭遇したときには常にその定義になります。 それ以降はいつでも参考になります。 このため、参照に遭遇した場合は、*常に*定義済みです。
if (IsObjectReference(data))
{
int refId = int.Parse(data.AsDictionary[Key_ObjectReference].AsString);
result = _references.GetReferenceObject(refId);
processors = GetProcessors(result.GetType());
return(fsResult.Success);
}
return(InternalDeserialize_2_Version(overrideConverterType, data, storageType, ref result, out processors));
}
