Exemplo n.º 1
0
    public void StrangeFormatTests() {
        var serializer = new fsSerializer();
        DateTime time = DateTime.Now;
        serializer.TryDeserialize(new fsData("2016-01-22T12:06:57.503005Z"), ref time).AssertSuccessWithoutWarnings();

        Assert.AreEqual(Convert.ToDateTime("2016-01-22T12:06:57.503005Z"), time);
    }
        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));
        }
Exemplo n.º 3
0
        static FullSerializerSerializer() {
            _serializer = new fsSerializer();
            _serializer.AddConverter(new UnityObjectConverter());
#if !UNITY_4_3
            _serializer.AddProcessor(new SerializationCallbackReceiverObjectProcessor());
#endif
        }
Exemplo n.º 4
0
        static FullSerializerBackend()
        {
            Serializer = new fsSerializer();
            Serializer.AddConverter(new UnityObjectConverter());
            Serializer.AddConverter(new MethodInfoConverter());

            fsConfig.SerializeAttributes = VFWSerializationLogic.Instance.SerializeMember;
            fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.DontSerializeMember;
        }
        static FullSerializerBackend()
        {
            Serializer = new fsSerializer();
            Serializer.AddConverter(new UnityObjectConverter());
            Serializer.AddConverter(new MethodInfoConverter());

            fsConfig.SerializeAttributes       = VFWSerializationLogic.Instance.Attributes.SerializeMember;
            fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.Attributes.DontSerializeMember;
        }
Exemplo n.º 6
0
        private static void DeserializeJson(fsSerializer serializer, string json, ref object instance, bool forceReflected)
        {
            using (ProfilingUtility.SampleBlock("DeserializeJson"))
            {
                fsResult result = DeserializeJsonUtil(serializer, json, ref instance, forceReflected);

                HandleResult("Deserialization", result, instance as UnityObject);
            }
        }
Exemplo n.º 7
0
        private static void GetJsonConverters(ref fsSerializer _serializer)
        {
            var converters = new List <fsConverter>(AllJsonConverters.GetAllJsonConverters());

            foreach (var converter in converters)
            {
                _serializer.AddConverter(converter);
            }
        }
Exemplo n.º 8
0
    public void StrangeFormatTests()
    {
        var      serializer = new fsSerializer();
        DateTime time       = DateTime.Now;

        serializer.TryDeserialize(new fsData("2016-01-22T12:06:57.503005Z"), ref time).AssertSuccessWithoutWarnings();

        Assert.AreEqual(Convert.ToDateTime("2016-01-22T12:06:57.503005Z"), time);
    }
Exemplo n.º 9
0
    //string text = "Paste JSON here";

    void OnGUI()
    {
        if (GUILayout.Button("Instantiate Ragdoll"))
        {
            guids  = new Dictionary <string, UnityEngine.Object>();
            fields = new Dictionary <Action <UnityEngine.Object>, string>();

            string      text     = File.ReadAllText(@"C:\Program Files (x86)\Steam\SteamApps\common\Human Fall Flat\prefab.json");
            var         s        = new fsSerializer();
            fsData      data     = fsJsonParser.Parse(text);
            JGameObject instance = new JGameObject();
            s.TryDeserialize <JGameObject>(data, ref instance);
            instance.Instantiate(null);

            foreach (var a in fields.Keys)
            {
                string g = fields[a];
                if (guids.ContainsKey(g))
                {
                    a.Invoke(guids[g]);
                }
                else
                {
                    Debug.Log("Missing GUID " + g);
                }
            }
        }

        if (GUILayout.Button("Instantiate Player"))
        {
            guids  = new Dictionary <string, UnityEngine.Object>();
            fields = new Dictionary <Action <UnityEngine.Object>, string>();

            string      text     = File.ReadAllText(@"C:\Program Files (x86)\Steam\SteamApps\common\Human Fall Flat\playerPrefab.json");
            var         s        = new fsSerializer();
            fsData      data     = fsJsonParser.Parse(text);
            JGameObject instance = new JGameObject();
            s.TryDeserialize <JGameObject>(data, ref instance);
            instance.Instantiate(null);

            foreach (var a in fields.Keys)
            {
                string g = fields[a];
                if (guids.ContainsKey(g))
                {
                    a.Invoke(guids[g]);
                }
                else
                {
                    Debug.Log("Missing GUID " + g);
                }
            }
        }

        //text = EditorGUILayout.TextArea(text);
    }
