public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { if (serializedState == "null") { return(null); } if (_serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } UnityObjectReferenceHack.ActiveOperator = serializationOperator; byte[] bytes = Convert.FromBase64String(serializedState); using (var stream = new MemoryStream(bytes)) { var deserialized = _serializer.Deserialize(stream, null, GetStorageType(storageType), new SerializationContext() { Context = serializationOperator }); UnityObjectReferenceHack.ActiveOperator = null; return(deserialized); } }
internal override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { string result; try { JsonNetSerializer.Settings.Context = new StreamingContext(StreamingContextStates.All, serializationOperator); if (BaseSerializer.GetStorageType(storageType) != value.GetType()) { TypeNameHandling typeNameHandling = JsonNetSerializer.Settings.TypeNameHandling; JsonNetSerializer.Settings.TypeNameHandling = TypeNameHandling.All; string text = JsonConvert.SerializeObject(value, Formatting.None, JsonNetSerializer.Settings); JsonNetSerializer.Settings.TypeNameHandling = typeNameHandling; result = text; } else { result = JsonConvert.SerializeObject(value, Formatting.None, JsonNetSerializer.Settings); } } finally { JsonNetSerializer.Settings.Context = default(StreamingContext); } return result; }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (value == null) return "null"; if (_serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } UnityObjectReferenceHack.ActiveOperator = serializationOperator; using (var stream = new MemoryStream()) { _serializer.Serialize(stream, value, new SerializationContext() { Context = serializationOperator }); UnityObjectReferenceHack.ActiveOperator = null; #if !UNITY_EDITOR && UNITY_WINRT return Convert.ToBase64String(stream.ToArray(), 0, (int)stream.Length); #else return Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length); #endif } }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (value == null) { return("null"); } if (_serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } UnityObjectReferenceHack.ActiveOperator = serializationOperator; using (var stream = new MemoryStream()) { _serializer.Serialize(stream, value, new SerializationContext() { Context = serializationOperator }); UnityObjectReferenceHack.ActiveOperator = null; #if !UNITY_EDITOR && UNITY_WINRT return(Convert.ToBase64String(stream.ToArray(), 0, (int)stream.Length)); #else return(Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length)); #endif } }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (value == null) { return("null"); } try { JsonNetOperatorHack.ActivateOperator = serializationOperator; // Json.NET for Unity does not support specifying the initial serialized type with // JsonConvert.SerializeObject, so we work around that by forcing Json.NET to emit // type information for all types when the initial type does not match if (GetStorageType(storageType) != value.GetType()) { var saved = Settings.TypeNameHandling; Settings.TypeNameHandling = TypeNameHandling.All; string serialized = JsonConvert.SerializeObject(value, Formatting.None, Settings); Settings.TypeNameHandling = saved; return(serialized); } return(JsonConvert.SerializeObject(value, Formatting.None, Settings)); } finally { JsonNetOperatorHack.ActivateOperator = null; } }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (value == null) { return "null"; } try { JsonNetOperatorHack.ActivateOperator = serializationOperator; // Json.NET for Unity does not support specifying the initial serialized type with // JsonConvert.SerializeObject, so we work around that by forcing Json.NET to emit // type information for all types when the initial type does not match if (GetStorageType(storageType) != value.GetType()) { var saved = Settings.TypeNameHandling; Settings.TypeNameHandling = TypeNameHandling.All; string serialized = JsonConvert.SerializeObject(value, Formatting.None, Settings); Settings.TypeNameHandling = saved; return serialized; } return JsonConvert.SerializeObject(value, Formatting.None, Settings); } finally { JsonNetOperatorHack.ActivateOperator = null; } }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { try { JsonNetOperatorHack.ActivateOperator = serializationOperator; return(JsonConvert.DeserializeObject(serializedState, GetStorageType(storageType), Settings)); } finally { JsonNetOperatorHack.ActivateOperator = null; } }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { _serializer.Context.Set(serializationOperator); fsData data; var fail = _serializer.TrySerialize(GetStorageType(storageType), value, out data); if (EmitFailWarning(fail)) return null; return fsJsonPrinter.CompressedJson(data); }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { try { JsonNetOperatorHack.ActivateOperator = serializationOperator; return JsonConvert.DeserializeObject(serializedState, GetStorageType(storageType), Settings); } finally { JsonNetOperatorHack.ActivateOperator = null; } }
/// <summary> /// Serializes a property that will be stored on the facade. /// </summary> public static bool TrySerializeProperty(BaseSerializer serializer, ISerializationOperator serializationOperator, InspectedProperty property, object value, out string data) { try { data = serializer.Serialize(property.StorageType, value, serializationOperator); return(true); } catch { data = string.Empty; return(false); } }
internal override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { object result; try { JsonNetSerializer.Settings.Context = new StreamingContext(StreamingContextStates.All, serializationOperator); result = JsonConvert.DeserializeObject(serializedState, BaseSerializer.GetStorageType(storageType), JsonNetSerializer.Settings); } finally { JsonNetSerializer.Settings.Context = default(StreamingContext); } return result; }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (value == null) { return("null"); } _formatter.Context = new StreamingContext(StreamingContextStates.All, serializationOperator); using (var stream = new MemoryStream()) { _formatter.Serialize(stream, value); return(Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length)); } }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { fsData data; var result = fsJsonParser.Parse(serializedState, out data); if (EmitFailWarning(result)) return null; _serializer.Context.Set(serializationOperator); object deserialized = null; result = _serializer.TryDeserialize(data, GetStorageType(storageType), ref deserialized); if (EmitFailWarning(result)) return null; return deserialized; }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { _serializer.Context.Set(serializationOperator); fsData data; var fail = _serializer.TrySerialize(GetStorageType(storageType), value, out data); if (EmitFailWarning(fail)) { return(null); } return(fsJsonPrinter.CompressedJson(data)); }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { if (serializedState == "null") { return(null); } _formatter.Context = new StreamingContext(StreamingContextStates.All, serializationOperator); byte[] bytes = Convert.FromBase64String(serializedState); using (var stream = new MemoryStream(bytes)) { return(_formatter.Deserialize(stream)); } }
internal override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { if (ProtoBufNetSerializer._serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } string result; using (MemoryStream memoryStream = new MemoryStream()) { ProtoBufNetSerializer._serializer.Serialize(memoryStream, value, new SerializationContext { Context = serializationOperator }); result = Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length); } return result; }
/// <summary> /// Deserializes a property on the facade. /// </summary> private static object DeserializeProperty(BaseSerializer serializer, ISerializationOperator serializationOperator, InspectedProperty property, Facade <T> facade) { string data; if (facade.FacadeMembers.TryGetValue(property.Name, out data)) { try { return(serializer.Deserialize(property.StorageType, data, serializationOperator)); } catch { } } return(GetDefault(property.StorageType)); }
internal override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { if (ProtoBufNetSerializer._serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } byte[] buffer = Convert.FromBase64String(serializedState); object result; using (MemoryStream memoryStream = new MemoryStream(buffer)) { result = ProtoBufNetSerializer._serializer.Deserialize(memoryStream, null, BaseSerializer.GetStorageType(storageType), new SerializationContext { Context = serializationOperator }); } return result; }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { if (serializedState == "null") return null; if (_serializer == null) { throw new InvalidOperationException("No protobuf-net serializer is loaded"); } UnityObjectReferenceHack.ActiveOperator = serializationOperator; byte[] bytes = Convert.FromBase64String(serializedState); using (var stream = new MemoryStream(bytes)) { var deserialized = _serializer.Deserialize(stream, null, GetStorageType(storageType), new SerializationContext() { Context = serializationOperator }); UnityObjectReferenceHack.ActiveOperator = null; return deserialized; } }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { fsData data; var result = fsJsonParser.Parse(serializedState, out data); if (EmitFailWarning(result)) { return(null); } Serializer.Context.Set(serializationOperator); object deserialized = null; result = Serializer.TryDeserialize(data, GetStorageType(storageType), ref deserialized); if (EmitFailWarning(result)) { return(null); } return(deserialized); }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { return null; }
/// <summary> /// Deserialize the given serialized content. /// </summary> /// <param name="storageType">The type of field/property that is storing this value. For /// example, an object field may be storing an int instance. In that case, storageType will /// be typeof(object), while value.GetType() will result in typeof(int).</param> /// <param name="serializedState">The serialized state of the object, created by calling /// Serialize(target).</param> /// <param name="serializationOperator">Contains implementations for common serialization /// operations, such as storing a UnityObject reference.</param> public abstract object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator);
/// <summary> /// Serialize the given object into a string. /// </summary> /// <param name="storageType">The type of field/property that is storing this value. For /// example, an object field may be storing an int instance. In that case, storageType will /// be typeof(object), while value.GetType() will result in typeof(int).</param> /// <param name="value">The object to serialize.</param> /// <param name="serializationOperator">Contains implementations for common serialization /// operations, such as storing a UnityObject reference.</param> /// <returns>The serialized state of the object that can be used to restore it.</returns> public abstract string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator);
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { return(null); }
public override object Deserialize(MemberInfo storageType, string serializedState, ISerializationOperator serializationOperator) { return(null); }
private static bool SaveStateForProperty(ISerializedObject obj, InspectedProperty property, BaseSerializer serializer, ISerializationOperator serializationOperator, out string serializedValue, ref bool success) { object currentValue = property.Read(obj); try { if (currentValue == null) { serializedValue = null; } else { serializedValue = serializer.Serialize(property.MemberInfo, currentValue, serializationOperator); } return(true); } catch (Exception e) { success = false; serializedValue = null; Debug.LogError("Exception caught when serializing property <" + property.Name + "> in <" + obj + "> with value " + currentValue + "\n" + e); return(false); } }
public override string Serialize(MemberInfo storageType, object value, ISerializationOperator serializationOperator) { return null; }