Style cleanup

Author: jacobdufault

Assets/FullSerializer/Source/Converters/Unity/UnityEvent_Converter.cs

@@ -5,19 +5,22 @@
 
 namespace FullSerializer {
     partial class fsConverterRegistrar {
-        // Disable the converter for the time being. Unity's JsonUtility API cannot be called from
-        // within a C# ISerializationCallbackReceiver callback.
+        // Disable the converter for the time being. Unity's JsonUtility API
+        // cannot be called from within a C# ISerializationCallbackReceiver
+        // callback.
 
-        // public static Internal.Converters.UnityEvent_Converter Register_UnityEvent_Converter;
+        // public static Internal.Converters.UnityEvent_Converter
+        // Register_UnityEvent_Converter;
     }
 }
 
 namespace FullSerializer.Internal.Converters {
-    // The standard FS reflection converter has started causing Unity to crash when processing
-    // UnityEvent. We can send the serialization through JsonUtility which appears to work correctly
-    // instead.
+    // The standard FS reflection converter has started causing Unity to crash
+    // when processing UnityEvent. We can send the serialization through
+    // JsonUtility which appears to work correctly instead.
     //
-    // We have to support legacy serialization formats so importing works as expected.
+    // We have to support legacy serialization formats so importing works as
+    // expected.
     public class UnityEvent_Converter : fsConverter {
         public override bool CanProcess(Type type) {
             return typeof(UnityEvent).Resolve().IsAssignableFrom(type) && type.IsGenericType == false;

Assets/FullSerializer/Source/Converters/fsArrayConverter.cs

@@ -16,8 +16,8 @@ public override bool RequestInheritanceSupport(Type storageType) {
         }
 
         public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType) {
-            // note: IList[index] is **significantly** faster than Array.Get, so make sure we use
-            //       that instead.
+            // note: IList[index] is **significantly** faster than Array.Get, so
+            //       make sure we use that instead.
 
             IList arr = (Array)instance;
             Type elementType = storageType.GetElementType();

Assets/FullSerializer/Source/Converters/fsDateConverter.cs

@@ -6,7 +6,8 @@ namespace FullSerializer.Internal {
     /// Supports serialization for DateTime, DateTimeOffset, and TimeSpan.
     /// </summary>
     public class fsDateConverter : fsConverter {
-        // The format strings that we use when serializing DateTime and DateTimeOffset types.
+        // The format strings that we use when serializing DateTime and
+        // DateTimeOffset types.
         private const string DefaultDateTimeFormatString = @"o";
         private const string DateTimeOffsetFormatString = @"o";
 
@@ -57,12 +58,14 @@ public override fsResult TryDeserialize(fsData data, ref object instance, Type s
                     return fsResult.Success;
                 }
 
-                // DateTime.TryParse can fail for some valid DateTime instances. Try to use Convert.ToDateTime.
+                // DateTime.TryParse can fail for some valid DateTime instances.
+                // Try to use Convert.ToDateTime.
                 if (fsGlobalConfig.AllowInternalExceptions) {
                     try {
                         instance = Convert.ToDateTime(data.AsString);
                         return fsResult.Success;
-                    } catch (Exception e) {
+                    }
+                    catch (Exception e) {
                         return fsResult.Fail("Unable to parse " + data.AsString + " into a DateTime; got exception " + e);
                     }
                 }

Assets/FullSerializer/Source/Converters/fsDictionaryConverter.cs

@@ -4,9 +4,11 @@
 using System.Reflection;
 
 namespace FullSerializer.Internal {
-    // While the generic IEnumerable converter can handle dictionaries, we process them separately here because
-    // we support a few more advanced use-cases with dictionaries, such as inline strings. Further, dictionary
-    // processing in general is a bit more advanced because a few of the collection implementations are buggy.
+    // While the generic IEnumerable converter can handle dictionaries, we
+    // process them separately here because we support a few more advanced
+    // use-cases with dictionaries, such as inline strings. Further, dictionary
+    // processing in general is a bit more advanced because a few of the
+    // collection implementations are buggy.
     public class fsDictionaryConverter : fsConverter {
         public override bool CanProcess(Type type) {
             return typeof(IDictionary).IsAssignableFrom(type);
@@ -70,7 +72,8 @@ public override fsResult TrySerialize(object instance_, out fsData serialized, T
             Type keyStorageType, valueStorageType;
             GetKeyValueTypes(instance.GetType(), out keyStorageType, out valueStorageType);
 
-            // No other way to iterate dictionaries and still have access to the key/value info
+            // No other way to iterate dictionaries and still have access to the
+            // key/value info
             IDictionaryEnumerator enumerator = instance.GetEnumerator();
 
             bool allStringKeys = true;
@@ -116,23 +119,28 @@ public override fsResult TrySerialize(object instance_, out fsData serialized, T
         }
 
         private fsResult AddItemToDictionary(IDictionary dictionary, object key, object value) {
-            // Because we're operating through the IDictionary interface by default (and not the
-            // generic one), we normally send items through IDictionary.Add(object, object). This
-            // works fine in the general case, except that the add method verifies that it's
-            // parameter types are proper types. However, mono is buggy and these type checks do
-            // not consider null a subtype of the parameter types, and exceptions get thrown. So,
-            // we have to special case adding null items via the generic functions (which do not
-            // do the null check), which is slow and messy.
+            // Because we're operating through the IDictionary interface by
+            // default (and not the generic one), we normally send items through
+            // IDictionary.Add(object, object). This works fine in the general
+            // case, except that the add method verifies that it's parameter
+            // types are proper types. However, mono is buggy and these type
+            // checks do not consider null a subtype of the parameter types, and
+            // exceptions get thrown. So, we have to special case adding null
+            // items via the generic functions (which do not do the null check),
+            // which is slow and messy.
             //
-            // An example of a collection that fails deserialization without this method is
-            // `new SortedList<int, string> { { 0, null } }`. (SortedDictionary is fine because
-            // it properly handles null values).
+            // An example of a collection that fails deserialization without this
+            // method is `new SortedList<int, string> { { 0, null } }`.
+            // (SortedDictionary is fine because it properly handles null
+            // values).
             if (key == null || value == null) {
-                // Life would be much easier if we had MakeGenericType available, but we don't. So
-                // we're going to find the correct generic KeyValuePair type via a bit of trickery.
-                // All dictionaries extend ICollection<KeyValuePair<TKey, TValue>>, so we just
-                // fetch the ICollection<> type with the proper generic arguments, and then we take
-                // the KeyValuePair<> generic argument, and whola! we have our proper generic type.
+                // Life would be much easier if we had MakeGenericType available,
+                // but we don't. So we're going to find the correct generic
+                // KeyValuePair type via a bit of trickery. All dictionaries
+                // extend ICollection<KeyValuePair<TKey, TValue>>, so we just
+                // fetch the ICollection<> type with the proper generic
+                // arguments, and then we take the KeyValuePair<> generic
+                // argument, and whola! we have our proper generic type.
 
                 var collectionType = fsReflectionUtility.GetInterface(dictionary.GetType(), typeof(ICollection<>));
                 if (collectionType == null) {
@@ -146,23 +154,24 @@ private fsResult AddItemToDictionary(IDictionary dictionary, object key, object
                 return fsResult.Success;
             }
 
-            // We use the inline set methods instead of dictionary.Add; dictionary.Add will throw an exception
-            // if the key already exists.
+            // We use the inline set methods instead of dictionary.Add;
+            // dictionary.Add will throw an exception if the key already exists.
             dictionary[key] = value;
             return fsResult.Success;
         }
 
         private static void GetKeyValueTypes(Type dictionaryType, out Type keyStorageType, out Type valueStorageType) {
-            // All dictionaries extend IDictionary<TKey, TValue>, so we just fetch the generic arguments from it
+            // All dictionaries extend IDictionary<TKey, TValue>, so we just
+            // fetch the generic arguments from it
             var interfaceType = fsReflectionUtility.GetInterface(dictionaryType, typeof(IDictionary<,>));
             if (interfaceType != null) {
                 var genericArgs = interfaceType.GetGenericArguments();
                 keyStorageType = genericArgs[0];
                 valueStorageType = genericArgs[1];
             }
-
             else {
-                // Fetching IDictionary<,> failed... we have to encode full type information :(
+                // Fetching IDictionary<,> failed... we have to encode full type
+                // information :(
                 keyStorageType = typeof(object);
                 valueStorageType = typeof(object);
             }

Assets/FullSerializer/Source/Converters/fsEnumConverter.cs

@@ -20,8 +20,9 @@ public override bool RequestInheritanceSupport(Type storageType) {
         }
 
         public override object CreateInstance(fsData data, Type storageType) {
-            // In .NET compact, Enum.ToObject(Type, Object) is defined but the overloads like
-            // Enum.ToObject(Type, int) are not -- so we get around this by boxing the value.
+            // In .NET compact, Enum.ToObject(Type, Object) is defined but the
+            // overloads like Enum.ToObject(Type, int) are not -- so we get
+            // around this by boxing the value.
             return Enum.ToObject(storageType, (object)0);
         }
 
@@ -61,8 +62,8 @@ public override fsResult TryDeserialize(fsData data, ref object instance, Type s
                 for (int i = 0; i < enumValues.Length; ++i) {
                     string enumValue = enumValues[i];
 
-                    // Verify that the enum name exists; Enum.TryParse is only available in .NET 4.0
-                    // and above :(.
+                    // Verify that the enum name exists; Enum.TryParse is only
+                    // available in .NET 4.0 and above :(.
                     if (ArrayContains(Enum.GetNames(storageType), enumValue) == false) {
                         return fsResult.Fail("Cannot find enum name " + enumValue + " on type " + storageType);
                     }
@@ -74,12 +75,12 @@ public override fsResult TryDeserialize(fsData data, ref object instance, Type s
                 instance = Enum.ToObject(storageType, (object)instanceValue);
                 return fsResult.Success;
             }
-
             else if (data.IsInt64) {
                 int enumValue = (int)data.AsInt64;
 
-                // In .NET compact, Enum.ToObject(Type, Object) is defined but the overloads like
-                // Enum.ToObject(Type, int) are not -- so we get around this by boxing the value.
+                // In .NET compact, Enum.ToObject(Type, Object) is defined but
+                // the overloads like Enum.ToObject(Type, int) are not -- so we
+                // get around this by boxing the value.
                 instance = Enum.ToObject(storageType, (object)enumValue);
 
                 return fsResult.Success;
@@ -89,7 +90,8 @@ public override fsResult TryDeserialize(fsData data, ref object instance, Type s
         }
 
         /// <summary>
-        /// Returns true if the given value is contained within the specified array.
+        /// Returns true if the given value is contained within the specified
+        /// array.
         /// </summary>
         private static bool ArrayContains<T>(T[] values, T value) {
             // note: We don't use LINQ because this function will *not* allocate

Assets/FullSerializer/Source/Converters/fsForwardConverter.cs

@@ -2,15 +2,16 @@
 
 namespace FullSerializer {
     /// <summary>
-    /// This allows you to forward serialization of an object to one of its members. For example,
+    /// This allows you to forward serialization of an object to one of its
+    /// members. For example,
     ///
     /// [fsForward("Values")]
     /// struct Wrapper {
-    ///   public int[] Values;
+    ///     public int[] Values;
     /// }
     ///
-    /// Then `Wrapper` will be serialized into a JSON array of integers. It will be as if `Wrapper`
-    /// doesn't exist.
+    /// Then `Wrapper` will be serialized into a JSON array of integers. It will
+    /// be as if `Wrapper` doesn't exist.
     /// </summary>
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct)]
     public sealed class fsForwardAttribute : Attribute {
@@ -20,9 +21,12 @@ public sealed class fsForwardAttribute : Attribute {
         public string MemberName;
 
         /// <summary>
-        /// Forward object serialization to an instance member. See class comment.
+        /// Forward object serialization to an instance member. See class
+        /// comment.
         /// </summary>
-        /// <param name="memberName">The name of the member that we should serialize this object as.</param>
+        /// <param name="memberName">
+        /// The name of the member that we should serialize this object as.
+        /// </param>
         public fsForwardAttribute(string memberName) {
             MemberName = memberName;
         }

Assets/FullSerializer/Source/Converters/fsIEnumerableConverter.cs

@@ -5,7 +5,8 @@
 
 namespace FullSerializer.Internal {
     /// <summary>
-    /// Provides serialization support for anything which extends from `IEnumerable` and has an `Add` method.
+    /// Provides serialization support for anything which extends from
+    /// `IEnumerable` and has an `Add` method.
     /// </summary>
     public class fsIEnumerableConverter : fsConverter {
         public override bool CanProcess(Type type) {
@@ -29,16 +30,18 @@ public override fsResult TrySerialize(object instance_, out fsData serialized, T
             foreach (object item in instance) {
                 fsData itemData;
 
-                // note: We don't fail the entire deserialization even if the item failed
+                // note: We don't fail the entire deserialization even if the
+                //       item failed
                 var itemResult = Serializer.TrySerialize(elementType, item, out itemData);
                 result.AddMessages(itemResult);
                 if (itemResult.Failed) continue;
 
                 serializedList.Add(itemData);
             }
 
-            // Stacks iterate from back to front, which means when we deserialize we will deserialize
-            // the items in the wrong order, so the stack will get reversed.
+            // Stacks iterate from back to front, which means when we deserialize
+            // we will deserialize the items in the wrong order, so the stack
+            // will get reversed.
             if (IsStack(instance.GetType())) {
                 serializedList.Reverse();
             }
@@ -57,8 +60,8 @@ public override fsResult TryDeserialize(fsData data, ref object instance_, Type
 
             if ((result += CheckType(data, fsDataType.Array)).Failed) return result;
 
-            // For general strategy, instance may already have items in it. We will try to deserialize into
-            // the existing element.
+            // For general strategy, instance may already have items in it. We
+            // will try to deserialize into the existing element.
             var elementStorageType = GetElementType(storageType);
             var addMethod = GetAddMethod(storageType);
             var getMethod = storageType.GetFlattenedMethod("get_Item");
@@ -74,7 +77,8 @@ public override fsResult TryDeserialize(fsData data, ref object instance_, Type
                     itemInstance = getMethod.Invoke(instance, new object[] { i });
                 }
 
-                // note: We don't fail the entire deserialization even if the item failed
+                // note: We don't fail the entire deserialization even if the
+                //       item failed
                 var itemResult = Serializer.TryDeserialize(itemData, elementStorageType, ref itemInstance);
                 result.AddMessages(itemResult);
                 if (itemResult.Failed) continue;
@@ -125,10 +129,11 @@ private static int TryGetExistingSize(Type type, object instance) {
         }
 
         private static MethodInfo GetAddMethod(Type type) {
-            // There is a really good chance the type will extend ICollection{}, which will contain
-            // the add method we want. Just doing type.GetFlattenedMethod() may return the incorrect one --
-            // for example, with dictionaries, it'll return Add(TKey, TValue), and we want
-            // Add(KeyValuePair<TKey, TValue>).
+            // There is a really good chance the type will extend ICollection{},
+            // which will contain the add method we want. Just doing
+            // type.GetFlattenedMethod() may return the incorrect one -- for
+            // example, with dictionaries, it'll return Add(TKey, TValue), and we
+            // want Add(KeyValuePair<TKey, TValue>).
             Type collectionInterface = fsReflectionUtility.GetInterface(type, typeof(ICollection<>));
             if (collectionInterface != null) {
                 MethodInfo add = collectionInterface.GetDeclaredMethod("Add");

Assets/FullSerializer/Source/Converters/fsNullableConverter.cs

@@ -2,8 +2,8 @@
 
 namespace FullSerializer.Internal {
     /// <summary>
-    /// The reflected converter will properly serialize nullable types. However, we do it here
-    /// instead as we can emit less serialization data.
+    /// The reflected converter will properly serialize nullable types. However,
+    /// we do it here instead as we can emit less serialization data.
     /// </summary>
     public class fsNullableConverter : fsConverter {
         public override bool CanProcess(Type type) {

Assets/FullSerializer/Source/Converters/fsPrimitiveConverter.cs

@@ -58,10 +58,13 @@ public override fsResult TrySerialize(object instance, out fsData serialized, Ty
             }
 
             if (UseDouble(instanceType)) {
-                // Casting from float to double introduces floating point jitter, ie, 0.1 becomes 0.100000001490116.
-                // Casting to decimal as an intermediate step removes the jitter. Not sure why.
+                // Casting from float to double introduces floating point jitter,
+                // ie, 0.1 becomes 0.100000001490116. Casting to decimal as an
+                // intermediate step removes the jitter. Not sure why.
                 if (instance.GetType() == typeof(float) &&
-                    // Decimal can't store float.MinValue/float.MaxValue/float.PositiveInfinity/float.NegativeInfinity/float.NaN - an exception gets thrown in that scenario.
+                    // Decimal can't store
+                    // float.MinValue/float.MaxValue/float.PositiveInfinity/float.NegativeInfinity/float.NaN
+                    // - an exception gets thrown in that scenario.
                     (float)instance != float.MinValue &&
                     (float)instance != float.MaxValue &&
                     !float.IsInfinity((float)instance) &&
@@ -121,5 +124,4 @@ public override fsResult TryDeserialize(fsData storage, ref object instance, Typ
             return fsResult.Fail(GetType().Name + ": Bad data; expected bool, number, string, but got " + storage);
         }
     }
-}
-
+}