Exemplo n.º 10
0
        private static string DoSerialize <T>(T spell)
        {
            fsData       data;
            fsSerializer serializer = new fsSerializer();

            serializer.TrySerialize(typeof(T), spell, out data);
            string results = FullSerializer.fsJsonPrinter.PrettyJson(data);

            return(results);
        }
Exemplo n.º 11
0
        static JsonHelper()
        {
            serializer = new fsSerializer();
            serializer.Config.EnablePropertySerialization = false;

            editorSerializer = new fsSerializer();
            editorSerializer.AddConverter(new UnityObjectConverter());
            editorSerializer.Config.SerializeEnumsAsInteger     = true;
            editorSerializer.Config.EnablePropertySerialization = false;
        }
Exemplo n.º 12
0
        public void UpdateLevel()
        {
            var serializer = new fsSerializer();

            if (endLevel >= maxLevel)
            {
                endLevel = maxLevel;
            }
            level = FileUtils.LoadJsonFile <Level>(serializer, "Levels/" + ((!isTestScene) ? endLevel : startLevel) /*endLevel*/);
        }
Exemplo n.º 13
0
    void LoadMetadata(string geoJsonData)
    {
        fsSerializer serializer = new fsSerializer();
        fsData       data       = null;

        data = fsJsonParser.Parse(geoJsonData);

        // step 2: deserialize the data
        serializer.TryDeserialize(data, ref _tileMetadata).AssertSuccessWithoutWarnings();
        Debug.Log(data);
    }
	// 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);

	}
Exemplo n.º 15
0
        public void save(string filename)
        {
            try
            {
                World world = this;
                // world.ui.setToMainMenu();
                GraphicalMap.purge();
                GraphicalSociety.purge();
                world.map.world = null;


                //foreach (SocialGroup sg in map.socialGroups)
                //{
                //    if (sg is Society)
                //    {
                //        Society soc = (Society)sg;
                //        soc.voteSession = null;
                //    }
                //}

                fsSerializer _serializer = new fsSerializer();
                fsData       data;
                _serializer.TrySerialize(typeof(Map), map, out data).AssertSuccessWithoutWarnings();

                // emit the data via JSON
                string saveString = fsJsonPrinter.CompressedJson(data);
                World.Log("Save exit point");

                if (File.Exists(filename))
                {
                    World.Log("Overwriting old save: " + filename);
                    File.Delete(filename);
                }
                File.WriteAllLines(filename, new string[] { saveString });

                world.map.world = world;
                staticMap       = map;

                world.prefabStore.popMsg("Game saved as: " + filename);

                //// step 1: parse the JSON data
                //fsData data = fsJsonParser.Parse(serializedState);

                //// step 2: deserialize the data
                //object deserialized = null;
                //_serializer.TryDeserialize(data, type, ref deserialized).AssertSuccessWithoutWarnings();
            }catch (Exception e)
            {
                World.log(e.Message);
                World.log(e.StackTrace);
                prefabStore.popMsg("Failure to save");
                prefabStore.popMsg("Exception: " + e.StackTrace);
            }
        }
        public static string Serialize(Type type, object value)
        {
            fsSerializer _serializer = new fsSerializer();
            // serialize the data
            fsData data;

            _serializer.TrySerialize(type, value, out data).AssertSuccessWithoutWarnings();

            // emit the data via JSON
            return(fsJsonPrinter.CompressedJson(data));
        }
Exemplo n.º 17
0
        public void TestDeserializeWriteOnlyProperty() {
            var data = fsData.CreateDictionary();
            data.AsDictionary["Getter"] = new fsData(111); // not used, but somewhat verifies that we do not try to deserialize into a R/O property
            data.AsDictionary["Setter"] = new fsData(222);

            var model = default(Model);
            var serializer = new fsSerializer();
            Assert.IsTrue(serializer.TryDeserialize(data, ref model).Succeeded);

            Assert.AreEqual(222, model._setValue);
        }
Exemplo n.º 18
0
        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);
        }
Exemplo n.º 19
0
        public static fsSerializer GetSerializer(UnityObjectList objectReferences)
        {
            if (s_serializer == null)
            {
                s_serializer = new fsSerializer();
                // would add converters here if we needed to
            }

            s_serializer.UnityReferences = objectReferences;
            return(s_serializer);
        }
