public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
Label label = (Label)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (!string.IsNullOrEmpty(label.Nature))
{
_serializer.TrySerialize(label.Nature, out tempData);
serialization.Add("nature", tempData);
}
if (!string.IsNullOrEmpty(label.Party))
{
_serializer.TrySerialize(label.Party, out tempData);
serialization.Add("party", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public static string SerializeGameBoard()
{
fsData data;
_serializer.TrySerialize(typeof(Board), State.gameBoard, out data).AssertSuccessWithoutWarnings();
return(fsJsonPrinter.CompressedJson(data));
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
Location location = (Location)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (location.Begin != null)
{
_serializer.TrySerialize(location.Begin, out tempData);
serialization.Add("begin", tempData);
}
if (location.End != null)
{
_serializer.TrySerialize(location.End, out tempData);
serialization.Add("end", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
TypeLabel typeLabel = (TypeLabel)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (typeLabel.Label != null)
{
_serializer.TrySerialize(typeLabel.Label, out tempData);
serialization.Add("label", tempData);
}
if (typeLabel.ProvenanceIds != null && typeLabel.ProvenanceIds.Count > 0)
{
_serializer.TrySerialize(typeLabel.ProvenanceIds, out tempData);
serialization.Add("provenance_ids", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public static string UserFieldModel(User user)
{
UserFields fields = new UserFields
{
email = new Email {
stringValue = user.email
},
local_id = new LocalId {
stringValue = user.local_id
},
phone_no = new PhoneNo {
stringValue = user.local_id
},
username = new Username {
stringValue = user.username
},
wallet_balance = new WalletBalance {
doubleValue = user.wallet_balance
}
};
UserRootObject rootObject = new UserRootObject
{
fields = fields
};
fsData data;
serializer.TrySerialize(typeof(UserRootObject), rootObject, out data).AssertSuccessWithoutWarnings();
string post_data = data.ToString();
return(post_data);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
UpdatedLabelsIn UpdatedLabelsIn = (UpdatedLabelsIn)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (UpdatedLabelsIn.Types != null && UpdatedLabelsIn.Types.Count > 0)
{
_serializer.TrySerialize(UpdatedLabelsIn.Types, out tempData);
serialization.Add("types", tempData);
}
if (UpdatedLabelsIn.Categories != null && UpdatedLabelsIn.Categories.Count > 0)
{
_serializer.TrySerialize(UpdatedLabelsIn.Categories, out tempData);
serialization.Add("categories", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
ShortDoc shortDoc = (ShortDoc)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (!string.IsNullOrEmpty(shortDoc.Title))
{
_serializer.TrySerialize(shortDoc.Title, out tempData);
serialization.Add("title", tempData);
}
if (!string.IsNullOrEmpty(shortDoc.Hash))
{
_serializer.TrySerialize(shortDoc.Hash, out tempData);
serialization.Add("hash", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public void SharedReferenceAcrossDifferentSerializationsAreNotKept()
{
var obj = new object();
var holder = new Holder {
value = obj
};
fsData data;
var serializer = new fsSerializer();
// Try serializing once.
serializer.TrySerialize(holder, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("{\"value\":{}}", fsJsonPrinter.CompressedJson(data));
// Serialize the same thing again to verify we don't preseve the reference.
serializer.TrySerialize(holder, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("{\"value\":{}}", fsJsonPrinter.CompressedJson(data));
// Serialize an array of Holders to verify references are maintained across an array.
var arrayOfHolders = new Holder[] {
new Holder {
value = obj
},
new Holder {
value = obj
}
};
serializer.TrySerialize(arrayOfHolders, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("[{\"value\":{\"$id\":\"0\"}},{\"value\":{\"$ref\":\"0\"}}]", fsJsonPrinter.CompressedJson(data));
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
EmotionOptions emotionOptions = (EmotionOptions)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (emotionOptions.document != null)
{
sm_Serializer.TrySerialize(emotionOptions.document, out tempData);
serialization.Add("document", tempData);
}
if (emotionOptions.targets != null)
{
sm_Serializer.TrySerialize(emotionOptions.targets, out tempData);
serialization.Add("targets", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
private void OnGetModels(ListModelsResults resp, string customData)
{
fsData data = null;
sm_Serializer.TrySerialize(resp, out data).AssertSuccess();
Log.Debug("ExampleNaturalLanguageUnderstandingV1", "ListModelsResult: {0}", data.ToString());
}
private static void WriteConfigAsJson(Type type, string folder)
{
var exportFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
if (exportFields.Length == 0)
{
return;
}
_serializer.Config.CustomDateTimeFormatString = "G";
_serializer.AddConverter(new MyCustomEnumConverter());
_serializer.AddConverter(new MyDictionaryConverter());
var ins = InstanceUtility.InstanceOfType(type);
foreach (var field in exportFields)
{
if (field.GetValue(ins) == null)
{
var value = InstanceUtility.InstanceOfType(field.FieldType);
field.SetValue(ins, value);
}
XlsxNameAttribute xlxsName = (XlsxNameAttribute)Attribute.GetCustomAttribute(field, typeof(XlsxNameAttribute));
string jsonFilename = xlxsName != null ? xlxsName.xlsxName : field.Name;
var file = Path.Combine(folder, jsonFilename + ".json");
fsData data;
_serializer.TrySerialize(field.FieldType, field.GetValue(ins), out data).AssertSuccess();
WriteDataToJson(file, data);
if (TypeUtility.HasAttribute <LocaleAttribute>(field.FieldType))
{
file = Path.Combine(folder, jsonFilename + ".locale.json");
_serializer.TrySerialize(typeof(Dictionary <string, LocaleJsonObject>), localeDict, out data).AssertSuccess();
WriteDataToJson(file, data);
}
}
}
public void Serialize <T>(string fullPath, T sourceData)
{
fsData data;
Serializer.TrySerialize(typeof(T), sourceData, out data).AssertSuccessWithoutWarnings();
//Debug.Log("[[[FULLLLL Serialize]]]] fullPath:" + fullPath);
if (!File.Exists(fullPath))
{
var file = File.Create(fullPath);
file.Close();
}
StreamWriter streamWriter = null;
try
{
streamWriter = new StreamWriter(fullPath);
streamWriter.WriteLine(data);
}
catch (Exception e)
{
Debug.LogError("WRITE ERROR:" + e.Message);
}
finally
{
if (streamWriter != null)
{
streamWriter.Close();
streamWriter.Dispose();
}
}
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
FeedbackInput feedbackInput = (FeedbackInput)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (!string.IsNullOrEmpty(feedbackInput.UserId))
{
_serializer.TrySerialize(feedbackInput.UserId, out tempData);
serialization.Add("user_id", tempData);
}
if (!string.IsNullOrEmpty(feedbackInput.Comment))
{
_serializer.TrySerialize(feedbackInput.Comment, out tempData);
serialization.Add("comment", tempData);
}
if (feedbackInput.FeedbackData != null)
{
_serializer.TrySerialize(feedbackInput.FeedbackData, out tempData);
serialization.Add("feedback_data", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
CreateExample createExample = (CreateExample)instance;
serialized = null;
Dictionary <string, fsData> serialization = new Dictionary <string, fsData>();
fsData tempData = null;
if (createExample.Mentions != null)
{
sm_Serializer.TrySerialize(createExample.Mentions, out tempData);
serialization.Add("mentions", tempData);
}
if (createExample.Text != null)
{
sm_Serializer.TrySerialize(createExample.Text, out tempData);
serialization.Add("text", tempData);
}
serialized = new fsData(serialization);
return(fsResult.Success);
}
public static void WriteToJsonFile <T>(string pathname, T obj) where T : new()
{
fsData data;
_serializer.TrySerialize(obj, out data).AssertSuccess();
byte[] content = new UTF8Encoding(true).GetBytes(fsJsonPrinter.PrettyJson(data));
WriteToFile(pathname, content);
}
public static string Serialize <T>(T value)
{
Type type = typeof(T);
fsData data;
var success = _serializer.TrySerialize(type, value, out data);
return(fsJsonPrinter.PrettyJson(data));
}
/// <summary>
/// Serialize the specified type and value.
/// returns a json string
/// </summary>
/// <param name="type">Type.</param>
/// <param name="value">Value.</param>
private static string SerializeToJSON(Type type, object value)
{
// serialize the data
fsData data;
_serializer.TrySerialize(type, value, out data).AssertSuccessWithoutWarnings();
// emit the data via JSON
return(fsJsonPrinter.CompressedJson(data));
}
public static object DeepCopy(object originalObject)
{
fsData data;
s_serializer.TrySerialize(originalObject.GetType(), originalObject, out data).AssertSuccessWithoutWarnings();
object deserialized = null;
s_serializer.TryDeserialize(data, originalObject.GetType(), ref deserialized).AssertSuccessWithoutWarnings();
return(deserialized);
}
public static string ToJson(this object value, Type type)
{
try
{
fsData result;
serializer.TrySerialize(type, value, out result);
return(fsJsonPrinter.CompressedJson(result));
}
catch
{
return(JsonUtility.ToJson(value));
}
}
public static string ToJson(T board)
{
fsData data;
serializer.TrySerialize(typeof(T), board, out data).AssertSuccessWithoutWarnings(); // TODO : MIRAR AssertSuccessWithoutWarnings
return(fsJsonPrinter.CompressedJson(data));
}
public override List <BenchmarkRunnerBase> CreateRunners()
{
return(new List <BenchmarkRunnerBase> {
new BenchmarkRunner <TestCases.StringField>(
"BaseLine.StringField_Serialize",
10,
obj1 => {
var str = $"{{\"Field\": \"{obj1.Field}\"}}";
return str != null;
},
_arg
),
new BenchmarkRunner <TestCases.StringField>(
"FullSerializer.StringField_Serialize",
10,
obj1 => {
fsData data1;
var serializer = new fsSerializer();
serializer.TrySerialize(obj1, out data1);
var str = fsJsonPrinter.CompressedJson(data1);
return str != null;
},
_arg
),
new BenchmarkRunner <TestCases.StringField>(
"JsonNet.StringField_Serialize",
10,
obj1 => {
var str = JsonConvert.SerializeObject(obj1);
return str != null;
},
_arg
)
});
}
public void TestPopulateObject() {
// This test verifies that when we pass in an existing object
// instance that same instance is used to deserialize into, ie,
// we can do the equivalent of Json.NET's PopulateObject
SimpleModel model1 = new SimpleModel { A = 3, B = new List<int> { 1, 2, 3 } };
fsData data;
var serializer = new fsSerializer();
Assert.IsTrue(serializer.TrySerialize(model1, out data).Succeeded);
model1.A = 1;
model1.B = new List<int> { 1 };
SimpleModel model2 = model1;
Assert.AreEqual(1, model1.A);
Assert.AreEqual(1, model2.A);
CollectionAssert.AreEqual(new List<int> { 1 }, model1.B);
CollectionAssert.AreEqual(new List<int> { 1 }, model2.B);
Assert.IsTrue(serializer.TryDeserialize(data, ref model2).Succeeded);
// If the same instance was not used, then model2.A will equal 1
Assert.AreEqual(3, model1.A);
Assert.AreEqual(3, model2.A);
CollectionAssert.AreEqual(new List<int> { 1, 2, 3 }, model1.B);
CollectionAssert.AreEqual(new List<int> { 1, 2, 3 }, model2.B);
Assert.IsTrue(ReferenceEquals(model1, model2));
}
public static string Generate(Type storageType, object instance)
{
if (storageType == _fsDataType)
{
return(Generate(instance as fsData));
}
fsData data;
if (LogResult(_serializer.TrySerialize(storageType, instance, out data)).Succeeded)
{
return(Generate(data));
}
return(null);
}
string TestFullSerializerSerialize(SaveGame saveGame, fsSerializer serializer)
{
fsData fsData;
serializer.TrySerialize(saveGame, out fsData);
return(fsJsonPrinter.CompressedJson(fsData));
}
/// <summary>
/// Returns a dilemma that contains the problem and a resolution. The problem contains a set of options and objectives. The resolution
/// contains a set of optimal options, their analytical characteristics, and by default their representation on a two-dimensional space.
/// You can optionally request that the service also return a refined set of preferable options that are most likely to appeal to the
/// greatest number of users
/// </summary>
/// <param name="successCallback">The success callback.</param>
/// <param name="failCallback">The fail callback.</param>
/// <param name="problem">The decision problem.</param>
/// <param name="generateVisualization">Indicates whether to calculate the map visualization. If true, the visualization is returned if
/// the is_objective field is true for at least three columns and at least three options have a status of FRONT in the problem resolution.</param>
/// <param name="customData">Optional custom data.</param>
/// <returns></returns>
public bool GetDilemma(SuccessCallback <DilemmasResponse> successCallback, FailCallback failCallback, Problem problem, Boolean generateVisualization, Dictionary <string, object> customData = null)
{
if (successCallback == null)
{
throw new ArgumentNullException("successCallback");
}
if (failCallback == null)
{
throw new ArgumentNullException("failCallback");
}
RESTConnector connector = RESTConnector.GetConnector(Credentials, DillemaEndpoint);
if (connector == null)
{
return(false);
}
GetDilemmaRequest req = new GetDilemmaRequest();
req.SuccessCallback = successCallback;
req.FailCallback = failCallback;
req.CustomData = customData == null ? new Dictionary <string, object>() : customData;
req.OnResponse = GetDilemmaResponse;
req.Parameters["generate_visualization"] = generateVisualization.ToString();
fsData tempData = null;
_serializer.TrySerialize <Problem>(problem, out tempData);
req.Send = Encoding.UTF8.GetBytes(tempData.ToString());
req.Headers["Content-Type"] = "application/json";
return(connector.Send(req));
}
/// <summary>
/// Writes mod settings (title, priority, enabled) to file
/// </summary>
/// <returns>True if settings written successfully.</returns>
public static bool WriteModSettings()
{
try
{
if (ModManager.Instance.mods == null || ModManager.Instance.mods.Count <= 0)
{
return(false);
}
fsData sdata = null;
var result = _serializer.TrySerialize <List <Mod> >(ModManager.Instance.mods, out sdata);
if (result.Failed)
{
return(false);
}
File.WriteAllText(Path.Combine(ModManager.Instance.ModDataDirectory, "Mods.json"), fsJsonPrinter.PrettyJson(sdata));
return(true);
}
catch (Exception ex)
{
Debug.LogError(string.Format("Failed to write mod settings: {0}", ex.Message));
return(false);
}
}
public static void WriteConfigAsJson(Type type, string folder)
{
var exportFields = ClassFieldFilter.GetConfigFieldInfo(type);
if (exportFields.Count == 0)
{
return;
}
foreach (var field in exportFields)
{
if (field.GetValue(null) == null)
{
UnityEngine.Debug.LogErrorFormat("Export {0} is null", field.Name);
return;
}
var file = Path.Combine(folder, field.Name + ".json");
fsData data;
_serializer.TrySerialize(field.FieldType, field.GetValue(null), out data).AssertSuccess();
if (File.Exists(file))
{
File.Delete(file);
}
using (FileStream fs = File.Create(file))
{
byte[] content = new UTF8Encoding(true).GetBytes(fsJsonPrinter.PrettyJson(data));
fs.Write(content, 0, content.Length);
}
}
}
private static void SaveJSON <T>(string toFile, T saveData)
{
jsonSerializer.TrySerialize(saveData, out fsData data);
string jsonData = fsJsonPrinter.PrettyJson(data);
File.WriteAllText(GetFilePath(toFile, FileExtension.json), jsonData);
}
private static void DoTest <T>(T obj)
{
var serializer = new fsSerializer();
var processor1 = new OrderedProcessor();
var processor2 = new OrderedProcessor();
serializer.AddProcessor(processor1);
serializer.AddProcessor(processor2);
int id = 0;
fsData data;
OrderedProcessor.NextId = 0;
serializer.TrySerialize(obj, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual(++id, processor1.onBeforeSerialize);
Assert.AreEqual(++id, processor2.onBeforeSerialize);
Assert.AreEqual(++id, processor2.onAfterSerialize);
Assert.AreEqual(++id, processor1.onAfterSerialize);
id = 0;
var deserialized = default(T);
OrderedProcessor.NextId = 0;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(++id, processor1.onBeforeDeserialize);
Assert.AreEqual(++id, processor2.onBeforeDeserialize);
Assert.AreEqual(++id, processor2.onAfterDeserialize);
Assert.AreEqual(++id, processor1.onAfterDeserialize);
}
///Serialize to json
public static string Serialize(Type type, object value, bool pretyJson = false, List <UnityEngine.Object> objectReferences = null)
{
lock (serializerLock)
{
if (!init)
{
serializer.AddConverter(new fsUnityObjectConverter());
init = true;
}
//set the objectReferences context
if (objectReferences != null)
{
serializer.Context.Set <List <UnityEngine.Object> >(objectReferences);
}
//serialize the data
fsData data;
serializer.TrySerialize(type, value, out data).AssertSuccess();
cache[fsJsonPrinter.CompressedJson(data)] = data;
//print data to json
if (pretyJson)
{
return(fsJsonPrinter.PrettyJson(data));
}
return(fsJsonPrinter.CompressedJson(data));
}
}
public void TestOptIn()
{
var model1 = new SimpleModel {
Serialized0 = 1,
Serialized1 = 1,
Serialized2 = 1,
NotSerialized0 = 1
};
fsData data;
var serializer = new fsSerializer();
Assert.IsTrue(serializer.TrySerialize(model1, out data).Succeeded);
SimpleModel model2 = null;
Assert.IsTrue(serializer.TryDeserialize(data, ref model2).Succeeded);
Debug.Log(fsJsonPrinter.PrettyJson(data));
Assert.AreEqual(model1.Serialized0, model2.Serialized0);
Assert.AreEqual(model1.Serialized1, model2.Serialized1);
Assert.AreEqual(model1.Serialized2, model2.Serialized2);
Assert.AreEqual(0, model2.NotSerialized0);
}
// Use this for initialization
void Start () {
fsSerializer serializer = new fsSerializer();
List<PairData> memoryCapacity = new List<PairData> () {
new PairData(6, 16),
new PairData(4, 8)};
List<PairData> hdd = new List<PairData> () {
new PairData(4, 4),
new PairData(4, 8)};
List<PairData> network = new List<PairData> () {
new PairData(2, 10),
new PairData(2, 1)};
List<string> gpu = new List<string> () {
"GPU A",
"GPU B",
"GPU C"};
ModelData modelData = new ModelData("Test Model",
true,
2,
4,
1000,
8,
1333,
memoryCapacity,
"RAID 0",
hdd,
network,
gpu,
3,
"Just a test",
System.DateTime.Now);
fsData data;
serializer.TrySerialize(modelData.GetType(), modelData, out data);
string dataString = fsJsonPrinter.PrettyJson(data);
data = fsJsonParser.Parse(dataString);
Debug.Log(dataString);
Debug.Log(modelData.ToString());
object deserialized = null;
serializer.TryDeserialize(data, typeof(ModelData), ref deserialized);
ModelData newModelData = (ModelData) deserialized;
Debug.Log(newModelData.ToString());
PersistanceManager.StoreLocalModelData("Test Model", dataString, null);
}
public void VerifyNegativeInfinityRoundTrips() {
var serializer = new fsSerializer();
fsData data;
serializer.TrySerialize(float.NegativeInfinity, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("-Infinity", fsJsonPrinter.PrettyJson(data));
float deserialized = 0f;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(float.NegativeInfinity, deserialized);
}
public void VerifyMinValueRoundTrips() {
var serializer = new fsSerializer();
fsData data;
serializer.TrySerialize(float.MinValue, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual(((double)float.MinValue).ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data));
float deserialized = 0f;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(float.MinValue, deserialized);
}
public void VerifyNaNRoundTrips() {
var serializer = new fsSerializer();
// todo: could definitely reduce duplication of tests in this file!
fsData data;
serializer.TrySerialize(float.NaN, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("NaN", fsJsonPrinter.PrettyJson(data));
float deserialized = 0f;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(float.NaN, deserialized);
}
public void TestSerializeReadOnlyProperty() {
var model = new Model();
fsData data;
var serializer = new fsSerializer();
Assert.IsTrue(serializer.TrySerialize(model, out data).Succeeded);
var expected = fsData.CreateDictionary();
expected.AsDictionary["Getter"] = new fsData(model.Getter);
Assert.AreEqual(expected, data);
}
public void TestOptOutOfProperties()
{
var model = new Model();
fsData data;
var serializer = new fsSerializer();
serializer.Config.EnablePropertySerialization = false;
Assert.IsTrue( serializer.TrySerialize( model, out data ).Succeeded );
var expected = fsData.CreateDictionary(); // Should just be empty dictionary.
Assert.AreEqual( expected, data );
}
public void VerifyFloatSerializationDoesNotHaveJitter() {
var serializer = new fsSerializer();
// We serialize w/o jitter
fsData data;
serializer.TrySerialize(0.1f, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual("0.1", fsJsonPrinter.PrettyJson(data));
// We deserialize w/o jitter.
float deserialized = 0f;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(0.1f, deserialized);
}
public void VerifyLargeDoubleRoundTrips()
{
double valueToTest = 500000000000000000.0;
var serializer = new fsSerializer();
fsData data;
serializer.TrySerialize(valueToTest, out data).AssertSuccessWithoutWarnings();
Assert.AreEqual(valueToTest.ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data));
double deserialized = 0f;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
Assert.AreEqual(valueToTest, deserialized);
}
public void VerifyConversion() {
MyConverter.DidDeserialize = false;
MyConverter.DidSerialize = false;
var serializer = new fsSerializer();
fsData result;
serializer.TrySerialize(new MyModel(), out result);
Assert.IsTrue(MyConverter.DidSerialize);
Assert.IsFalse(MyConverter.DidDeserialize);
MyConverter.DidSerialize = false;
object resultObj = null;
serializer.TryDeserialize(result, typeof (MyModel), ref resultObj);
Assert.IsFalse(MyConverter.DidSerialize);
Assert.IsTrue(MyConverter.DidDeserialize);
}
public void VerifyPropertyConverter() {
MyConverter.DidDeserialize = false;
MyConverter.DidSerialize = false;
var serializer = new fsSerializer();
// Make sure to set |a| to some value, otherwise we will short-circuit serialize it to null.
fsData result;
serializer.TrySerialize(new ModelWithPropertyConverter { a = 3 }, out result);
Assert.IsTrue(MyConverter.DidSerialize);
Assert.IsFalse(MyConverter.DidDeserialize);
MyConverter.DidSerialize = false;
object resultObj = null;
serializer.TryDeserialize(result, typeof(ModelWithPropertyConverter), ref resultObj);
Assert.IsFalse(MyConverter.DidSerialize);
Assert.IsTrue(MyConverter.DidDeserialize);
}
public void TestOptIn() {
var model1 = new SimpleModel {
Serialized0 = 1,
Serialized1 = 1,
Serialized2 = 1,
NotSerialized0 = 1
};
fsData data;
var serializer = new fsSerializer();
Assert.IsTrue(serializer.TrySerialize(model1, out data).Succeeded);
SimpleModel model2 = null;
Assert.IsTrue(serializer.TryDeserialize(data, ref model2).Succeeded);
Debug.Log(fsJsonPrinter.PrettyJson(data));
Assert.AreEqual(model1.Serialized0, model2.Serialized0);
Assert.AreEqual(model1.Serialized1, model2.Serialized1);
Assert.AreEqual(model1.Serialized2, model2.Serialized2);
Assert.AreEqual(0, model2.NotSerialized0);
}
public void MultistageMigration() {
var serializer = new fsSerializer();
var model_v1 = new VersionedModel_v1 {
A = 3
};
fsData serialized;
Assert.IsTrue(serializer.TrySerialize(model_v1, out serialized).Succeeded);
var model_v2 = new VersionedModel_v2();
Assert.IsTrue(serializer.TryDeserialize(serialized, ref model_v2).Succeeded);
Assert.AreEqual(model_v1.A, model_v2.B);
}
public void MultistageMigration() {
var serializer = new fsSerializer();
var model_v1 = new VersionedModel_v1 {
A = 3
};
fsData serialized;
serializer.TrySerialize(model_v1, out serialized).AssertSuccessWithoutWarnings();
var model_v2 = new VersionedModel_v2();
serializer.TryDeserialize(serialized, ref model_v2).AssertSuccessWithoutWarnings();
Assert.AreEqual(model_v1.A, model_v2.B);
}
//private static readonly FullSerializer.fsSerializer _serializer = new FullSerializer.fsSerializer();
public void Serialize(Stream fileStream, object graph)
{
fsData data;
var serializer = new fsSerializer();
serializer.TrySerialize(graph, out data);
var jsonString = fsJsonPrinter.CompressedJson(data);
fileStream.Write(System.Text.Encoding.UTF8.GetBytes(jsonString), 0, jsonString.Length);
}
