Provide default deserialization types for interfaces.

ICollection<T> => List<T>
IList<T> => List<T>
IDictionary<K,V> => Dictionary<K,V>

This resolves issue #120.

Author: jacobdufault

Assets/FullSerializer/Source/fsSerializer.cs

@@ -274,6 +274,35 @@ public void Clear() {
         private readonly fsCyclicReferenceManager _references;
         private readonly fsLazyCycleDefinitionWriter _lazyReferenceWriter;
 
+        /// <summary>
+        /// Allow the user to provide default storage types for interfaces and abstract
+        /// classes. For example, a model could have IList{int} as a parameter, but the
+        /// serialization data does not specify a List{int} type. A IList{} -> List{}
+        /// remapping will cause List{} to be used as the default storage type. see
+        /// https://github.com/jacobdufault/fullserializer/issues/120 for additional
+        /// context.
+        /// </summary>
+        private readonly Dictionary<Type, Type> _abstractTypeRemap;
+
+        private void RemapAbstractStorageTypeToDefaultType(ref Type storageType) {
+            if ((storageType.IsInterface || storageType.IsAbstract) == false)
+                return;
+
+            if (storageType.IsGenericType) {
+                Type remappedGenericType;
+                if (_abstractTypeRemap.TryGetValue(storageType.GetGenericTypeDefinition(), out remappedGenericType)) {
+                    Type[] genericArguments = storageType.GetGenericArguments();
+                    storageType = remappedGenericType.MakeGenericType(genericArguments);
+                }
+            }
+
+            else {
+                Type remappedType;
+                if (_abstractTypeRemap.TryGetValue(storageType, out remappedType))
+                    storageType = remappedType;
+            }
+        }
+
         public fsSerializer() {
             _cachedConverterTypeInstances = new Dictionary<Type, fsBaseConverter>();
             _cachedConverters = new Dictionary<Type, fsBaseConverter>();
@@ -309,6 +338,11 @@ public fsSerializer() {
             _processors.Add(new fsSerializationCallbackReceiverProcessor());
 #endif
 
+            _abstractTypeRemap = new Dictionary<Type, Type>();
+            SetDefaultStorageType(typeof(ICollection<>), typeof(List<>));
+            SetDefaultStorageType(typeof(IList<>), typeof(List<>));
+            SetDefaultStorageType(typeof(IDictionary<,>), typeof(Dictionary<,>));
+
             Context = new fsContext();
             Config = new fsConfig();
 
@@ -365,6 +399,18 @@ public void RemoveProcessor<TProcessor>() {
             _cachedProcessors = new Dictionary<Type, List<fsObjectProcessor>>();
         }
 
+        /// <summary>
+        /// Provide a default storage type for the given abstract or interface type. If
+        /// a type is deserialized which contains an interface/abstract field type and a
+        /// mapping is provided, the mapped type will be used by default. For example,
+        /// IList{T} => List{T} or IDictionary{TKey, TValue} => Dictionary{TKey, TValue}.
+        /// </summary>
+        public void SetDefaultStorageType(Type abstractType, Type defaultStorageType) {
+            if ((abstractType.IsInterface || abstractType.IsAbstract) == false)
+                throw new ArgumentException("|abstractType| must be an interface or abstract type");
+            _abstractTypeRemap[abstractType] = defaultStorageType;
+        }
+
         /// <summary>
         /// Fetches all of the processors for the given type.
         /// </summary>
@@ -824,6 +870,7 @@ private fsResult InternalDeserialize_3_Inheritance(Type overrideConverterType, f
                     objectType = type;
                 } while (false);
             }
+            RemapAbstractStorageTypeToDefaultType(ref objectType);
 
             // We wait until here to actually Invoke_OnBeforeDeserialize because
             // we do not have the correct set of processors to invoke until

Assets/FullSerializer/Testing/Editor/AbstractTypeRemappingTests.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace FullSerializer.Tests {
+    public class AbstractTypeRemappingTests {
+        public string Serialize<T>(T value) {
+            fsData data;
+            (new fsSerializer()).TrySerialize(value, out data).AssertSuccessWithoutWarnings();
+            return fsJsonPrinter.PrettyJson(data);
+        }
+
+        public T Deserialize<T>(string content) {
+            fsData data;
+            fsJsonParser.Parse(content, out data).AssertSuccessWithoutWarnings();
+            var result = default(T);
+            (new fsSerializer()).TryDeserialize(data, ref result).AssertSuccessWithoutWarnings();
+            return result;
+        }
+
+        [Test]
+        public void IListDeserializedAsList() {
+            var value = new List<int> { 1, 2, 3 };
+            string serialized = Serialize<List<int>>(value);
+            IList<int> deserialized = Deserialize<IList<int>>(serialized);
+            Assert.IsInstanceOf<List<int>>(deserialized);
+            CollectionAssert.AreEquivalent(value, deserialized);
+        }
+
+        [Test]
+        public void ICollectionDeserializedAsList() {
+            var value = new List<int> { 1, 2, 3 };
+            string serialized = Serialize<List<int>>(value);
+            ICollection<int> deserialized = Deserialize<ICollection<int>>(serialized);
+            Assert.IsInstanceOf<List<int>>(deserialized);
+            CollectionAssert.AreEquivalent(value, deserialized);
+        }
+
+        [Test]
+        public void IDictionaryDeserializedAsDictionary() {
+            var value = new Dictionary<string, int> { { "1", 1 }, { "2", 2 }, { "3", 3 } };
+            string serialized = Serialize<Dictionary<string, int>>(value);
+            IDictionary<string, int> deserialized = Deserialize<IDictionary<string, int>>(serialized);
+            Assert.IsInstanceOf<Dictionary<string, int>>(deserialized);
+            CollectionAssert.AreEquivalent(value, deserialized);
+        }
+    }
+}