Exemplo n.º 20
0
 public SerializationOperation()
 {
     objectReferences = new List <UnityObject>();
     serializer       = new fsSerializer();
     serializer.AddConverter(new UnityObjectConverter());
     serializer.AddConverter(new RayConverter());
     serializer.AddConverter(new Ray2DConverter());
     serializer.AddConverter(new NamespaceConverter());
     serializer.AddConverter(new LooseAssemblyNameConverter());
     serializer.Context.Set(objectReferences);
 }
        public static Dictionary <T1, T2> Deserialize <T1, T2>(string json)
        {
            var    fsData          = fsJsonParser.Parse(json); //in JSON
            object deserializedRes = null;

            fsSerializer serializer = new fsSerializer();

            serializer.TryDeserialize(fsData, typeof(Dictionary <T1, T2>), ref deserializedRes).AssertSuccess();

            return((Dictionary <T1, T2>)deserializedRes);
        }
Exemplo n.º 22
0
        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);
        }
Exemplo n.º 23
0
        /// <summary>
        /// Loads the specified json file.
        /// </summary>
        /// <param name="serializer">The FullSerializer serializer to use.</param>
        /// <param name="path">The json file path.</param>
        /// <typeparam name="T">The type of the data to load.</typeparam>
        /// <returns>The loaded json data.</returns>
        public static T LoadJsonFile <T>(fsSerializer serializer, string path) where T : class
        {
            var textAsset = Resources.Load <TextAsset>(path);

            Assert.IsNotNull((textAsset));
            var    data         = fsJsonParser.Parse(textAsset.text);
            object deserialized = null;

            serializer.TryDeserialize(data, typeof(T), ref deserialized).AssertSuccessWithoutWarnings();
            return(deserialized as T);
        }
Exemplo n.º 24
0
        protected void SaveJsonFile <T>(string path, T data) where T : class
        {
            fsData serializedData;
            var    serializer = new fsSerializer();

            serializer.TrySerialize(data, out serializedData).AssertSuccessWithoutWarnings();
            var file = new StreamWriter(path);
            var json = fsJsonPrinter.PrettyJson(serializedData);

            file.WriteLine(json);
            file.Close();
        }
Exemplo n.º 25
0
    public static string ToJSON(Dictionary <string, object> dict)
    {
        fsSerializer serializer = new fsSerializer();

        serializer.AddConverter(new DictionaryConverter());

        fsData data;

        serializer.TrySerialize <Dictionary <string, object> >(dict, out data).AssertSuccessWithoutWarnings();

        return(fsJsonPrinter.CompressedJson(data));
    }
Exemplo n.º 26
0
        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);
        }
Exemplo n.º 27
0
    public static object Deserialize(Type type, string serializedState)
    {
        // step 1: parse the JSON data
        fsData       data        = fsJsonParser.Parse(serializedState);
        fsSerializer _serializer = new fsSerializer();
        // step 2: deserialize the data
        object deserialized = null;

        _serializer.TryDeserialize(data, type, ref deserialized).AssertSuccessWithoutWarnings();

        return(deserialized);
    }
Exemplo n.º 28
0
        public void ImportLegacyInheritance() {
            fsData data = fsData.CreateDictionary();
            data.AsDictionary["Type"] = new fsData("System.Int32");
            data.AsDictionary["Data"] = new fsData(32);

            object o = null;
            var serializer = new fsSerializer();
            Assert.IsTrue(serializer.TryDeserialize(data, ref o).Succeeded);

            Assert.IsTrue(o.GetType() == typeof(int));
            Assert.IsTrue((int)o == 32);
        }
Exemplo n.º 29
0
        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);
        }
Exemplo n.º 30
0
        public static bool LoadFile(string fileName, fsSerializer serializer, out SaveFileInfo saveFileInfo)
        {
            LoadFileResult result     = null;
            Thread         loadThread = new Thread(() => result = LoadFileAsync(fileName, serializer), 1024 * 1024 * 3);

            loadThread.Start();
            while (loadThread.IsAlive)
            {
            }
            saveFileInfo = result.success ? result.saveFileInfo : null;
            return(result.success);
        }
Exemplo n.º 31
0
        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);
        }
