[ntuple] improve whitespace removal in type name normalization

Author: jblomer

tree/ntuple/src/RFieldUtils.cxx

@@ -119,62 +119,41 @@ std::vector<AnglePos> FindTemplateAngleBrackets(const std::string &typeName)
 }
 
 // TClassEdit::CleanType and the name demangling insert blanks between closing angle brackets,
-// as they were required before C++11. We want to remove them for RNTuple.
-void RemoveSpaceBeforeClosingAngleBracket(std::string &typeName)
+// as they were required before C++11. Name demangling introduces a blank before array dimensions,
+// which should also be removed.
+void RemoveSpaceBefore(std::string &typeName, char beforeChar)
 {
-   auto angle = typeName.find('<');
-   if (angle != std::string::npos) {
-      auto dst = typeName.begin() + angle;
-      auto end = typeName.end();
-      for (auto src = dst; src != end; ++src) {
-         if (*src == ' ') {
-            auto next = src + 1;
-            if (next != end && *next == '>') {
-               // Skip this space before a closing angle bracket.
-               continue;
-            }
+   auto dst = typeName.begin();
+   auto end = typeName.end();
+   for (auto src = dst; src != end; ++src) {
+      if (*src == ' ') {
+         auto next = src + 1;
+         if (next != end && *next == beforeChar) {
+            // Skip this space before a closing angle bracket.
+            continue;
          }
-         *(dst++) = *src;
       }
-      typeName.erase(dst, end);
+      *(dst++) = *src;
    }
+   typeName.erase(dst, end);
 }
 
 // The demangled name adds spaces after commas
-void RemoveSpaceAfterComma(std::string &typeName)
+void RemoveSpaceAfter(std::string &typeName, char afterChar)
 {
-   auto itr = typeName.begin();
-   while (itr != typeName.end()) {
-      auto c = *itr;
-      itr++;
-
-      if (c != ',')
-         continue;
-
-      R__ASSERT(itr != typeName.end());
-      if (*itr == ' ') {
-         itr = typeName.erase(itr);
-      }
-   }
-}
-
-// The demangled name adds a space before array dimensions
-void RemoveSpaceBeforeBracket(std::string &typeName)
-{
-   auto itr = typeName.begin();
-   while (itr != typeName.end()) {
-      auto last = itr;
-      itr++;
-
-      if (*last != ' ')
-         continue;
-
-      R__ASSERT(itr != typeName.end());
-      if (*itr == '[') {
-         itr = typeName.erase(last);
-         itr++;
+   auto dst = typeName.begin();
+   auto end = typeName.end();
+   for (auto src = dst; src != end; ++src) {
+      *(dst++) = *src;
+      if (*src == afterChar) {
+         auto next = src + 1;
+         if (next != end && *next == ' ') {
+            // Skip this space before a closing angle bracket.
+            ++src;
+         }
       }
    }
+   typeName.erase(dst, end);
 }
 
 // Map fundamental integer types to stdint integer types (e.g. int --> std::int32_t)
@@ -214,8 +193,8 @@ std::string GetDemangledTrimmedType(const std::type_info &ti)
    std::string result{str};
    free(str);
 
-   RemoveSpaceBeforeClosingAngleBracket(result);
-   RemoveSpaceAfterComma(result);
+   RemoveSpaceBefore(result, '>');
+   RemoveSpaceAfter(result, ',');
 
    return result;
 }
@@ -331,16 +310,16 @@ std::string GetRenormalizedDemangledTypeName(const std::string &demangledName)
    using ROOT::Internal::ParseArrayType;
 
    std::string tn{demangledName};
-   RemoveSpaceBeforeBracket(tn);
+   RemoveSpaceBefore(tn, '[');
    auto [canonicalTypePrefix, dimensions] = ParseArrayType(tn);
    MapIntegerType(canonicalTypePrefix);
 
    if (canonicalTypePrefix.find('<') == std::string::npos) {
       // If there are no templates, the function is done.
       return GetStandardArrayType(canonicalTypePrefix, dimensions);
    }
-   RemoveSpaceBeforeClosingAngleBracket(canonicalTypePrefix);
-   RemoveSpaceAfterComma(canonicalTypePrefix);
+   RemoveSpaceBefore(canonicalTypePrefix, '>');
+   RemoveSpaceAfter(canonicalTypePrefix, ',');
 
    // Remove optional stdlib template arguments
    int maxTemplateArgs = 0;
@@ -381,7 +360,7 @@ std::tuple<std::string, std::vector<std::size_t>> ROOT::Internal::GetCanonicalTy
       canonicalType.erase(0, 2);
    }
 
-   RemoveSpaceBeforeClosingAngleBracket(canonicalType);
+   RemoveSpaceBefore(canonicalType, '>');
 
    if (canonicalType.substr(0, 6) == "array<") {
       canonicalType = "std::" + canonicalType;