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