Exemplo n.º 32
0
        public BetterSerializer()
        {
            serializer = new fsSerializer();
            serializer.AddConverter <UnityObjectConverter>();

            Logic = SerializationLogic.Default;

            fsSerializer.Config = new fsConfig(
                Logic.Attributes.SerializeMember,
                Logic.Attributes.DontSerializeMember,
                false, Debug.Log, true
                );
        }
Exemplo n.º 33
0
        public string Export()
        {
            fsSerializer serializer = new fsSerializer();

            serializer.AddConverter(new Vector3Converter());
            serializer.AddConverter(new Vector2Converter());
            serializer.AddConverter(new QuaternionConverter());
            serializer.TrySerialize <BlueprintData>(this, out fsData data).AssertSuccessWithoutWarnings();

            string json = fsJsonPrinter.CompressedJson(data);

            return(Convert.ToBase64String(Zip(json)));
        }
        private static bool Serialize(ModSettingsConfiguration config)
        {
            fsSerializer fsSerializer = new fsSerializer();
            fsData       data;

            if (fsSerializer.TrySerialize(typeof(fsSerializer), config, out data).Succeeded)
            {
                File.WriteAllText(JsonPath, fsJsonPrinter.PrettyJson(data));
                return(true);
            }

            return(false);
        }
        private static bool Deserialize(ModSettingsConfiguration config)
        {
            fsSerializer fsSerializer = new fsSerializer();

            if (File.Exists(JsonPath))
            {
                string serializedData = File.ReadAllText(JsonPath);
                fsData data           = fsJsonParser.Parse(serializedData);
                return(fsSerializer.TryDeserialize(data, ref config).Succeeded);
            }

            return(false);
        }
Exemplo n.º 36
0
        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 );
        }
Exemplo n.º 37
0
    private T Deserialize <T>(string json)
    {
        // Parse the json string to fsData
        fsData data = fsJsonParser.Parse(json);

        // Deserialize the data to the input type
        object       deserialized = null;
        fsSerializer _serializer  = new fsSerializer();

        _serializer.TryDeserialize(data, typeof(T), ref deserialized);

        return((T)deserialized);
    }
Exemplo n.º 38
0
        public void VerifyMaxValueRoundTrips()
        {
            var serializer = new fsSerializer();

            fsData data;

            serializer.TrySerialize(float.MaxValue, out data).AssertSuccessWithoutWarnings();
            Assert.AreEqual(((double)float.MaxValue).ToString(System.Globalization.CultureInfo.InvariantCulture), fsJsonPrinter.PrettyJson(data));

            float deserialized = 0f;

            serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
            Assert.AreEqual(float.MaxValue, deserialized);
        }
Exemplo n.º 39
0
        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);
        }
Exemplo n.º 40
0
        public void TestDeserializeWriteOnlyProperty()
        {
            var data = fsData.CreateDictionary();

            data.AsDictionary["Getter"] = new fsData(111); // not used, but somewhat verifies that we do not try to deserialize into a R/O property
            data.AsDictionary["Setter"] = new fsData(222);

            var model      = default(Model);
            var serializer = new fsSerializer();

            Assert.IsTrue(serializer.TryDeserialize(data, ref model).Succeeded);

            Assert.AreEqual(222, model._setValue);
        }
        /// <summary>
        /// Serializes the user settings to the disk.
        /// </summary>
        /// <returns>true only if all the settings were saved to disk.</returns>
        public bool SerializePersistentSettings()
        {
            List <KeyValuePair <object, object> > strProperties  = new List <KeyValuePair <object, object> >();
            List <KeyValuePair <object, object> > metaProperties = new List <KeyValuePair <object, object> >();

            foreach (object key in _dict.Keys)
            {
                if (key.GetType() == typeof(string))
                {
                    strProperties.Add(new KeyValuePair <object, object>(key, _dict[key]));
                }
                else if (key.GetType() == typeof(MetaProp))
                {
                    metaProperties.Add(new KeyValuePair <object, object>(key, _dict[key]));
                }
            }

            fsSerializer serializer = new fsSerializer();
            fsData       data;
            var          items = new[]
            {
                new { List = (object)strProperties, Path = _pathHandler.DeveloperSettingFilePath },
                new { List = (object)metaProperties, Path = _pathHandler.MetaSettingsFilePath }
            };

            bool b_isSuccess = true;

            foreach (var item in items)
            {
                var result = serializer.TrySerialize(item.List.GetType(), item.List, out data);
                if (result.Failed)
                {
                    return(false);
                }
                string text     = fsJsonPrinter.PrettyJson(data);
                string old_text = TryReadTextFile(item.Path);

                if (text == old_text)
                { //avoid changing the file's timestamp (to prevent the service from syncing unnecessarily)
                  //Debug.Log("Prevented serialising to disk");
                    continue;
                }

                if (TryWriteTextFile(item.Path, text))
                {
                    b_isSuccess = false;
                }
            }
            return(b_isSuccess);
        }
