public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_ceras.DiscardObjectMethod?.Invoke(value);
}
value = default;
return;
}
if (objId == InlineType)
{
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
value = (T)(object)type; // This is ugly, but there's no way to prevent it, right?
return;
}
if (objId >= 0)
{
// Something we already know
value = _ceras.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_ceras.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
// == NewValue (EmbeddedType)
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else
{
// == NewValueSameType
specificType = typeof(T);
}
var entry = GetOrCreateEntry(specificType);
// At this point we know that the 'value' will not be 'null', so if 'value' (the variable) is null we need to create an instance
if (!entry.IsValueType) // still possible that we're dealing with a boxed value;
{
// Do we already have an object?
if (value != null)
{
// Yes, then maybe we can overwrite its values (works for objects and collections)
// But only if it's the right type!
if (value.GetType() != specificType)
{
// Discard the old value
_ceras.DiscardObjectMethod?.Invoke(value);
// Create instance of the right type
value = (T)entry.Constructor();
}
else
{
// Existing object is the right type
}
}
else
{
// Instance is null, create one
value = (T)entry.Constructor();
}
}
else
{
// Not a reference type. So it doesn't matter anyway.
}
if (!_allowReferences)
{
entry.CurrentDeserializeDispatcher(buffer, ref offset, ref value);
return;
}
//
// Deserialize the object
// 1. First generate a proxy so we can do lookups
var objectProxy = _ceras.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// 2. Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// 3. Actually read the object
entry.CurrentDeserializeDispatcher(buffer, ref offset, ref objectProxy.Value);
// 4. Write back the actual value, which instantly resolves all references
value = objectProxy.Value;
}
public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_serializer.Config.DiscardObjectMethod?.Invoke(value);
}
value = default;
return;
}
if (objId == InlineType)
{
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
value = (T)(object)type; // This is ugly, but there's no way to prevent it, right?
return;
}
if (objId >= 0)
{
// Something we already know
value = _serializer.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_serializer.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else // if (objId == NewValueSameType) commented out, its the only possible remaining case
{
specificType = typeof(T);
}
// At this point we know that the 'value' will not be 'null', so if 'value' (the variable) is null we need to create an instance
bool isRefType = !specificType.IsValueType;
if (isRefType)
{
// Do we already have an object?
if (value != null)
{
// Yes, then maybe we can overwrite its values (works for objects and collections)
// But only if it's the right type!
// todo: types using a SerializationCtor (in the future) are handled in a different ReferenceFormatter
// where we first read all members into local variables, then create the object (passing some of them into the constructor), and then writing the remaining as usual
if (value.GetType() != specificType)
{
// Discard the old value
_serializer.Config.DiscardObjectMethod?.Invoke(value);
// Create instance of the right type
value = CreateInstance(specificType);
}
else
{
// Existing object is the right type
}
}
else
{
// Instance is null, create one
// Note: that we *could* check if the type is one of the types that we cannot instantiate (String, Type, MemberInfo, ...) and then
// just not call CreateInstance, but the check itself would be expensive as well (HashSet look up?), so what's the point of complicating the code more?
// CreateInstance will do a dictionary lookup for us and simply return null for those types.
value = CreateInstance(specificType);
}
}
else
{
// Not a reference type. So it doesn't matter.
}
//
// Deserialize the object
// 1. First generate a proxy so we can do lookups
var objectProxy = _serializer.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// 2. Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// 3. Actually read the object
GetSpecificDeserializerDispatcher(specificType)(buffer, ref offset, ref objectProxy.Value);
// 4. Write back the actual value, which instantly resolves all references
value = objectProxy.Value;
}
