public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
PropertyInfo keyProperty = storageType.GetDeclaredProperty("Key");
PropertyInfo valueProperty = storageType.GetDeclaredProperty("Value");
object keyObject = keyProperty.GetValue(instance, null);
object valueObject = valueProperty.GetValue(instance, null);
Type[] genericArguments = storageType.GetGenericArguments();
Type keyType = genericArguments[0], valueType = genericArguments[1];
fsResult result = fsResult.Success;
fsData keyData, valueData;
result.AddMessages(Serializer.TrySerialize(keyType, keyObject, out keyData));
result.AddMessages(Serializer.TrySerialize(valueType, valueObject, out valueData));
serialized = fsData.CreateDictionary();
if (keyData != null)
{
serialized.AsDictionary["Key"] = keyData;
}
if (valueData != null)
{
serialized.AsDictionary["Value"] = valueData;
}
return(result);
}
// Token: 0x06000452 RID: 1106 RVA: 0x0001BDA8 File Offset: 0x00019FA8
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult fsResult = fsResult.Success;
fsData data2;
fsResult fsResult2;
fsResult = (fsResult2 = fsResult + base.CheckKey(data, "Key", out data2));
if (fsResult2.Failed)
{
return(fsResult);
}
fsData data3;
fsResult fsResult3;
fsResult = (fsResult3 = fsResult + base.CheckKey(data, "Value", out data3));
if (fsResult3.Failed)
{
return(fsResult);
}
Type[] genericArguments = storageType.GetGenericArguments();
Type storageType2 = genericArguments[0];
Type storageType3 = genericArguments[1];
object obj = null;
object obj2 = null;
fsResult.AddMessages(this.Serializer.TryDeserialize(data2, storageType2, ref obj));
fsResult.AddMessages(this.Serializer.TryDeserialize(data3, storageType3, ref obj2));
instance = Activator.CreateInstance(storageType, new object[]
{
obj,
obj2
});
return(fsResult);
}
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult result = fsResult.Success;
fsData keyData, valueData;
if ((result += CheckKey(data, "Key", out keyData)).Failed)
{
return(result);
}
if ((result += CheckKey(data, "Value", out valueData)).Failed)
{
return(result);
}
Type[] genericArguments = storageType.GetGenericArguments();
Type keyType = genericArguments[0], valueType = genericArguments[1];
object keyObject = null, valueObject = null;
result.AddMessages(Serializer.TryDeserialize(keyData, keyType, ref keyObject));
result.AddMessages(Serializer.TryDeserialize(valueData, valueType, ref valueObject));
instance = Activator.CreateInstance(storageType, keyObject, valueObject);
return(result);
}
// Token: 0x06000453 RID: 1107 RVA: 0x0001BE68 File Offset: 0x0001A068
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
PropertyInfo declaredProperty = storageType.GetDeclaredProperty("Key");
PropertyInfo declaredProperty2 = storageType.GetDeclaredProperty("Value");
object value = declaredProperty.GetValue(instance, null);
object value2 = declaredProperty2.GetValue(instance, null);
Type[] genericArguments = storageType.GetGenericArguments();
Type storageType2 = genericArguments[0];
Type storageType3 = genericArguments[1];
fsResult success = fsResult.Success;
fsData fsData;
success.AddMessages(this.Serializer.TrySerialize(storageType2, value, out fsData));
fsData fsData2;
success.AddMessages(this.Serializer.TrySerialize(storageType3, value2, out fsData2));
serialized = fsData.CreateDictionary();
if (fsData != null)
{
serialized.AsDictionary["Key"] = fsData;
}
if (fsData2 != null)
{
serialized.AsDictionary["Value"] = fsData2;
}
return(success);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
// note: IList[index] is **significantly** faster than Array.Get, so make sure we use
// that instead.
IList arr = (Array)instance;
Type elementType = storageType.GetElementType();
fsResult result = fsResult.Success;
serialized = fsData.CreateList(arr.Count);
List <fsData> serializedList = serialized.AsList;
for (int i = 0; i < arr.Count; ++i)
{
object item = arr[i];
fsData serializedItem;
fsResult itemResult = Serializer.TrySerialize(elementType, item, out serializedItem);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
serializedList.Add(serializedItem);
}
return(result);
}
public override fsResult TrySerialize(object instance_, out fsData serialized, Type storageType)
{
IEnumerable instance = (IEnumerable)instance_;
fsResult result = fsResult.Success;
Type elementType = GetElementType(storageType);
serialized = fsData.CreateList(HintSize(instance));
List <fsData> serializedList = serialized.AsList;
foreach (object item in instance)
{
fsData itemData;
// note: We don't fail the entire deserialization even if the item failed
fsResult itemResult = Serializer.TrySerialize(elementType, item, out itemData);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
serializedList.Add(itemData);
}
// Stacks iterate from back to front, which means when we deserialize we will deserialize
// the items in the wrong order, so the stack will get reversed.
if (IsStack(instance.GetType()))
{
serializedList.Reverse();
}
return(result);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
Array array = (Array)instance;
IList list1 = (IList)array;
Type elementType = storageType.GetElementType();
fsResult success = fsResult.Success;
serialized = fsData.CreateDictionary();
Dictionary <string, fsData> asDictionary = serialized.AsDictionary;
fsData list2 = fsData.CreateList(list1.Count);
asDictionary.Add("c", new fsData((long)array.GetLength(1)));
asDictionary.Add("r", new fsData((long)array.GetLength(0)));
asDictionary.Add("a", list2);
List <fsData> asList = list2.AsList;
for (int index1 = 0; index1 < array.GetLength(0); ++index1)
{
for (int index2 = 0; index2 < array.GetLength(1); ++index2)
{
object instance1 = array.GetValue(index1, index2);
fsData data;
fsResult result = this.Serializer.TrySerialize(elementType, instance1, out data);
success.AddMessages(result);
if (!result.Failed)
{
asList.Add(data);
}
}
}
return(success);
}
// Token: 0x0600041E RID: 1054 RVA: 0x0001AA48 File Offset: 0x00018C48
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
Array array = (Array)instance;
IList list = array;
Type elementType = storageType.GetElementType();
fsResult success = fsResult.Success;
serialized = fsData.CreateDictionary();
Dictionary <string, fsData> asDictionary = serialized.AsDictionary;
fsData fsData = fsData.CreateList(list.Count);
asDictionary.Add("c", new fsData((long)array.GetLength(1)));
asDictionary.Add("r", new fsData((long)array.GetLength(0)));
asDictionary.Add("a", fsData);
List <fsData> asList = fsData.AsList;
for (int i = 0; i < array.GetLength(0); i++)
{
for (int j = 0; j < array.GetLength(1); j++)
{
object value = array.GetValue(i, j);
fsData item;
fsResult result = this.Serializer.TrySerialize(elementType, value, out item);
success.AddMessages(result);
if (!result.Failed)
{
asList.Add(item);
}
}
}
return(success);
}
// Token: 0x06000446 RID: 1094 RVA: 0x0001B9D8 File Offset: 0x00019BD8
public override fsResult TrySerialize(object instance_, out fsData serialized, Type storageType)
{
IEnumerable enumerable = (IEnumerable)instance_;
fsResult success = fsResult.Success;
Type elementType = fsIEnumerableConverter.GetElementType(storageType);
serialized = fsData.CreateList(fsIEnumerableConverter.HintSize(enumerable));
List <fsData> asList = serialized.AsList;
foreach (object current in enumerable)
{
fsData item;
fsResult result = this.Serializer.TrySerialize(elementType, current, out item);
success.AddMessages(result);
if (!result.Failed)
{
asList.Add(item);
}
}
if (this.IsStack(enumerable.GetType()))
{
asList.Reverse();
}
return(success);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
serialized = fsData.CreateDictionary();
fsResult result = fsResult.Success;
fsMetaType metaType = fsMetaType.Get(Serializer.Config, instance.GetType());
metaType.EmitAotData(/*throwException:*/ false);
for (int i = 0; i < metaType.Properties.Length; ++i)
{
fsMetaProperty property = metaType.Properties[i];
if (property.CanRead == false)
{
continue;
}
fsData serializedData;
fsResult itemResult = Serializer.TrySerialize(property.StorageType, property.OverrideConverterType,
property.Read(instance), out serializedData);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
serialized.AsDictionary[property.JsonName] = serializedData;
}
return(result);
}
// Token: 0x06000448 RID: 1096 RVA: 0x0001BAEC File Offset: 0x00019CEC
public override fsResult TryDeserialize(fsData data, ref object instance_, Type storageType)
{
IEnumerable enumerable = (IEnumerable)instance_;
fsResult fsResult = fsResult.Success;
fsResult fsResult2;
fsResult = (fsResult2 = fsResult + base.CheckType(data, fsDataType.Array));
if (fsResult2.Failed)
{
return(fsResult);
}
Type elementType = fsIEnumerableConverter.GetElementType(storageType);
MethodInfo addMethod = fsIEnumerableConverter.GetAddMethod(storageType);
MethodInfo flattenedMethod = storageType.GetFlattenedMethod("get_Item");
MethodInfo flattenedMethod2 = storageType.GetFlattenedMethod("set_Item");
if (flattenedMethod2 == null)
{
fsIEnumerableConverter.TryClear(storageType, enumerable);
}
int num = fsIEnumerableConverter.TryGetExistingSize(storageType, enumerable);
List <fsData> asList = data.AsList;
for (int i = 0; i < asList.Count; i++)
{
fsData data2 = asList[i];
object obj = null;
if (flattenedMethod != null && i < num)
{
obj = flattenedMethod.Invoke(enumerable, new object[]
{
i
});
}
fsResult result = this.Serializer.TryDeserialize(data2, elementType, ref obj);
fsResult.AddMessages(result);
if (!result.Failed)
{
if (flattenedMethod2 != null && i < num)
{
flattenedMethod2.Invoke(enumerable, new object[]
{
i,
obj
});
}
else
{
addMethod.Invoke(enumerable, new object[]
{
obj
});
}
}
}
return(fsResult);
}
public override fsResult TryDeserialize(fsData data, ref object instance_, Type storageType)
{
IEnumerable instance = (IEnumerable)instance_;
fsResult result = fsResult.Success;
if ((result += CheckType(data, fsDataType.Array)).Failed)
{
return(result);
}
// For general strategy, instance may already have items in it. We
// will try to deserialize into the existing element.
Type elementStorageType = GetElementType(storageType);
MethodInfo addMethod = GetAddMethod(storageType);
MethodInfo getMethod = storageType.GetFlattenedMethod("get_Item");
MethodInfo setMethod = storageType.GetFlattenedMethod("set_Item");
if (setMethod == null)
{
TryClear(storageType, instance);
}
int existingSize = TryGetExistingSize(storageType, instance);
List <fsData> serializedList = data.AsList;
for (int i = 0; i < serializedList.Count; ++i)
{
fsData itemData = serializedList[i];
object itemInstance = null;
if (getMethod != null && i < existingSize)
{
itemInstance = getMethod.Invoke(instance, new object[] { i });
}
// note: We don't fail the entire deserialization even if the
// item failed
fsResult itemResult = Serializer.TryDeserialize(itemData, elementStorageType, ref itemInstance);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
if (setMethod != null && i < existingSize)
{
setMethod.Invoke(instance, new[] { i, itemInstance });
}
else
{
addMethod.Invoke(instance, new[] { itemInstance });
}
}
return(result);
}
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult result = fsResult.Success;
// Verify that we actually have an Object
if ((result += CheckType(data, fsDataType.Object)).Failed)
{
return(result);
}
fsMetaType metaType = fsMetaType.Get(Serializer.Config, storageType);
metaType.EmitAotData(/*throwException:*/ false);
for (int i = 0; i < metaType.Properties.Length; ++i)
{
fsMetaProperty property = metaType.Properties[i];
if (property.CanWrite == false)
{
continue;
}
fsData propertyData;
if (data.AsDictionary.TryGetValue(property.JsonName, out propertyData))
{
object deserializedValue = null;
// We have to read in the existing value, since we need to
// support partial deserialization. However, this is bad for
// perf.
// TODO: Find a way to avoid this call when we are not doing
// a partial deserialization Maybe through a new
// property, ie, Serializer.IsPartialSerialization,
// which just gets set when starting a new
// serialization? We cannot pipe the information
// through CreateInstance unfortunately.
if (property.CanRead)
{
deserializedValue = property.Read(instance);
}
fsResult itemResult = Serializer.TryDeserialize(propertyData, property.StorageType,
property.OverrideConverterType, ref deserializedValue);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
property.Write(instance, deserializedValue);
}
}
return(result);
}
// Token: 0x06000466 RID: 1126 RVA: 0x0001C52C File Offset: 0x0001A72C
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult fsResult = fsResult.Success;
fsResult fsResult2;
fsResult = (fsResult2 = fsResult + base.CheckType(data, fsDataType.Object));
if (fsResult2.Failed)
{
return(fsResult);
}
fsMetaType fsMetaType = fsMetaType.Get(this.Serializer.Config, storageType);
fsMetaType.EmitAotData();
for (int i = 0; i < fsMetaType.Properties.Length; i++)
{
fsMetaProperty property = fsMetaType.Properties[i];
if (property.CanWrite)
{
fsData data2;
if (data.AsDictionary.TryGetValue(property.JsonName, out data2))
{
int referenceId = fsBaseConverter.GetReferenceId(data2);
if (referenceId != -1 && this.Serializer.IsObjectVersionedAndUnderConstruction(referenceId))
{
object temp = instance;
this.Serializer.WhenInstanceCreated(referenceId, delegate(object refObject)
{
property.Write(temp, refObject);
});
}
else
{
object value = null;
if (property.CanRead)
{
value = property.Read(instance);
}
fsResult result = this.Serializer.TryDeserialize(data2, property.StorageType, property.OverrideConverterType, ref value);
fsResult.AddMessages(result);
if (!result.Failed)
{
property.Write(instance, value);
}
}
}
}
}
return(fsResult);
}
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult result = fsResult.Success;
// Verify that we actually have an List
if ((result += CheckType(data, fsDataType.Array)).Failed)
{
return(result);
}
Type elementType = storageType.GetElementType();
List <fsData> serializedList = data.AsList;
ArrayList list = new ArrayList(serializedList.Count);
int existingCount = list.Count;
for (int i = 0; i < serializedList.Count; ++i)
{
fsData serializedItem = serializedList[i];
object deserialized = null;
if (i < existingCount)
{
deserialized = list[i];
}
fsResult itemResult = Serializer.TryDeserialize(serializedItem, elementType, ref deserialized);
result.AddMessages(itemResult);
if (itemResult.Failed)
{
continue;
}
if (i < existingCount)
{
list[i] = deserialized;
}
else
{
list.Add(deserialized);
}
}
instance = list.ToArray(elementType);
return(result);
}
// Token: 0x06000417 RID: 1047 RVA: 0x0001A7B0 File Offset: 0x000189B0
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
IList list = (Array)instance;
Type elementType = storageType.GetElementType();
fsResult success = fsResult.Success;
serialized = fsData.CreateList(list.Count);
List <fsData> asList = serialized.AsList;
for (int i = 0; i < list.Count; i++)
{
object instance2 = list[i];
fsData item;
fsResult result = this.Serializer.TrySerialize(elementType, instance2, out item);
success.AddMessages(result);
if (!result.Failed)
{
asList.Add(item);
}
}
return(success);
}
// Token: 0x06000465 RID: 1125 RVA: 0x0001C470 File Offset: 0x0001A670
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
serialized = fsData.CreateDictionary();
fsResult success = fsResult.Success;
fsMetaType fsMetaType = fsMetaType.Get(this.Serializer.Config, instance.GetType());
fsMetaType.EmitAotData();
for (int i = 0; i < fsMetaType.Properties.Length; i++)
{
fsMetaProperty fsMetaProperty = fsMetaType.Properties[i];
if (fsMetaProperty.CanRead)
{
fsData value;
fsResult result = this.Serializer.TrySerialize(fsMetaProperty.StorageType, fsMetaProperty.OverrideConverterType, fsMetaProperty.Read(instance), out value);
success.AddMessages(result);
if (!result.Failed)
{
serialized.AsDictionary[fsMetaProperty.JsonName] = value;
}
}
}
return(success);
}
// Token: 0x0600041F RID: 1055 RVA: 0x0001AB4C File Offset: 0x00018D4C
public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult fsResult = fsResult.Success;
fsResult fsResult2;
fsResult = (fsResult2 = fsResult + base.CheckType(data, fsDataType.Object));
if (fsResult2.Failed)
{
return(fsResult);
}
Type elementType = storageType.GetElementType();
Dictionary <string, fsData> asDictionary = data.AsDictionary;
int num;
fsResult fsResult3;
fsResult = (fsResult3 = fsResult + base.DeserializeMember <int>(asDictionary, null, "c", out num));
if (fsResult3.Failed)
{
return(fsResult);
}
int num2;
fsResult fsResult4;
fsResult = (fsResult4 = fsResult + base.DeserializeMember <int>(asDictionary, null, "r", out num2));
if (fsResult4.Failed)
{
return(fsResult);
}
fsData fsData;
if (!asDictionary.TryGetValue("a", out fsData))
{
fsResult.AddMessage("Failed to get flattened list");
return(fsResult);
}
fsResult fsResult5;
fsResult = (fsResult5 = fsResult + base.CheckType(fsData, fsDataType.Array));
if (fsResult5.Failed)
{
return(fsResult);
}
Array array = Array.CreateInstance(elementType, num2, num);
List <fsData> asList = fsData.AsList;
if (num * num2 > asList.Count)
{
fsResult.AddMessage("Serialised list has more items than can fit in multidimensional array");
}
for (int i = 0; i < num2; i++)
{
for (int j = 0; j < num; j++)
{
fsData data2 = asList[j + i * num];
object value = null;
fsResult result = this.Serializer.TryDeserialize(data2, elementType, ref value);
fsResult.AddMessages(result);
if (!result.Failed)
{
array.SetValue(value, i, j);
}
}
}
instance = array;
return(fsResult);
}
