[llvm][adt] Added TrimChars parameter to StringRef::Split

[njames93]

Summary

The overloads of StringRef::Split(SmallVector...) now have a 5th parameter called TrimChars which will trim substrings before adding them to the output vector

llvm/include/llvm/ADT/StringRef.h

public:
     }
 
     /// Split into substrings around the occurrences of a separator string.
     ///
     /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most
     /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1
     /// elements are added to A.
     /// If \p KeepEmpty is false, empty strings are not added to \p A. They
-    /// still count when considering \p MaxSplit
+    /// still count when considering \p MaxSplit. The substring has all
+    /// consecutive occurances of \p TrimChars characters removed from the 
+    /// front and back.
     /// An useful invariant is that
     /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true
     ///
     /// \param A - Where to put the substrings.
     /// \param Separator - The string to split on.
     /// \param MaxSplit - The maximum number of times the string is split.
     /// \param KeepEmpty - True if empty substring should be added.
-    void split(SmallVectorImpl<StringRef> &A,
-               StringRef Separator, int MaxSplit = -1,
-               bool KeepEmpty = true) const;
+    /// \param TrimChars - Chars to remove from front and back of substrings.
+    void split(SmallVectorImpl<StringRef> &A, StringRef Separator,
+               int MaxSplit = -1, bool KeepEmpty = true,
+               StringRef TrimChars = "") const;
 
     /// Split into substrings around the occurrences of a separator character.
     ///
     /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most
     /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1
     /// elements are added to A.
     /// If \p KeepEmpty is false, empty strings are not added to \p A. They
-    /// still count when considering \p MaxSplit
+    /// still count when considering \p MaxSplit. The substring has all
+    /// consecutive occurances of \p TrimChars characters removed from the 
+    /// front and back.
     /// An useful invariant is that
     /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true
     ///
     /// \param A - Where to put the substrings.
     /// \param Separator - The string to split on.
     /// \param MaxSplit - The maximum number of times the string is split.
     /// \param KeepEmpty - True if empty substring should be added.
+    /// \param TrimChars - Chars to remove from front and back of substrings.
     void split(SmallVectorImpl<StringRef> &A, char Separator, int MaxSplit = -1,
-               bool KeepEmpty = true) const;
+               bool KeepEmpty = true, StringRef TrimChars = "") const;
 
     /// Split into two substrings around the last occurrence of a separator
     /// character.
     ///
     /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
     /// such that (*this == LHS + Separator + RHS) is true and RHS is
     /// minimal. If \p Separator is not in the string, then the result is a
     /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").

llvm/lib/Support/StringRef.cpp

for (size_type i = 0, e = Chars.size(); i != e; ++i)
     CharBits.set((unsigned char)Chars[i]);
 
   for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
     if (!CharBits.test((unsigned char)Data[i]))
       return i;
   return npos;
 }
 
-void StringRef::split(SmallVectorImpl<StringRef> &A,
-                      StringRef Separator, int MaxSplit,
-                      bool KeepEmpty) const {
+void StringRef::split(SmallVectorImpl<StringRef> &A, StringRef Separator,
+                      int MaxSplit, bool KeepEmpty, StringRef TrimChars) const {
   StringRef S = *this;
 
   // Count down from MaxSplit. When MaxSplit is -1, this will just split
   // "forever". This doesn't support splitting more than 2^31 times
   // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
   // but that seems unlikely to be useful.
   while (MaxSplit-- != 0) {
     size_t Idx = S.find(Separator);
     if (Idx == npos)
       break;
 
+    StringRef Next = S.slice(0, Idx).trim(TrimChars);
+
     // Push this split.
-    if (KeepEmpty || Idx > 0)
-      A.push_back(S.slice(0, Idx));
+    if (KeepEmpty || !Next.empty())
+      A.push_back(Next);
 
     // Jump forward.
     S = S.slice(Idx + Separator.size(), npos);
   }
 
+  S = S.trim(TrimChars);
   // Push the tail.
   if (KeepEmpty || !S.empty())
     A.push_back(S);
 }
 
 void StringRef::split(SmallVectorImpl<StringRef> &A, char Separator,
-                      int MaxSplit, bool KeepEmpty) const {
+                      int MaxSplit, bool KeepEmpty, StringRef TrimChars) const {
   StringRef S = *this;
 
   // Count down from MaxSplit. When MaxSplit is -1, this will just split
   // "forever". This doesn't support splitting more than 2^31 times
   // intentionally; if we ever want that we can make MaxSplit a 64-bit integer
   // but that seems unlikely to be useful.
   while (MaxSplit-- != 0) {
     size_t Idx = S.find(Separator);
     if (Idx == npos)
       break;
 
+    StringRef Next = S.slice(0, Idx).trim(TrimChars);
+
     // Push this split.
-    if (KeepEmpty || Idx > 0)
-      A.push_back(S.slice(0, Idx));
+    if (KeepEmpty || !Next.empty())
+      A.push_back(Next);
 
     // Jump forward.
     S = S.slice(Idx + 1, npos);
   }
 
+  S = S.trim(TrimChars);
   // Push the tail.
   if (KeepEmpty || !S.empty())
     A.push_back(S);
 }
 
 //===----------------------------------------------------------------------===//
 // Helpful Algorithms
 //===----------------------------------------------------------------------===//

llvm/unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, Split2) {
 
   expected.clear(); parts.clear();
   expected.push_back("a");
   expected.push_back("");
   expected.push_back("b");
   expected.push_back("c,d");
   StringRef("a,,b,c,d").split(parts, ',', 3, true);
   EXPECT_TRUE(parts == expected);
+
+  expected.clear(); parts.clear();
+  expected.push_back("a");
+  expected.push_back("b");
+  expected.push_back("c");
+  expected.push_back("d");
+  expected.push_back("e");
+  StringRef("a, b ,c , d,  e  ").split(parts, ',', -1, true, " ");
+  EXPECT_TRUE(parts == expected);
+
+  expected.clear(); parts.clear();
+  expected.push_back("a");
+  expected.push_back("b");
+  expected.push_back("c");
+  expected.push_back("d");
+  expected.push_back("e");
+  StringRef("af, bf ,c ,f d,  fe  ").split(parts, ',', -1, true, "f ");
+  EXPECT_TRUE(parts == expected);
+
+  expected.clear(); parts.clear();
+  expected.push_back("a");
+  expected.push_back("b");
+  expected.push_back("c");
+  expected.push_back("d,  fe");
+  StringRef("af, bf ,c ,f d,  fe  ").split(parts, ',', 3, true, "f ");
+  EXPECT_TRUE(parts == expected);
+
+  expected.clear(); parts.clear();
+  expected.push_back("a");
+  expected.push_back("b");
+  expected.push_back("d");
+  expected.push_back("e");
+  StringRef("af, bf ,fff ,f d,  fe  ").split(parts, ',', -1, false, "f ");
+  EXPECT_TRUE(parts == expected);
+
 }
 
 TEST(StringRefTest, Trim) {
   StringRef Str0("hello");
   StringRef Str1(" hello ");
   StringRef Str2("  hello  ");
   StringRef Str3("\t\n\v\f\r  hello  \t\n\v\f\r");