public T Deserialize(SerializerInput input)
{
T item = default;
var childAddress = Unsafe.AsPointer(ref item);
_methods.Read(childAddress, input);
return(item);
}
public override void Read(void *fieldAddress, SerializerInput input)
{
TMember def = default;
var ptr = Unsafe.AsPointer(ref def);
_dataSerializer.Read(ptr, input);
_set(Unsafe.Read <T>(fieldAddress), def);
}
public override void Read(void *fieldAddress, SerializerInput input)
{
var obj = Unsafe.Read <object>(fieldAddress);//obj should not be null here
var pinnable = Unsafe.As <object, PinnableObject>(ref obj);
fixed(byte *objectAddress = &pinnable.Pinnable)
{
_dataSerializer.Read(objectAddress + _fieldOffset, input);
}
}
public void SkipData(DataType type, SerializerInput serializerInput)
{
if (GetForType(type, out var dataEntry))
{
dataEntry.Skip(serializerInput);
}
else
{
throw new Exception($"Unknown data type {type}");
}
}
public override void Read(void *fieldAddress, SerializerInput input)
{
if (input.BeginReadSize(out var end))
{
_fieldsSerializer.Read((byte *)fieldAddress, input);
input.EndObject(end);
}
else
{
//"Changed from reference type?"
}
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
if (input.BeginReadSize(out var end))
{
_memberSerializer.Read((byte *)fieldAddress, input);
input.EndObject(end);
}
else
{
ref var instance = ref Unsafe.AsRef <T>(fieldAddress);
instance = default;
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
if (input.BeginReadSize(out var end))
{
ref var objectInstance = ref Unsafe.AsRef <object>(fieldAddress);
if (objectInstance == null)
{
objectInstance = Activator.CreateInstance(_type);
}
_memberSerializer.Read((byte *)fieldAddress, input);
input.EndObject(end);
}
public unsafe bool TryPopulateObject(SerializerInput input, object obj)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
var type = obj.GetType();
if (TryGetDataSerializer(type, out var serializationMethods) == false)
{
//Debug.LogError($"Could not find serialization data for {type}");
return(false);
}
serializationMethods.Read(Unsafe.AsPointer(ref obj), input);
return(true);
}
public unsafe bool TryDeserialize <T>(SerializerInput input, ref T result)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (TryGetDataSerializer(typeof(T), out var serializationMethods))
{
serializationMethods.Read(Unsafe.AsPointer(ref result), input);
return(true);
}
else
{
result = default;
}
return(false);
}
public unsafe bool TryPopulateObject <T>(SerializerInput input, Type type, ref T result)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (typeof(T).IsAssignableFrom(type) == false)
{
throw new Exception($"You are try to use a serializer:{type} on a non compatible type {typeof(T)}");
//return false;
}
if (TryGetDataSerializer(type, out var serializationMethods) == false)
{
//Debug.LogError($"Could not find serialization data for {type}");
return(false);
}
serializationMethods.Read(Unsafe.AsPointer(ref result), input);
return(true);
}
public override void Read(void *fieldAddress, SerializerInput input)
{
ref var instance = ref Unsafe.AsRef <object>(fieldAddress);
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
var value = (ushort *)(fieldAddress);
*value = input.ReadUInt16();
}
public override void Read(void *fieldAddress, SerializerInput input)
{
var address = (byte *)fieldAddress + _fieldOffset;
_dataSerializer.Read(address, input);
}
public abstract void Read(void *fieldAddress, SerializerInput input);
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
var value = (double *)(fieldAddress);
*value = input.ReadDouble();
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
ref var array = ref Unsafe.AsRef <bool[]>(fieldAddress);
public bool TryPopulateObject <T>(SerializerInput input, ref T result)
{
return(TryPopulateObject(input, typeof(T), ref result));
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
ref var value = ref Unsafe.AsRef <string>(fieldAddress);
public void Deserialize(ref T item, SerializerInput input)
{
var childAddress = Unsafe.AsPointer(ref item);
_methods.Read(childAddress, input);
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
var value = (long *)(fieldAddress);
*value = input.ReadInt64();
}
public override void Read(void *fieldAddress, SerializerInput input)
{
throw new NotImplementedException();
}
public override unsafe void Read(void *fieldAddress, SerializerInput input)
{
var value = (float *)(fieldAddress);
*value = input.ReadFloat();
}
public void Read(byte *objectAddress, SerializerInput input)
{
var fieldCount = input.ReadByte();
var size = fieldCount * 5;
input.Skip(size);
//we just skipped the required data so we have it in the buffer
var buffer = input.Buffer;
var offset = input.PositionInBuffer - size;
var fieldDatas = _fields;
if (SameHeader(buffer, offset, size))
{
for (int i = 0; i < fieldCount; i++)
{
var fieldData = fieldDatas[i];
var fieldDataOffset = objectAddress + fieldData.Offset;
var dataSerializer = fieldData.SerializationMethods;
dataSerializer.Read(fieldDataOffset, input);
}
}
else
{
int position = offset;
var indexes = stackalloc byte[fieldCount];
var dataTypes = stackalloc DataType[fieldCount];
var fieldsLength = fieldDatas.Length;
int searchStart = 0;
for (var i = 0; i < fieldCount; i++)
{
dataTypes[i] = 0;
var field = buffer[position++] | buffer[position++] << 8 | buffer[position++] << 16 |
buffer[position++] << 24;
var type = (DataType)buffer[position++];
var deserialized = false;
for (var searchIndex = searchStart; searchIndex < fieldsLength; searchIndex++)
{
var fieldData = fieldDatas[searchIndex];
if (field == fieldData.FieldNameHash)
{
var dataSerializer = fieldData.SerializationMethods;
if (type == dataSerializer.GetDataType())
{
indexes[i] = (byte)searchIndex;
deserialized = true;
}
searchStart = searchIndex + 1;
break;
}
}
if (deserialized == false)
{
if (FieldData.GetAlternate(fieldDatas, type, field, out var alternateIndex))
{
indexes[i] = (byte)alternateIndex;
}
else
{
dataTypes[i] = type;
}
}
}
for (var i = 0; i < fieldCount; i++)
{
var index = indexes[i];
if ((byte)dataTypes[i] != 0)
{
_dataTypesDatabase.SkipData(dataTypes[i], input);
continue;
}
var fieldData = fieldDatas[index];
var fieldDataOffset = objectAddress + fieldData.Offset;
var dataSerializer = fieldData.SerializationMethods;
dataSerializer.Read(fieldDataOffset, input);
}
}
}
