add processing for addition in unit strings

.codecov.yml

@@ -7,7 +7,7 @@ codecov:
 coverage:
   precision: 2
   round: down
-  range: '90...100'
+  range: '95...100'
   status:
     project:
       default:

test/test_unit_strings.cpp

@@ -1027,6 +1027,40 @@ TEST(stringToUnits, rotSequences)
     EXPECT_EQ(u1, unit_from_string("BTU-IT"));
 }
 
+TEST(stringToUnits, addition)
+{
+    auto u1 = unit_from_string("cm+cm");
+    EXPECT_EQ(u1, precise_unit(2, precise::cm));
+
+    u1 = unit_from_string("km + m+ cm+mm");
+    EXPECT_EQ(u1, precise_unit(1001.011, precise::m));
+    u1 = unit_from_string("kilometer+ 3in");
+    EXPECT_EQ(u1, (1.0 * precise::km + 3.0 * precise::in).as_unit());
+
+    u1 = unit_from_string("km+  7.0 feet");
+    EXPECT_EQ(u1, (1.0 * precise::km + 7.0 * precise::ft).as_unit());
+    u1 = unit_from_string("m*km+  ft*in");
+    EXPECT_EQ(
+        u1,
+        (1.0 * precise::km * precise::m + 1.0 * precise::ft * precise::in)
+            .as_unit());
+
+    u1 = unit_from_string("meter + hippyhoppy");
+    EXPECT_FALSE(is_valid(u1));
+
+    u1 = unit_from_string("hippyhoppy + meter");
+    EXPECT_FALSE(is_valid(u1));
+
+    u1 = unit_from_string("arggh + kilometer");
+    EXPECT_FALSE(is_valid(u1));
+
+    u1 = unit_from_string("kilometer + arggh");
+    EXPECT_FALSE(is_valid(u1));
+
+    u1 = unit_from_string("meter + kg");
+    EXPECT_EQ(u1, precise::m * precise::kg);
+}
+
 TEST(stringToUnits, cleanPhase2)
 {
     auto u1 = unit_from_string("tech-nical-at-mosphere");

units/units.cpp

@@ -4795,6 +4795,53 @@ static precise_unit
     return precise::invalid;
 }
 
+/** handle addition of similar units as a regular unit*/
+static precise_unit
+    checkUnitAddition(const std::string& unit_string, std::uint64_t match_flags)
+{
+    auto sep = findOperatorSep(unit_string, "+");
+    if (sep != std::string::npos && sep > 0) {
+        if ((unit_string[sep - 1] == '+') || sep == unit_string.size() - 1 ||
+            unit_string[sep + 1] == '+') {
+            return precise::invalid;
+        }
+        precise_unit a_unit;
+        precise_unit b_unit;
+        if (sep + 1 > unit_string.size() / 2) {
+            b_unit = unit_from_string_internal(
+                unit_string.substr(sep + 1), match_flags);
+            if (!is_valid(b_unit)) {
+                return precise::invalid;
+            }
+            a_unit = unit_from_string_internal(
+                unit_string.substr(0, sep), match_flags);
+
+            if (!is_valid(a_unit)) {
+                return precise::invalid;
+            }
+        } else {
+            a_unit = unit_from_string_internal(
+                unit_string.substr(0, sep), match_flags);
+
+            if (!is_valid(a_unit)) {
+                return precise::invalid;
+            }
+            b_unit = unit_from_string_internal(
+                unit_string.substr(sep + 1), match_flags);
+            if (!is_valid(b_unit)) {
+                return precise::invalid;
+            }
+        }
+        auto res = convert(b_unit, a_unit);
+        if (!std::isnan(res)) {
+            return {
+                a_unit.base_units(),
+                a_unit.multiplier() + a_unit.multiplier() * res};
+        }
+    }
+    return precise::invalid;
+}
+
 precise_unit
     unit_from_string(std::string unit_string, std::uint64_t match_flags)
 {
@@ -4934,6 +4981,13 @@ static precise_unit unit_from_string_internal(
         }
     }
 
+    if (unit_string.find_first_of('+') != std::string::npos) {
+        retunit = checkUnitAddition(unit_string, match_flags);
+        if (is_valid(retunit)) {
+            return retunit;
+        }
+    }
+
     auto sep = findOperatorSep(unit_string, "*/");
     if (sep != std::string::npos) {
         precise_unit a_unit;