Move abbreviation mapping to individual quantity types (#1031)

Author: tmilnthorp

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -165,6 +165,8 @@ private void GenerateStaticConstructor()
                 }},
                 BaseUnit, Zero, BaseDimensions, QuantityType.{_quantity.Name});
 
+            DefaultConversionFunctions = new UnitConverter();
+
             RegisterDefaultConversions(DefaultConversionFunctions);
         }}
 ");
@@ -229,7 +231,7 @@ private void GenerateStaticProperties()
         /// <summary>
         ///     The <see cref=""UnitConverter"" /> containing the default generated conversion functions for <see cref=""{_quantity.Name}"" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions {{ get; }} = new UnitConverter();
+        public static UnitConverter DefaultConversionFunctions {{ get; }}
 
         /// <inheritdoc cref=""IQuantity.QuantityInfo""/>
         public static QuantityInfo<{_unitEnumName}> Info {{ get; }}
@@ -384,14 +386,33 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter)
             if(unit.SingularName == _quantity.BaseUnit)
                 continue;
 
-        var func = unit.FromUnitToBaseFunc.Replace("{x}", "quantity.Value");
-        Writer.WL($@"
+            var func = unit.FromUnitToBaseFunc.Replace("{x}", "quantity.Value");
+            Writer.WL($@"
             unitConverter.SetConversionFunction<{_quantity.Name}>({_quantity.Name}Unit.{unit.SingularName}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => new {_quantity.Name}({func}, {_unitEnumName}.{_quantity.BaseUnit}));");
         }
 
         Writer.WL($@"
         }}
 
+        internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache)
+        {{");
+            foreach(var unit in _quantity.Units)
+            {
+                foreach(var localization in unit.Localization)
+                {
+                    // All units must have a unit abbreviation, so fallback to "" for units with no abbreviations defined in JSON
+                    var abbreviationParams = localization.Abbreviations.Any() ?
+                        string.Join(", ", localization.Abbreviations.Select(abbr => $@"""{abbr}""")) :
+                        $@"""""";
+
+                    Writer.WL($@"
+            unitAbbreviationsCache.MapUnitToAbbreviation({_unitEnumName}.{unit.SingularName}, new CultureInfo(""{localization.Culture}""), new string[]{{{abbreviationParams}}});");
+                }
+            }
+
+            Writer.WL($@"
+        }}
+
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>

CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs

@@ -155,6 +155,14 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType,
                     return false;
             }
         }
+
+        internal static IEnumerable<Type> GetQuantityTypes()
+        {");
+            foreach (var quantity in _quantities)
+                Writer.WL($@"
+            yield return typeof({quantity.Name});");
+            Writer.WL(@"
+        }
     }
 }");
             return Writer.ToString();

CodeGen/Generators/UnitsNetGen/UnitAbbreviationsCacheGenerator.cs

@@ -66,7 +66,6 @@ public static void Generate(string rootDir, Quantity[] quantities)
 
             Log.Information("");
             GenerateIQuantityTests(quantities, $"{testProjectDir}/GeneratedCode/IQuantityTests.g.cs");
-            GenerateUnitAbbreviationsCache(quantities, $"{outputDir}/UnitAbbreviationsCache.g.cs");
             GenerateQuantityType(quantities, $"{outputDir}/QuantityType.g.cs");
             GenerateStaticQuantity(quantities, $"{outputDir}/Quantity.g.cs");
 
@@ -122,13 +121,6 @@ private static void GenerateIQuantityTests(Quantity[] quantities, string filePat
             Log.Information("✅ IQuantityTests.g.cs");
         }
 
-        private static void GenerateUnitAbbreviationsCache(Quantity[] quantities, string filePath)
-        {
-            var content = new UnitAbbreviationsCacheGenerator(quantities).Generate();
-            File.WriteAllText(filePath, content);
-            Log.Information("✅ UnitAbbreviationsCache.g.cs");
-        }
-
         private static void GenerateQuantityType(Quantity[] quantities, string filePath)
         {
             var content = new QuantityTypeGenerator(quantities).Generate();

CodeGen/Generators/UnitsNetGenerator.cs

@@ -281,6 +281,25 @@ private void GenerateStaticMethods()
 
         #region Static Methods
 
+        internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache)
+        {{");
+            foreach(var unit in _quantity.Units)
+            {
+                foreach(var localization in unit.Localization)
+                {
+                    // All units must have a unit abbreviation, so fallback to "" for units with no abbreviations defined in JSON
+                    var abbreviationParams = localization.Abbreviations.Any() ?
+                        string.Join(", ", localization.Abbreviations.Select(abbr => $@"""{abbr}""")) :
+                        $@"""""";
+
+                    Writer.WL($@"
+            unitAbbreviationsCache.MapUnitToAbbreviation({_unitEnumName}.{unit.SingularName}, new CultureInfo(""{localization.Culture}""), new string[]{{{abbreviationParams}}});");
+                }
+            }
+
+            Writer.WL($@"
+        }}
+
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>

CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs

@@ -17,7 +17,7 @@ public override string Generate()
             Writer.WL(GeneratedFileHeader);
             Writer.WL(@"
 using System;
-using System.Linq;
+using System.Collections.Generic;
 using JetBrains.Annotations;
 using UnitsNet.InternalHelpers;
 using UnitsNet.Units;
@@ -114,6 +114,14 @@ internal static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type q
             throw new ArgumentException(
                 $""Type {{quantityType}} is not a known quantity type. Did you pass in a third-party quantity type defined outside UnitsNet library?"");
         }}
+
+        internal static IEnumerable<Type> GetQuantityTypes()
+        {{");
+            foreach (var quantity in _quantities)
+                Writer.WL($@"
+            yield return typeof({quantity.Name});");
+            Writer.WL($@"
+        }}
     }}
 }}");
             return Writer.ToString();

