Add StringRef {take, drop} x {_while, _until}

[zturner]

Summary

This adds support for some common functional style operations
that allow you to take or drop characters until a certain
condition is met.

Example:

assert(StringRef("ABCD2908XYZ".take_while([](char c) { return ::is_hexdigit(c); }) == "XYZ");

[zturner]

Cleaned up the test. The lambda was unnecessary.

[davide]

lgtm, I like llvm becoming more haskell'y.

[davide]

include/llvm/ADT/StringRef.h

499–500

Oh, and maybe if you can add a comment at the beginning of each function (e.g. as consume_front() already does) it would be good.

[majnemer]

include/llvm/ADT/StringRef.h

499–511

Can you use function_ref instead?

[sanjoy]

Have you considered adding StringRef(iterator, iterator) constructor, and replacing the explicit loops with std::find_if and std::find_if_not.

[zturner]

Added find_if and made the drop and take functions use that.

[zturner]

Last patch was wrong. Let's try this.

[sanjoy]

lgtm modulo minor comments

include/llvm/ADT/StringRef.h

279

Docs?

282

Do you know if clang generates a zero-abstraction-overhead loop for this code? If it doesn't, it is an LLVM bug. :)

291

No LLVM_ATTRIBUTE_UNUSED_RESULT here?

292

Docs?

499

Docs?

Applies to all of the new functions you added.

unittests/ADT/StringRefTest.cpp

918

I'd use a separate variable for this:

StringRef EmptyStr = "";

Same comment for TakeWhileUntil.

include/llvm/ADT/StringRef.h

size_t find(char C, size_t From = 0) const {
       if (FindBegin < Length) { // Avoid calling memchr with nullptr.
         // Just forward to memchr, which is faster than a hand-rolled loop.
         if (const void *P = ::memchr(Data + FindBegin, C, Length - FindBegin))
           return static_cast<const char *>(P) - Data;
       }
       return npos;
     }
 
     /// Search for the first string \p Str in the string.
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
     size_t find(StringRef Str, size_t From = 0) const;
 
     /// Search for the last character \p C in the string.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
     size_t rfind(char C, size_t From = npos) const {
       From = std::min(From, Length);
       size_t i = From;
       while (i != 0) {
         --i;
         if (Data[i] == C)
           return i;
       }
       return npos;
     }
 
     /// Search for the last string \p Str in the string.
public:
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     LLVM_ATTRIBUTE_UNUSED_RESULT
     StringRef take_back(size_t N = 1) const {
       if (N >= size())
         return *this;
       return drop_front(size() - N);
     }
 
+    template <typename Func>
+    LLVM_ATTRIBUTE_UNUSED_RESULT StringRef take_while(Func F) const {
+      StringRef S(*this);
+      while (!S.empty()) {
+        if (!F(S.front()))
+          break;
+        S = S.drop_front();
+      }
+      return drop_back(S.size());
+    }
+
+    template <typename Func>
+    LLVM_ATTRIBUTE_UNUSED_RESULT StringRef take_until(Func F) const {
+      StringRef S(*this);
+      while (!S.empty()) {
+        if (F(S.front()))
+          break;
+        S = S.drop_front();
+      }
+      return drop_back(S.size());
+    }
+
     /// Return a StringRef equal to 'this' but with the first \p N elements
     /// dropped.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     LLVM_ATTRIBUTE_UNUSED_RESULT
     StringRef drop_front(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(N);
     }
 
     /// Return a StringRef equal to 'this' but with the last \p N elements
     /// dropped.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     LLVM_ATTRIBUTE_UNUSED_RESULT
     StringRef drop_back(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
       return substr(0, size()-N);
     }
 
+    template <typename Func>
+    LLVM_ATTRIBUTE_UNUSED_RESULT StringRef drop_while(Func F) const {
+      StringRef S(*this);
+      while (!S.empty()) {
+        if (!F(S.front()))
+          break;
+        S = S.drop_front();
+      }
+      return S;
+    }
+
+    template <typename Func>
+    LLVM_ATTRIBUTE_UNUSED_RESULT StringRef drop_until(Func F) const {
+      StringRef S(*this);
+      while (!S.empty()) {
+        if (F(S.front()))
+          break;
+        S = S.drop_front();
+      }
+      return S;
+    }
+
     /// Returns true if this StringRef has the given prefix and removes that
     /// prefix.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     LLVM_ATTRIBUTE_UNUSED_RESULT
     bool consume_front(StringRef Prefix) {
       if (!startswith(Prefix))
         return false;
 

unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, Take) {
 
   Taken = Test.take_front(0);
   EXPECT_TRUE(Taken.empty());
 
   Taken = Test.take_back(0);
   EXPECT_TRUE(Taken.empty());
 }
 
+TEST(StringRefTest, TakeWhileUntil) {
+  StringRef Test("String With 1 Number");
+
+  StringRef Taken = Test.take_while(::isdigit);
+  EXPECT_EQ("", Taken);
+
+  Taken = Test.take_until(::isdigit);
+  EXPECT_EQ("String With ", Taken);
+
+  Taken = Test.take_while([](char c) { return true; });
+  EXPECT_EQ(Test, Taken);
+
+  Taken = Test.take_until([](char c) { return true; });
+  EXPECT_EQ("", Taken);
+
+  Test = "";
+  Taken = Test.take_while([](char c) { return true; });
+  EXPECT_EQ("", Taken);
+}
+
+TEST(StringRefTest, DropWhileUntil) {
+  StringRef Test("String With 1 Number");
+
+  StringRef Taken = Test.drop_while(::isdigit);
+  EXPECT_EQ(Test, Taken);
+
+  Taken = Test.drop_until(::isdigit);
+  EXPECT_EQ("1 Number", Taken);
+
+  Taken = Test.drop_while([](char c) { return true; });
+  EXPECT_EQ("", Taken);
+
+  Taken = Test.drop_until([](char c) { return true; });
+  EXPECT_EQ(Test, Taken);
+
+  Test = "";
+  Taken = Test.drop_while([](char c) { return true; });
+  EXPECT_EQ("", Taken);
+}
+
 } // end anonymous namespace