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);
}
/// <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);
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);
}
}
/// <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);
public override string Serialize(MemberInfo storageType, object value,
ISerializationOperator serializationOperator) {
return null;
}
