Added CollectionConverter and some derivatives

IPA.Loader/Config/Stores/Attributes.cs

@@ -23,7 +23,7 @@ namespace IPA.Config.Stores.Attributes
 
     /// <summary>
     /// Indicates that a given field or property in an object being wrapped by <see cref="GeneratedExtension.Generated{T}(Config, bool)"/>
-    /// should be serialized and deserialized using the provided converter instead of the default mechanism.
+    /// should be serialized and deserialized using the provided converter instead of the default mechanism. 
     /// </summary>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
     public sealed class UseConverterAttribute : Attribute
@@ -40,6 +40,11 @@ namespace IPA.Config.Stores.Attributes
                                                 ConverterType.BaseType.GetGenericArguments()[0] :
                                                 null;
 
+        /// <summary>
+        /// Gets whether or not this converter is a generic <see cref="ValueConverter{T}"/>.
+        /// </summary>
+        public bool IsGenericConverter => ConverterTargetType != null;
+
         /// <summary>
         /// Creates a new <see cref="UseConverterAttribute"/> with a  given <see cref="ConverterType"/>.
         /// </summary>

IPA.Loader/Config/Stores/CollectionConverter.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using IPA.Config.Data;
+
+namespace IPA.Config.Stores.Converters
+{
+    /// <summary>
+    /// A base class for all <see cref="ICollection{T}"/> type converters, providing most of the functionality.
+    /// </summary>
+    /// <typeparam name="T">the type of the items in the collection</typeparam>
+    /// <typeparam name="TCollection">the instantiated type of collection</typeparam>
+    public class CollectionConverter<T, TCollection> : ValueConverter<TCollection>
+        where TCollection : ICollection<T>
+    {
+        /// <summary>
+        /// Creates a <see cref="CollectionConverter{T, TCollection}"/> using the default converter for the
+        /// element type. Equivalent to calling <see cref="CollectionConverter{T, TCollection}.CollectionConverter(ValueConverter{T})"/>
+        /// with <see cref="Converter{T}.Default"/>.
+        /// </summary>
+        /// <seealso cref="CollectionConverter{T, TCollection}.CollectionConverter(ValueConverter{T})"/>
+        public CollectionConverter() : this(Converter<T>.Default) { }
+        /// <summary>
+        /// Creates a <see cref="CollectionConverter{T, TCollection}"/> using the specified underlying converter.
+        /// </summary>
+        /// <param name="underlying">the <see cref="ValueConverter{T}"/> to use to convert the values</param>
+        public CollectionConverter(ValueConverter<T> underlying)
+            => BaseConverter = underlying;
+
+        /// <summary>
+        /// Gets the converter for the collection's value type.
+        /// </summary>
+        protected ValueConverter<T> BaseConverter { get; }
+        /// <summary>
+        /// Creates a collection of type <typeparamref name="TCollection"/> using the <paramref name="size"/> and
+        /// <paramref name="parent"/>.
+        /// </summary>
+        /// <param name="size">the initial size of the collecion</param>
+        /// <param name="parent">the object that will own the new collection</param>
+        /// <returns>a new instance of <typeparamref name="TCollection"/></returns>
+        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
+        protected virtual TCollection Create(int size, object parent)
+            => Activator.CreateInstance<TCollection>();
+        /// <summary>
+        /// Populates the colleciton <paramref name="col"/> with the deserialized values from <paramref name="list"/>
+        /// with the parent <paramref name="parent"/>.
+        /// </summary>
+        /// <param name="col">the collection to populate</param>
+        /// <param name="list">the values to populate it with</param>
+        /// <param name="parent">the object that will own the new objects</param>
+        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
+        protected void PopulateFromValue(TCollection col, List list, object parent)
+        {
+            foreach (var it in list)
+                col.Add(BaseConverter.FromValue(it, parent));
+        }
+        /// <summary>
+        /// Deserializes a <see cref="List"/> in <paramref name="value"/> into a new <typeparamref name="TCollection"/>
+        /// owned by <paramref name="parent"/>.
+        /// </summary>
+        /// <param name="value">the <see cref="List"/> to convert to a <typeparamref name="TCollection"/></param>
+        /// <param name="parent">the object that will own the resulting <typeparamref name="TCollection"/></param>
+        /// <returns>a new <typeparamref name="TCollection"/> holding the deserialized content of <paramref name="value"/></returns>
+        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
+        public override TCollection FromValue(Value value, object parent)
+        {
+            if (!(value is List list)) throw new ArgumentException("Argument not a List", nameof(value));
+
+            var col = Create(list.Count, parent);
+            PopulateFromValue(col, list, parent);
+            return col;
+        }
+        /// <summary>
+        /// Serializes a <typeparamref name="TCollection"/> into a <see cref="List"/>.
+        /// </summary>
+        /// <param name="obj">the <typeparamref name="TCollection"/> to serialize</param>
+        /// <param name="parent">the object owning <paramref name="obj"/></param>
+        /// <returns>the <see cref="List"/> that <paramref name="obj"/> was serialized into</returns>
+        /// <seealso cref="ValueConverter{T}.ToValue(T, object)"/>
+        public override Value ToValue(TCollection obj, object parent)
+            => Value.From(obj.Select(t => BaseConverter.ToValue(t, parent)));
+    }
+    /// <summary>
+    /// A <see cref="CollectionConverter{T, TCollection}"/> which default constructs a converter for use as the value converter.
+    /// </summary>
+    /// <typeparam name="T">the value type of the collection</typeparam>
+    /// <typeparam name="TCollection">the type of the colleciton</typeparam>
+    /// <typeparam name="TConverter">the type of the converter to use for <typeparamref name="T"/></typeparam>
+    /// <seealso cref="CollectionConverter{T, TCollection}"/>
+    public class CollectionConverter<T, TCollection, TConverter> : CollectionConverter<T, TCollection>
+        where TCollection : ICollection<T>
+        where TConverter : ValueConverter<T>, new()
+    {
+        /// <summary>
+        /// Creates a <see cref="CollectionConverter{T, TCollection}"/> using the default converter for the
+        /// element type. Equivalent to calling <see cref="CollectionConverter{T, TCollection}.CollectionConverter(ValueConverter{T})"/>
+        /// with a default-constructed <typeparamref name="TConverter"/>.
+        /// </summary>
+        /// <seealso cref="CollectionConverter{T, TCollection}.CollectionConverter(ValueConverter{T})"/>
+        public CollectionConverter() : base(new TConverter()) { }
+    }
+
+    public class ISetConverter<T> : CollectionConverter<T, ISet<T>>
+    {
+        public ISetConverter() : base() { }
+        public ISetConverter(ValueConverter<T> underlying) : base(underlying) { }
+        protected override ISet<T> Create(int size, object parent)
+            => new HashSet<T>();
+    }
+
+    public class ListConverter<T> : CollectionConverter<T, List<T>>
+    {
+        public ListConverter() : base() { }
+        public ListConverter(ValueConverter<T> underlying) : base(underlying) { }
+        protected override List<T> Create(int size, object parent)
+            => new List<T>(size);
+    }
+
+    public class IListConverter<T> : CollectionConverter<T, IList<T>>
+    {
+        public IListConverter() : base() { }
+        public IListConverter(ValueConverter<T> underlying) : base(underlying) { }
+        protected override IList<T> Create(int size, object parent)
+            => new List<T>(size);
+    }
+
+}