Exemplo n.º 42
0
        public void TestIgnoreIsInheritedForProperties()
        {
            var model = new InheritedIgnoredProperty();

            fsData data;

            var serializer = new fsSerializer();

            Assert.IsTrue(serializer.TrySerialize(model, out data).Succeeded);

            var expected = fsData.CreateDictionary(); // Should just be empty dictionary.

            Assert.AreEqual(expected, data);
        }
Exemplo n.º 43
0
 public void load(string filename)
 {
     try
     {
         if (map != null)
         {
             GraphicalMap.purge();
             GraphicalSociety.purge();
             map.world = null;
             map       = null;
         }
         filename = saveFolder + filename;
         string fullFile = File.ReadAllText(filename);
         //string serializedState = fullFile.Substring(fullFile.IndexOf("\n"), fullFile.Length);
         int          startIndex      = fullFile.IndexOf(saveHeader) + saveHeader.Length;
         int          endIndex        = fullFile.Length - startIndex;
         string       serializedState = fullFile.Substring(startIndex, endIndex);
         fsSerializer _serializer     = new fsSerializer();
         fsData       data            = fsJsonParser.Parse(serializedState);
         World.Log("Data parsed");
         object deserialized = null;
         _serializer.TryDeserialize(data, typeof(Map), ref deserialized).AssertSuccessWithoutWarnings();
         World.saveLog.takeLine("Finished deserial");
         map       = (Map)deserialized;
         map.world = this;
         staticMap = map;
         World.self.displayMessages = true;
         GraphicalMap.map           = map;
         //ui.setToMainMenu();
         //GraphicalMap.checkLoaded();
         //GraphicalMap.checkData();
         //graphicalMap.loadArea(0, 0);
         map.decompressFromSave();
         prefabStore.popMsg("Loaded file: " + filename, true);
         World.Log("reached end of loading code");
         // prefabStore.popMsg("Load may well have succeeded.");
     }
     catch (FileLoadException e)
     {
         Debug.Log(e);
         World.log(e.StackTrace);
         prefabStore.popMsg("Exception: " + e.StackTrace, true);
     }
     catch (Exception e2)
     {
         Debug.Log(e2);
         World.log(e2.StackTrace);
         prefabStore.popMsg("Exception: " + e2.StackTrace, true);
     }
 }
Exemplo n.º 44
0
        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);
        }
Exemplo n.º 45
0
        public void ImportLegacyCycle() {
            fsData data = fsData.CreateDictionary();
            data.AsDictionary["SourceId"] = new fsData("0");
            data.AsDictionary["Data"] = fsData.CreateDictionary();
            data.AsDictionary["Data"].AsDictionary["Value"] = new fsData(3);
            data.AsDictionary["Data"].AsDictionary["Ref"] = fsData.CreateDictionary();
            data.AsDictionary["Data"].AsDictionary["Ref"].AsDictionary["ReferenceId"] = new fsData("0");

            UnityEngine.Debug.Log(fsJsonPrinter.PrettyJson(data));

            Cycle c = null;
            var serializer = new fsSerializer();
            Assert.IsTrue(serializer.TryDeserialize(data, ref c).Succeeded);
            Assert.AreEqual(3, c.Value);
            Assert.AreEqual(c, c.Ref);
        }
        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);
        }
Exemplo n.º 49
0
        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);
        }
Exemplo n.º 50
0
    public object Deserialize(Stream fileStream, Type type)
    {
        var bytes = new byte[fileStream.Length];
        var count = fileStream.Read(bytes, 0, bytes.Length);

        var jsonString = System.Text.Encoding.UTF8.GetString(bytes, 0, count);
        var data = fsJsonParser.Parse(jsonString);

        var serializer = new fsSerializer();
        object refObject = null;

        serializer.TryDeserialize(data, type, ref refObject);
        return refObject;
    }
Exemplo n.º 51
0
 //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);
 }
Exemplo n.º 52
0
        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);
        }