Creating generic version of structs (WIP)

CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs

@@ -45,7 +45,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
                 // Example: LengthUnit.Centimeter
                 var unitEnumNameAndValue = $"{quantity.Name}Unit.{lastUnit.SingularName}";
                 Writer.WL($@"
-            Assertion(3, {unitEnumNameAndValue}, Quantity.From(3, {unitEnumNameAndValue}));");
+            Assertion(3, {unitEnumNameAndValue}, Quantity.From<double>(3, {unitEnumNameAndValue}));");
             }
             Writer.WL($@"
         }}
@@ -56,7 +56,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty()
             void Assertion(QuantityInfo expected, IQuantity quantity) => Assert.Same(expected, quantity.QuantityInfo);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.Info, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.Info, {quantity.Name}<double>.Zero);");
             Writer.WL($@"
         }}
 
@@ -66,7 +66,7 @@ public void Type_EqualsStaticQuantityTypeProperty()
             void Assertion(QuantityType expected, IQuantity quantity) => Assert.Equal(expected, quantity.Type);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.QuantityType, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.QuantityType, {quantity.Name}<double>.Zero);" );
             Writer.WL($@"
         }}
 
@@ -76,7 +76,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions()
             void Assertion(BaseDimensions expected, IQuantity quantity) => Assert.Equal(expected, quantity.Dimensions);
 ");
             foreach (var quantity in _quantities) Writer.WL($@"
-            Assertion({quantity.Name}.BaseDimensions, {quantity.Name}.Zero);");
+            Assertion({quantity.Name}<double>.BaseDimensions, {quantity.Name}<double>.Zero);" );
             Writer.WL($@"
         }}
     }}

CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs

@@ -38,12 +38,12 @@ public static class NumberTo{_quantityName}Extensions
             foreach (var unit in _units)
             {
                 Writer.WL(2, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
+/// <inheritdoc cref=""{_quantityName}{{T}}.From{unit.PluralName}(T)"" />");
 
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
-                Writer.WL(2, $@"public static {_quantityName} {unit.PluralName}<T>(this T value) =>
-            {_quantityName}.From{unit.PluralName}(Convert.ToDouble(value));
+                Writer.WL(2, $@"public static {_quantityName}<double> {unit.PluralName}<T>(this T value) =>
+            {_quantityName}<double>.From{unit.PluralName}(Convert.ToDouble(value));
 ");
             }
 

CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs

@@ -28,7 +28,7 @@ public override string Generate()
 using Xunit;
 
 namespace UnitsNet.Tests
-{{    
+{{
     public class NumberTo{_quantityName}ExtensionsTests
     {{");
 
@@ -40,7 +40,7 @@ public class NumberTo{_quantityName}ExtensionsTests
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
                 Writer.WL(2, $@"public void NumberTo{unit.PluralName}Test() =>
-            Assert.Equal({_quantityName}.From{unit.PluralName}(2), 2.{unit.PluralName}());
+            Assert.Equal({_quantityName}<double>.From{unit.PluralName}(2), 2.{unit.PluralName}());
 ");
             }
 

CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs

@@ -60,7 +60,7 @@ public static partial class Quantity
         /// <param name=""value"">The value to construct the quantity with.</param>
         /// <returns>The created quantity.</returns>
         [Obsolete(""QuantityType will be removed. Use FromQuantityInfo(QuantityInfo, QuantityValue) instead."")]
-        public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValue value)
+        public static IQuantity FromQuantityType<T>(QuantityType quantityType, QuantityValue value)
         {
             switch(quantityType)
             {");
@@ -69,7 +69,7 @@ public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValu
                 var quantityName = quantity.Name;
                 Writer.WL($@"
                 case QuantityType.{quantityName}:
-                    return {quantityName}.From(value, {quantityName}.BaseUnit);");
+                    return {quantityName}<T>.From(value, {quantityName}<T>.BaseUnit);");
             }
 
             Writer.WL(@"
@@ -109,7 +109,7 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu
         /// <param name=""unit"">Unit enum value.</param>
         /// <param name=""quantity"">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns><c>True</c> if successful with <paramref name=""quantity""/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quantity)
+        public static bool TryFrom<T>(QuantityValue value, Enum unit, out IQuantity? quantity)
         {
             switch (unit)
             {");
@@ -120,7 +120,7 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti
                 var unitValue = unitTypeName.ToCamelCase();
                 Writer.WL($@"
                 case {unitTypeName} {unitValue}:
-                    quantity = {quantityName}.From(value, {unitValue});
+                    quantity = {quantityName}<T>.From(value, {unitValue});
                     return true;");
             }
 
@@ -137,11 +137,11 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti
         ///     Try to dynamically parse a quantity string representation.
         /// </summary>
         /// <param name=""formatProvider"">The format provider to use for lookup. Defaults to <see cref=""CultureInfo.CurrentUICulture"" /> if null.</param>
-        /// <param name=""quantityType"">Type of quantity, such as <see cref=""Length""/>.</param>
+        /// <param name=""quantityType"">Type of quantity, such as <see cref=""Length{T}""/>.</param>
         /// <param name=""quantityString"">Quantity string representation, such as ""1.5 kg"". Must be compatible with given quantity type.</param>
         /// <param name=""quantity"">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns>The parsed quantity.</returns>
-        public static bool TryParse(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
+        public static bool TryParse<T>(IFormatProvider? formatProvider, Type quantityType, string quantityString, out IQuantity? quantity)
         {
             quantity = default(IQuantity);
 
@@ -156,8 +156,8 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType,
             {
                 var quantityName = quantity.Name;
                 Writer.WL($@"
-                case Type _ when quantityType == typeof({quantityName}):
-                    return parser.TryParse<{quantityName}, {quantityName}Unit>(quantityString, formatProvider, {quantityName}.From, out quantity);");
+                case Type _ when quantityType == typeof({quantityName}<T>):
+                    return parser.TryParse<{quantityName}<T>, {quantityName}Unit>(quantityString, formatProvider, {quantityName}<T>.From, out quantity);");
             }
 
             Writer.WL(@"

CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.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 ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
 
 using CodeGen.Helpers;
@@ -26,23 +26,23 @@ public override string Generate()
 
 namespace UnitsNet
 {{
-    public sealed partial class UnitConverter
+    public sealed partial class UnitConverter<T>
     {{
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref=""UnitConverter""/> instance.
+        /// Registers the default conversion functions in the given <see cref=""UnitConverter{{T}}""/> instance.
         /// </summary>
-        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to register the default conversion functions in.</param>
-        public static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {{");
+        /// <param name=""unitConverter"">The <see cref=""UnitConverter{{T}}""/> to register the default conversion functions in.</param>
+        public static void RegisterDefaultConversions(UnitConverter<T> 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}<T>>({quantity.Name}<T>.BaseUnit, {quantity.Name}<T>.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());");
+            unitConverter.SetConversionFunction<{quantity.Name}<T>>({quantity.Name}<T>.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName}));
+            unitConverter.SetConversionFunction<{quantity.Name}<T>>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}<T>.BaseUnit, q => q.ToBaseUnit());");
             }
 
             Writer.WL($@"