measurement conversion factor changed to abstract generic class; adde…

…d volume conversion factor;

src/Nox.Types/Types/Volume/Measurement.cs

@@ -65,12 +65,14 @@ public override string ToString()
     public string ToString(IFormatProvider formatProvider)
         => $"{Value.ToString(formatProvider)} {Unit}";
 
-    protected QuantityValue GetMeasurementIn(MeasurementUnit targetUnit)
+    protected QuantityValue GetMeasurementIn(TUnitType targetUnit)
     {
-        var factor = new MeasurementConversionFactor(Unit, targetUnit).Value;
+        var factor = ResolveUnitConversionFactor(Unit, targetUnit);
         return Round(Value * factor);
     }
 
     private static QuantityValue Round(QuantityValue value)
         => Math.Round((double)value, QuantityValueDecimalPrecision);
+
+    protected abstract MeasurementConversionFactor<TUnitType> ResolveUnitConversionFactor(TUnitType sourceUnit, TUnitType targetUnit);
 }

src/Nox.Types/Types/Volume/MeasurementConversionFactor.cs

@@ -3,35 +3,34 @@
 
 namespace Nox.Types;
 
-public class MeasurementConversionFactor
+public abstract class MeasurementConversionFactor<TUnitType> where TUnitType : MeasurementUnit
 {
-    private static readonly Dictionary<(VolumeUnit, VolumeUnit), double> DefinedVolumeConversionFactors = new()
-    {
-        { (VolumeUnit.CubicFoot,  VolumeUnit.CubicMeter), 0.0283168466 },
-        { (VolumeUnit.CubicMeter,  VolumeUnit.CubicFoot), 35.3146667 },
-    };
+    protected abstract Dictionary<(TUnitType, TUnitType), double> DefinedConversionFactors { get; }
 
     public double Value { get; }
 
-    public MeasurementConversionFactor(MeasurementUnit sourceUnit, MeasurementUnit targetUnit)
+    protected MeasurementConversionFactor(TUnitType sourceUnit, TUnitType targetUnit)
     {
         Value = ResolveConversionFactor(sourceUnit, targetUnit);
     }
 
-    private static double ResolveConversionFactor(MeasurementUnit sourceUnit, MeasurementUnit targetUnit)
+    private double ResolveConversionFactor(TUnitType sourceUnit, TUnitType targetUnit)
     {
+        var conversion = (sourceUnit, targetUnit);
 
-        if (sourceUnit is VolumeUnit volumeSourceUnit && targetUnit is VolumeUnit volumeTargetUnit)
-        {
-            var conversion = (volumeSourceUnit, volumeTargetUnit);
+        if (DefinedConversionFactors.ContainsKey(conversion))
+            return DefinedConversionFactors[conversion];
 
-            if (DefinedVolumeConversionFactors.ContainsKey(conversion))
-                return DefinedVolumeConversionFactors[conversion];
-        }
 
         if (sourceUnit == targetUnit)
             return 1;
 
         throw new NotImplementedException($"No conversion defined from {sourceUnit?.Name} to {targetUnit?.Name}.");
     }
-}
+
+    public static QuantityValue operator *(QuantityValue value, MeasurementConversionFactor<TUnitType> factor)
+        => value * factor.Value;
+
+    public static QuantityValue operator *(MeasurementConversionFactor<TUnitType> factor, QuantityValue value)
+        => value * factor;
+}

src/Nox.Types/Types/Volume/Volume.cs

@@ -46,4 +46,7 @@ protected override IEnumerable<KeyValuePair<string, object>> GetEqualityComponen
     {
         yield return new KeyValuePair<string, object>(nameof(Value), ToCubicMeters());
     }
+
+    protected override MeasurementConversionFactor<VolumeUnit> ResolveUnitConversionFactor(VolumeUnit sourceUnit, VolumeUnit targetUnit)
+        => new VolumeConversionFactor(sourceUnit, targetUnit);
 }

src/Nox.Types/Types/Volume/VolumeConversionFactor.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace Nox.Types;
+
+public class VolumeConversionFactor : MeasurementConversionFactor<VolumeUnit>
+{
+    private static readonly Dictionary<(VolumeUnit, VolumeUnit), double> _definedVolumeConversionFactors = new()
+    {
+        { (VolumeUnit.CubicFoot,  VolumeUnit.CubicMeter), 0.0283168466 },
+        { (VolumeUnit.CubicMeter,  VolumeUnit.CubicFoot), 35.3146667 },
+    };
+
+    protected override Dictionary<(VolumeUnit, VolumeUnit), double> DefinedConversionFactors => _definedVolumeConversionFactors;
+
+    public VolumeConversionFactor(VolumeUnit sourceUnit, VolumeUnit targetUnit)
+        : base(sourceUnit, targetUnit)
+    {
+    }
+}

src/Nox.Types/Types/Volume/VolumeUnit.cs

@@ -9,3 +9,21 @@ private VolumeUnit(int id, string name, string symbol) : base(id, name, symbol)
     {
     }
 }
+
+
+public class LengthUnit : MeasurementUnit
+{
+    public static LengthUnit Meter { get; } = new LengthUnit(1, "Meter", "m");
+    public static LengthUnit Foot { get; } = new LengthUnit(2, "Foot", "ft");
+
+    protected LengthUnit(int id, string name, string symbol) : base(id, name, symbol)
+    {
+    }
+}
+
+public class DistanceUnit : LengthUnit
+{
+    protected DistanceUnit(int id, string name, string symbol) : base(id, name, symbol)
+    {
+    }
+}    

tests/Nox.Types.Tests/Types/Volume/VolumeConversionFactorTests.cs

@@ -0,0 +1,34 @@
+using FluentAssertions;
+
+namespace Nox.Types.Tests.Types;
+
+public class VolumeConversionFactorTests
+{
+    [Fact]
+    public void VolumeConversionFactor_FromCubicFootToCubicMeter_ReturnsValue()
+    {
+        var factor = new VolumeConversionFactor(VolumeUnit.CubicFoot, VolumeUnit.CubicMeter);
+
+        factor.Value.Should().Be(0.0283168466);
+    }
+
+    [Fact]
+    public void VolumeConversionFactor_FromCubicMeterToCubicFoot_ReturnsValue()
+    {
+        var factor = new VolumeConversionFactor(VolumeUnit.CubicMeter, VolumeUnit.CubicFoot);
+
+        factor.Value.Should().Be(35.3146667);
+    }
+
+    [Fact]
+    public void VolumeConversionFactor_WhenMultipliedByQuantityValue_ReturnsValue()
+    {
+        var factor = new VolumeConversionFactor(VolumeUnit.CubicMeter, VolumeUnit.CubicFoot);
+
+        var result1 = (QuantityValue)2.5 * factor;
+        var result2 = factor * (QuantityValue)2.5;
+
+        result1.Should().Be(result2);
+        result1.Should().Be(88.28666675);
+    }
+}

tests/Nox.Types.Tests/Types/Volume/VolumeTests.cs

@@ -214,6 +214,9 @@ private static void AssertAreEquivalent(Volume expected, Volume actual)
 
     private static void AssertAreNotEquivalent(Volume expected, Volume actual)
     {
+        var a =LengthUnit.Foot;
+        var b = DistanceUnit.Foot;
+
         actual.Should().NotBe(expected);
 
         expected.Equals(actual).Should().BeFalse();