IPA.Loader/Config/Stores/Converters.cs

@@ -1,4 +1,5 @@
 using IPA.Config.Data;
+using IPA.Config.Stores.Attributes;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -171,6 +172,24 @@ namespace IPA.Config.Stores.Converters
             => obj == null ? null : baseConverter.ToValue(obj.Value, parent);
     }
 
+    /// <summary>
+    /// A converter for a <see cref="Nullable{T}"/> that default-constructs a converter of type <typeparamref name="TConverter"/>
+    /// to use as the underlying converter. Use this in the <see cref="UseConverterAttribute"/>.
+    /// </summary>
+    /// <typeparam name="T">the underlying type of the <see cref="Nullable{T}"/></typeparam>
+    /// <typeparam name="TConverter">the type to use as an underlying converter</typeparam>
+    /// <seealso cref="NullableConverter{T}"/>
+    public class NullableConverter<T, TConverter> : NullableConverter<T> 
+        where T : struct 
+        where TConverter : ValueConverter<T>, new()
+    {
+        /// <summary>
+        /// Creates a converter with a new <typeparamref name="TConverter"/> as the underlying converter.
+        /// </summary>
+        /// <seealso cref="NullableConverter{T}.NullableConverter(ValueConverter{T})"/>
+        public NullableConverter() : base(new TConverter()) { }
+    }
+
     internal class StringConverter : ValueConverter<string>
     {
         public override string FromValue(Value value, object parent)

IPA.Loader/Config/Stores/GeneratedStore.cs

@@ -325,10 +325,10 @@ namespace IPA.Config.Stores
 
                 var converterAttr = attrs.Select(o => o as UseConverterAttribute).NonNull().FirstOrDefault();
                 if (converterAttr != null)
-                {
+                { // TODO: figure out how to represent chaining
                     member.Converter = converterAttr.ConverterType;
                     member.ConverterTarget = converterAttr.ConverterTargetType;
-                    member.IsGenericConverter = member.ConverterTarget != null;
+                    member.IsGenericConverter = converterAttr.IsGenericConverter;
                 }
 
                 return true;

IPA.Loader/Config/Stores/ValueConverter.cs

@@ -19,6 +19,9 @@ namespace IPA.Config.Stores
     /// be (ideally) the the top of the serialization tree, or some other generated object in that tree, rather than some arbitrary
     /// object in the middle that is not managed by the generatd config system.
     /// </para>
+    /// <para>
+    /// Converters do <i>not</i> need to perform null checks, as the serializer and deserializer will do that automatically.
+    /// </para>
     /// </remarks>
     public interface IValueConverter
     {

IPA.Loader/IPA.Loader.csproj

@@ -97,6 +97,7 @@
     <Compile Include="Config\Stores\Attributes.cs" />
     <Compile Include="Config\Stores\Converters.cs" />
     <Compile Include="Config\Stores\CustomObjectConverter.cs" />
+    <Compile Include="Config\Stores\CollectionConverter.cs" />
     <Compile Include="Config\Stores\GeneratedStore.cs" />
     <Compile Include="Config\Stores\GeneratedStoreCollections.cs" />
     <Compile Include="Config\Stores\ValueConverter.cs" />

IPA.Loader/Loader/DisabledConfig.cs

@@ -1,6 +1,7 @@
 using IPA.Config;
 using IPA.Config.Stores;
 using IPA.Config.Stores.Attributes;
+using IPA.Config.Stores.Converters;
 using IPA.Utilities;
 using System;
 using System.Collections.Generic;
@@ -24,6 +25,8 @@ namespace IPA.Loader
 
         public virtual bool Reset { get; set; } = true;
 
+        [NonNullable]
+        [UseConverter(typeof(CollectionConverter<string, HashSet<string>>))]
         public virtual HashSet<string> DisabledModIds { get; set; } = new HashSet<string>();
 
         protected virtual void OnReload()