Dynamic unit conversions (#588)

* Allowing custom unit conversion functions to be specified

* Registering default base->unit and unit->base conversion functions in UnitConverter. Adding test for custom direct conversions

* Whitespace consistency

* Add some overloads and allowing source/target quantities to be different

* Inline initialization and style update for field

* PR feedback updates

* Regen WRC

* Use IQuantity.Value in test case

* Rename typeparams, remove empty ctor

* Micro optimization of lookup of IQuantity type

It was looked up and wrapped N times

* UnitConverter: Move static field initialization to static ctor

They became a bit unwieldy.
Move fields to top of class.

* Add typed conversion function for same quantity conversion functions

Since this is the most commonly used call path by far, it made sense to handle this case separately.
The advantage is that the callback quantity is strongly typed.

* Use typed conversions in RegisterDefaultConversions

* Header update

* Add xmldoc and minor renaming

* Add test cases for Type parameters

* QuantityParser: Make field readonly

* UnitParser: Add test parsing HowMuch custom unit

* UnitConverter: Echo quantity when converting to same unit, test custom quantity conversions

* Port codegen scripts to C#

The only difference is fixing the header of a file.

* Regen code

Author: tmilnthorp

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -904,6 +904,17 @@ IQuantity IQuantity.ToUnit(Enum unit)
             }}
         }}
 
+        /// <summary>
+        ///     Converts the current value + unit to the base unit.
+        ///     This is typically the first step in converting from one unit to another.
+        /// </summary>
+        /// <returns>The value in the base unit representation.</returns>
+        internal {_quantity.Name} ToBaseUnit()
+        {{
+            var baseUnitValue = GetValueInBaseUnit();
+            return new {_quantity.Name}(baseUnitValue, BaseUnit);
+        }}
+
         private {_valueType} GetValueAs({_unitEnumName} unit)
         {{
             if(Unit == unit)

CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs

@@ -0,0 +1,56 @@
+// 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 CodeGen.Helpers;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class UnitConverterGenerator : GeneratorBase
+    {
+        private readonly Quantity[] _quantities;
+
+        public UnitConverterGenerator(Quantity[] quantities)
+        {
+            _quantities = quantities;
+        }
+
+        public override string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+            Writer.WL($@"
+using UnitsNet.Units;
+
+// ReSharper disable RedundantCommaInArrayInitializer
+// ReSharper disable once CheckNamespace
+
+namespace UnitsNet
+{{
+    public sealed partial class UnitConverter
+    {{
+        /// <summary>
+        /// Registers the default conversion functions in the given <see cref=""UnitConverter""/> instance.
+        /// </summary>
+        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to register the default conversion functions in.</param>
+        public static void RegisterDefaultConversions(UnitConverter unitConverter)
+        {{");
+            foreach (Quantity quantity in _quantities)
+            foreach (Unit unit in quantity.Units)
+            {
+                Writer.WL(quantity.BaseUnit == unit.SingularName
+                    ? $@"
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}.BaseUnit, q => q);"
+                    : $@"
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName}));
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}.BaseUnit, q => q.ToBaseUnit());");
+            }
+
+            Writer.WL($@"
+        }}
+    }}
+}}");
+
+            return Writer.ToString();
+        }
+    }
+}

CodeGen/Generators/UnitsNetGenerator.cs

@@ -58,6 +58,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
             GenerateUnitAbbreviationsCache(quantities, $"{outputDir}/UnitAbbreviationsCache.g.cs");
             GenerateQuantityType(quantities, $"{outputDir}/QuantityType.g.cs");
             GenerateStaticQuantity(quantities, $"{outputDir}/Quantity.g.cs");
+            GenerateUnitConverter(quantities, $"{outputDir}/UnitConverter.g.cs");
 
             var unitCount = quantities.SelectMany(q => q.Units).Count();
             Log.Information("");
@@ -119,5 +120,12 @@ private static void GenerateStaticQuantity(Quantity[] quantities, string filePat
             File.WriteAllText(filePath, content, Encoding.UTF8);
             Log.Information("Quantity.g.cs: ".PadRight(AlignPad) + "(OK)");
         }
