Merge pull request #7 from coryleach/dev

Object Copy Implemented.

Author: coryleach

README.md

@@ -1,6 +1,6 @@
 <h1 align="center">Gameframe.SaveLoad 👋</h1>
 <p>
-  <img alt="Version" src="https://img.shields.io/badge/version-1.0.3-blue.svg?cacheSeconds=2592000" />
+  <img alt="Version" src="https://img.shields.io/badge/version-1.0.4-blue.svg?cacheSeconds=2592000" />
   <a href="https://twitter.com/Cory Leach">
     <img alt="Twitter: coryleach" src="https://img.shields.io/twitter/follow/coryleach.svg?style=social" target="_blank" />
   </a>
@@ -13,15 +13,15 @@ Serialization helper utility that supports save, load and encryption.
 #### Using UnityPackageManager (for Unity 2019.3 or later)
 Open the package manager window (menu: Window > Package Manager)<br/>
 Select "Add package from git URL...", fill in the pop-up with the following link:<br/>
-https://github.com/coryleach/UnitySaveLoad.git#1.0.3<br/>
+https://github.com/coryleach/UnitySaveLoad.git#1.0.4<br/>
 
 #### Using UnityPackageManager (for Unity 2019.1 or later)
 
 Find the manifest.json file in the Packages folder of your project and edit it to look like this:
 ```js
 {
   "dependencies": {
-    "com.gameframe.saveload": "https://github.com/coryleach/UnitySaveLoad.git#1.0.3",
+    "com.gameframe.saveload": "https://github.com/coryleach/UnitySaveLoad.git#1.0.4",
     ...
   },
 }

Runtime/ISerializationMethod.cs

@@ -9,6 +9,7 @@ public interface ISerializationMethod
     {
         void Save(object savedObject, FileStream fileStream);
         object Load(System.Type savedObjectType, FileStream fileStream);
+        object Copy(object copyObject);
     }
 }
 

Runtime/SaveLoadManager.cs

@@ -73,6 +73,29 @@ public void Save(object obj, string filename, string folder = null)
             var saveLoadMethod = GetSaveLoadMethod(saveMethod);
             SaveLoadUtility.Save(obj,saveLoadMethod,filename,folder, baseFolder);
         }
+
+        /// <summary>
+        /// Creat a copy of an object by serializing and deserializing it
+        /// </summary>
+        /// <param name="obj">object to be copied</param>
+        /// <returns>duplicated instance</returns>
+        public object Copy(object obj)
+        {
+            var saveLoadMethod = GetSaveLoadMethod(saveMethod);
+            return saveLoadMethod.Copy(obj);
+        }
+
+        /// <summary>
+        /// Creat a copy of an object by serializing and deserializing it
+        /// </summary>
+        /// <param name="obj">object to be copied</param>
+        /// <typeparam name="T">Type of object to be copied.</typeparam>
+        /// <returns>duplicated instance</returns>
+        public T Copy<T>(T obj)
+        {
+            var saveLoadMethod = GetSaveLoadMethod(saveMethod);
+            return (T)saveLoadMethod.Copy(obj);
+        }
 
         /// <summary>
         /// Load an object from disk

Runtime/SerializationMethodBinary.cs

@@ -32,6 +32,18 @@ public object Load(Type savedObjectType, FileStream fileStream)
             loadedObj = formatter.Deserialize(fileStream);
             return loadedObj;
         }
+        
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var formatter = new BinaryFormatter();
+                formatter.Serialize(stream, copyObject);
+                stream.Position = 0;
+                return formatter.Deserialize(stream);
+            }
+        }
+
     }
 }
 

Runtime/SerializationMethodBinaryEncrypted.cs

@@ -58,6 +58,17 @@ public void SetEncryption(string key, string salt)
             _key = key;
             _salt = salt;
         }
+        
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var formatter = new BinaryFormatter();
+                formatter.Serialize(stream, copyObject);
+                stream.Position = 0;
+                return formatter.Deserialize(stream);
+            }
+        }
     }
 }
 

Runtime/SerializationMethodJsonDotNet.cs

@@ -31,6 +31,26 @@ public object Load(Type savedObjectType, FileStream fileStream)
 
             return loadedObj;
         }
+
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var writeJson = JsonConvert.SerializeObject(copyObject);
+            
+                var streamWriter = new StreamWriter(stream);
+                streamWriter.Write(writeJson);
+                streamWriter.Flush();
+
+                stream.Position = 0;
+
+                using (var streamReader = new StreamReader(stream))
+                {
+                    var readJson = streamReader.ReadToEnd();
+                    return JsonConvert.DeserializeObject(readJson, copyObject.GetType());
+                }
+            }
+        }
     }
 }
 

Runtime/SerializationMethodJsonDotNetEncrypted.cs

@@ -66,6 +66,27 @@ public void SetEncryption(string key, string salt)
             _key = key;
             _salt = salt;
         }
+        
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var writeJson = JsonConvert.SerializeObject(copyObject);
+            
+                var streamWriter = new StreamWriter(stream);
+                streamWriter.Write(writeJson);
+                streamWriter.Flush();
+
+                stream.Position = 0;
+
+                using (var streamReader = new StreamReader(stream))
+                {
+                    var readJson = streamReader.ReadToEnd();
+                    return JsonConvert.DeserializeObject(readJson, copyObject.GetType());
+                }
+            }
+        }
+
     }
 }
 

Runtime/SerializationMethodUnityJson.cs

@@ -30,6 +30,27 @@ public object Load(Type savedObjectType, FileStream fileStream)
 
             return loadedObj;
         }
+        
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var writeJson = JsonUtility.ToJson(copyObject);
+                var streamWriter = new StreamWriter(stream);
+                streamWriter.Write(writeJson);
+                streamWriter.Flush();
+
+                stream.Position = 0;
+                
+                using (var streamReader = new StreamReader(stream))
+                {
+                    var readJson = streamReader.ReadToEnd();
+                    streamReader.Close();
+                    return JsonUtility.FromJson(readJson, copyObject.GetType());
+                }
+            }
+        }
+
     }
 }
 

Runtime/SerializationMethodUnityJsonEncrypted.cs

@@ -16,7 +16,7 @@ public SerializationMethodUnityJsonEncrypted(string key, string salt)
 
         public void Save(object savedObject, FileStream fileStream)
         {
-            //TODO: Using Unity's json serializer... does not support dictionaries. Do better.
+            //Note: Use JsonDotNet method for Dictionary serialization
             var json = JsonUtility.ToJson(savedObject);
             using (var memoryStream = new MemoryStream())
             {
@@ -64,6 +64,27 @@ public void SetEncryption(string key, string salt)
             _key = key;
             _salt = salt;
         }
+        
+        public object Copy(object copyObject)
+        {
+            using (var stream = new MemoryStream())
+            {
+                var writeJson = JsonUtility.ToJson(copyObject);
+                var streamWriter = new StreamWriter(stream);
+                streamWriter.Write(writeJson);
+                streamWriter.Flush();
+
+                stream.Position = 0;
+                
+                using (var streamReader = new StreamReader(stream))
+                {
+                    var readJson = streamReader.ReadToEnd();
+                    streamReader.Close();
+                    return JsonUtility.FromJson(readJson, copyObject.GetType());
+                }
+            }
+        }
+        
     }
 }
 

Tests/Runtime/SaveLoadManagerTests.cs

@@ -113,6 +113,34 @@ public void CanSaveAndLoad([Values] SerializationMethodType method)
             Object.Destroy(manager);
         }
 
+        [Test]
+        public void CanCopy([Values] SerializationMethodType method)
+        {
+            var manager = CreateManager(method);
+
+            var testObject = new SaveLoadTestObject()
+            {
+                listOfStrings = new List<string> {"one", "two"},
+                count = 10,
+            };
+
+            var loadedObject = manager.Copy(testObject);
+            
+            Assert.NotNull(loadedObject);
+            Assert.IsFalse(ReferenceEquals(testObject,loadedObject));
+            Assert.NotNull(loadedObject.listOfStrings);
+            Assert.IsTrue(loadedObject.listOfStrings.Count == testObject.listOfStrings.Count);
+
+            for (int i = 0; i < testObject.listOfStrings.Count; i++)
+            {
+                Assert.IsTrue(testObject.listOfStrings[i] == loadedObject.listOfStrings[i]);
+            }
+            
+            Assert.IsTrue(testObject.count == loadedObject.count);
+            
+            Object.Destroy(manager);
+        }
+        
         [Test]
         public void LoadReturnsNullWhenFileDoesnotExist([Values] SerializationMethodType method)
         {