CodeGen/Generators/UnitsNetWrcGen/StaticQuantityGenerator.cs

@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.IO;
@@ -51,7 +51,6 @@ public static void Generate(string rootDir, Quantity[] quantities)
             }
 
             Log.Information("");
-            GenerateUnitAbbreviationsCache(quantities, $"{outputDir}/UnitAbbreviationsCache.g.cs");
             GenerateQuantityType(quantities, $"{outputDir}/QuantityType.g.cs");
             GenerateStaticQuantity(quantities, $"{outputDir}/Quantity.g.cs");
 
@@ -73,13 +72,6 @@ private static void GenerateUnitType(Quantity quantity, string filePath)
             File.WriteAllText(filePath, content);
         }
 
-        private static void GenerateUnitAbbreviationsCache(Quantity[] quantities, string filePath)
-        {
-            var content = new UnitAbbreviationsCacheGenerator(quantities).Generate();
-            File.WriteAllText(filePath, content);
-            Log.Information("✅ UnitAbbreviationsCache.g.cs (WRC)");
-        }
-
         private static void GenerateQuantityType(Quantity[] quantities, string filePath)
         {
             var content = new QuantityTypeGenerator(quantities).Generate();

CodeGen/Generators/UnitsNetWrcGen/UnitAbbreviationsCacheGenerator.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Reflection;
 using JetBrains.Annotations;
 using UnitsNet.InternalHelpers;
 using UnitsNet.Units;
@@ -14,7 +15,7 @@
 // ReSharper disable once CheckNamespace
 namespace UnitsNet
 {
-    public sealed partial class UnitAbbreviationsCache
+    public sealed class UnitAbbreviationsCache
     {
         private readonly Dictionary<IFormatProvider, UnitTypeToLookup> _lookupsForCulture;
 
@@ -45,10 +46,10 @@ static UnitAbbreviationsCache()
 
         private void LoadGeneratedAbbreviations()
         {
-            foreach(var localization in GeneratedLocalizations)
+            foreach(var quantity in Quantity.GetQuantityTypes())
             {
-                var culture = new CultureInfo(localization.CultureName);
-                MapUnitToAbbreviation(localization.UnitType, localization.UnitValue, culture, localization.UnitAbbreviations);
+                var mapGeneratedLocalizationsMethod = quantity.GetMethod(nameof(Length.MapGeneratedLocalizations), BindingFlags.NonPublic | BindingFlags.Static);
+                mapGeneratedLocalizationsMethod?.Invoke(null, new object[]{this});
             }
         }
 
@@ -57,13 +58,18 @@ private void LoadGeneratedAbbreviations()
         /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="LengthUnit"/> or to extend with third-party unit enums
         /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
         /// </summary>
-        /// <param name="unitType">The unit enum type.</param>
-        /// <param name="unitValue">The unit enum value.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
+        /// <param name="unit">The unit enum value.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
-        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
-        private void MapUnitToAbbreviation(Type unitType, int unitValue, IFormatProvider formatProvider, [NotNull] params string[] abbreviations)
+        /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
+        internal void MapUnitToAbbreviation<TUnitType>(TUnitType unit, IFormatProvider formatProvider, params string[] abbreviations) where TUnitType : Enum
         {
+            // Assuming TUnitType is an enum, this conversion is safe. Seems not possible to enforce this today.
+            // Src: http://stackoverflow.com/questions/908543/how-to-convert-from-system-enum-to-base-integer
+            // http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
+            var unitValue = Convert.ToInt32(unit);
+            var unitType = typeof(TUnitType);
+
             PerformAbbreviationMapping(unitType, unitValue, formatProvider, false, abbreviations);
         }