Generate operators from unit relations defined in JSON

CodeGen/Generators/QuantityRelationsParser.cs

@@ -31,33 +31,37 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
             var quantityDictionary = quantities.ToDictionary(q => q.Name, q => q);
 
             // Add double and 1 as pseudo-quantities to validate relations that use them.
-            var pseudoQuantity = new Quantity { Name = null!, Units = new[] { new Unit { SingularName = null! } } };
+            var pseudoQuantity = new Quantity { Name = null!, Units = [new Unit { SingularName = null! }] };
             quantityDictionary["double"] = pseudoQuantity with { Name = "double" };
             quantityDictionary["1"] = pseudoQuantity with { Name = "1" };
 
             var relations = ParseRelations(rootDir, quantityDictionary);
-            var timespanRelations = new List<QuantityRelation>();
 
-            foreach (var relation in relations)
-            {
-                if (relation.LeftQuantity.Name == "Duration")
+            // Because multiplication is commutative, we can infer the other operand order.
+            relations.AddRange(relations
+                .Where(r => r.Operator is "*" or "inverse" && r.LeftQuantity != r.RightQuantity)
+                .Select(r => r with
                 {
-                    timespanRelations.Add(relation with
-                    {
-                        LeftQuantity = new Quantity { Name = "TimeSpan" },
-                    });
-                }
-
-                if (relation.RightQuantity.Name == "Duration")
-                {
-                    timespanRelations.Add(relation with
-                    {
-                        RightQuantity = new Quantity { Name = "TimeSpan" },
-                    });
-                }
-            }
-
-            relations.AddRange(timespanRelations);
+                    LeftQuantity = r.RightQuantity,
+                    LeftUnit = r.RightUnit,
+                    RightQuantity = r.LeftQuantity,
+                    RightUnit = r.LeftUnit,
+                })
+                .ToList());
+
+            // We can infer TimeSpan relations from Duration relations.
+            var timeSpanQuantity = pseudoQuantity with { Name = "TimeSpan" };
+            relations.AddRange(relations
+                .Where(r => r.LeftQuantity.Name is "Duration")
+                .Select(r => r with { LeftQuantity = timeSpanQuantity })
+                .ToList());
+            relations.AddRange(relations
+                .Where(r => r.RightQuantity.Name is "Duration")
+                .Select(r => r with { RightQuantity = timeSpanQuantity })
+                .ToList());
+
+            // Sort all relations to keep generated operators in a consistent order.
+            relations.Sort();
 
             foreach (var quantity in quantities)
             {
@@ -67,24 +71,13 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                 {
                     if (relation.LeftQuantity == quantity)
                     {
+                        // The left operand of a relation is responsible for generating the operator.
                         quantityRelations.Add(relation);
-                        if (relation is { Operator: "*", RightQuantity.Name: "TimeSpan" or "double" })
-                        {
-                            quantityRelations.Add(relation.Swapped());
-                        }
                     }
-
-                    if (relation.RightQuantity == quantity)
+                    else if (relation.RightQuantity == quantity && relation.LeftQuantity.Name is "double" or "TimeSpan")
                     {
-                        if (relation.Operator == "inverse" || relation.Operator == "*" && relation.LeftQuantity != relation.RightQuantity)
-                        {
-                            quantityRelations.Add(relation.Swapped());
-                        }
-
-                        if (relation is { Operator: "/", LeftQuantity.Name: "double" })
-                        {
-                            quantityRelations.Add(relation);
-                        }
+                        // Because we cannot add generated operators to double or TimeSpan, we make the right operand responsible in this case.
+                        quantityRelations.Add(relation);
                     }
                 }
 
@@ -99,7 +92,7 @@ private static List<QuantityRelation> ParseRelations(string rootDir, IReadOnlyDi
             try
             {
                 var text = File.ReadAllText(relationsFileName);
-                var relationStrings = JsonConvert.DeserializeObject<List<string>>(text) ?? new List<string>();
+                var relationStrings = JsonConvert.DeserializeObject<List<string>>(text) ?? [];
                 relationStrings.Sort();
 
                 var parsedRelations = relationStrings.Select(relationString => ParseRelation(relationString, quantities)).ToList();
@@ -119,7 +112,7 @@ private static QuantityRelation ParseRelation(string relationString, IReadOnlyDi
         {
             var segments = relationString.Split(' ');
 
-            if (segments.Length != 5 || segments[1] != "=")
+            if (segments is not [_, "=", _, "*" or "/", _])
             {
                 throw new Exception($"Invalid relation string: {relationString}");
             }

CodeGen/JsonTypes/QuantityRelation.cs

@@ -1,9 +1,11 @@
 // 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;
+
 namespace CodeGen.JsonTypes
 {
-    internal record QuantityRelation
+    internal record QuantityRelation : IComparable<QuantityRelation>
     {
         public string Operator = null!;
 
@@ -16,12 +18,17 @@ internal record QuantityRelation
         public Quantity ResultQuantity = null!;
         public Unit ResultUnit = null!;
 
-        public QuantityRelation Swapped() => this with
+        private string SortString => ResultQuantity.Name
+                                     + ResultUnit.SingularName
+                                     + LeftQuantity.Name
+                                     + LeftUnit.SingularName
+                                     + Operator
+                                     + RightQuantity.Name
+                                     + RightUnit.SingularName;
+
+        public int CompareTo(QuantityRelation? other)
         {
-            LeftQuantity = RightQuantity,
-            LeftUnit = RightUnit,
-            RightQuantity = LeftQuantity,
-            RightUnit = LeftUnit,
-        };
+            return string.Compare(SortString, other?.SortString, StringComparison.Ordinal);
+        }
     }
 }

CodeGen/JsonTypes/Unit.cs

@@ -5,7 +5,7 @@
 
 namespace CodeGen.JsonTypes
 {
-    internal record Unit
+    internal class Unit
     {
         // 0649 Field is never assigned to
 #pragma warning disable 0649