+
+        private static void GenerateUnitConverter(Quantity[] quantities, string filePath)
+        {
+            var content = new UnitConverterGenerator(quantities).Generate();
+            File.WriteAllText(filePath, content, Encoding.UTF8);
+            Log.Information("UnitConverter.g.cs: ".PadRight(AlignPad) + "(OK)");
+        }
     }
 }

UnitsNet.Tests/UnitConverterTest.cs

@@ -1,12 +1,115 @@
 // 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;
+using UnitsNet.Tests.CustomQuantities;
+using UnitsNet.Units;
 using Xunit;
 
 namespace UnitsNet.Tests
 {
     public class UnitConverterTest
     {
+        [Fact]
+        public void CustomConversionWithSameQuantityType()
+        {
+            Length ConversionFunction(Length from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
+            var converted = foundConversionFunction(Length.FromMeters(1.0));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithSameQuantityTypeByTypeParam()
+        {
+            Length ConversionFunction(Length from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction<Length>) ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length), LengthUnit.Meter, typeof(Length), LengthUnit.Inch);
+            var converted = foundConversionFunction(Length.FromMeters(1.0));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithDifferentQuantityTypes()
+        {
+            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass.FromGrains(100));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithDifferentQuantityTypesByTypeParam()
+        {
+            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass), MassUnit.Grain, typeof(Length), LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass.FromGrains(100));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void TryCustomConversionForOilBarrelsToUsGallons()
+        {
+            Volume ConversionFunction(Volume from) => Volume.FromUsGallons(from.Value * 42);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon);
+            var converted = foundConversionFunction(Volume.FromOilBarrels(1));
+
+            Assert.Equal(Volume.FromUsGallons(42), converted);
+        }
+
+        [Fact]
+        public void ConversionToSameUnit_ReturnsSameQuantity()
+        {
+            var unitConverter = new UnitConverter();
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(HowMuchUnit.ATon, HowMuchUnit.ATon);
+            var converted = foundConversionFunction(new HowMuch(39, HowMuchUnit.Some)); // Intentionally pass the wrong unit here, to test that the exact same quantity is returned
+
+            Assert.Equal(39, converted.Value);
+            Assert.Equal(HowMuchUnit.Some, converted.Unit);
+        }
+
+        [Theory]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.Some, 1)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.ATon, 2)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.AShitTon, 10)]
+        public void ConversionForUnitsOfCustomQuantity(double fromValue, Enum fromUnit, Enum toUnit, double expectedValue)
+        {
+            // Intentionally don't map conversion Some->Some, it is not necessary
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.ATon, x => new HowMuch(x.Value * 2, HowMuchUnit.ATon));
+            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.AShitTon, x => new HowMuch(x.Value * 10, HowMuchUnit.AShitTon));
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(fromUnit, toUnit);
+            var converted = foundConversionFunction(new HowMuch(fromValue, fromUnit));
+
+            Assert.Equal(expectedValue, converted.Value);
+            Assert.Equal(toUnit, converted.Unit);
+        }
+
         [Theory]
         [InlineData(0, 0, "length", "meter", "centimeter")]
         [InlineData(0, 0, "Length", "Meter", "Centimeter")]

UnitsNet.Tests/UnitParserTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using UnitsNet.Tests.CustomQuantities;
 using UnitsNet.Units;
 using Xunit;
 
@@ -124,5 +125,17 @@ public void ParseMassUnit_GivenCulture(string str, string cultureName, Enum expe
         {
             Assert.Equal(expectedUnit, UnitParser.Default.Parse<MassUnit>(str, new CultureInfo(cultureName)));
         }
+
+        [Fact]
+        public void Parse_MappedCustomUnit()
+        {
+            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh");
+            var unitParser = new UnitParser(unitAbbreviationsCache);
+
+            var parsedUnit = unitParser.Parse<HowMuchUnit>("fooh");
+
+            Assert.Equal(HowMuchUnit.Some, parsedUnit);
+        }
     }
 }

UnitsNet/CustomCode/QuantityParser.cs

@@ -25,7 +25,7 @@ internal class QuantityParser
         private const NumberStyles ParseNumberStyles = NumberStyles.Number | NumberStyles.Float | NumberStyles.AllowExponent;
 
         private readonly UnitAbbreviationsCache _unitAbbreviationsCache;
-        private UnitParser _unitParser;
+        private readonly UnitParser _unitParser;
 
         public static QuantityParser Default { get; }