X-Git-Url: http://plrg.eecs.uci.edu/git/?p=folly.git;a=blobdiff_plain;f=folly%2FRange.h;h=228a8d5535c213194b579ccda1e1144b16e7e45b;hp=a2c1d96cc91153e87f1843fb8a4c6b38a4e5cb5a;hb=327ee770028d0e28e51958eb0c635342407b6b06;hpb=cd2511afa674f917cbfe39fc8ea4cc7838184720

diff --git a/folly/Range.h b/folly/Range.h
index a2c1d96c..228a8d55 100644
--- a/folly/Range.h
+++ b/folly/Range.h
@@ -19,7 +19,6 @@
 
 #pragma once
 
-#include <folly/FBString.h>
 #include <folly/Portability.h>
 #include <folly/hash/SpookyHashV2.h>
 #include <folly/portability/BitsFunctexcept.h>
@@ -30,6 +29,7 @@
 #include <glog/logging.h>
 #include <algorithm>
 #include <array>
+#include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstring>
@@ -38,20 +38,9 @@
 #include <string>
 #include <type_traits>
 
-// libc++ doesn't provide this header, nor does msvc
-#ifdef FOLLY_HAVE_BITS_CXXCONFIG_H
-// This file appears in two locations: inside fbcode and in the
-// libstdc++ source code (when embedding fbstring as std::string).
-// To aid in this schizophrenic use, two macros are defined in
-// c++config.h:
-//   _LIBSTDCXX_FBSTRING - Set inside libstdc++.  This is useful to
-//      gate use inside fbcode v. libstdc++
-#include <bits/c++config.h>
-#endif
-
 #include <folly/CpuId.h>
-#include <folly/Traits.h>
 #include <folly/Likely.h>
+#include <folly/Traits.h>
 #include <folly/detail/RangeCommon.h>
 #include <folly/detail/RangeSse42.h>
 
@@ -61,7 +50,17 @@ FOLLY_GCC_DISABLE_WARNING("-Wshadow")
 
 namespace folly {
 
-template <class Iter> class Range;
+/**
+ * Ubiquitous helper template for knowing what's a string.
+ */
+template <class T>
+struct IsSomeString : std::false_type {};
+
+template <>
+struct IsSomeString<std::string> : std::true_type {};
+
+template <class Iter>
+class Range;
 
 /**
  * Finds the first occurrence of needle in haystack. The algorithm is on
@@ -69,11 +68,11 @@ template <class Iter> class Range;
  * as Boyer-Moore. On the upside, it does not do any upfront
  * preprocessing and does not allocate memory.
  */
-template <class Iter,
-          class Comp = std::equal_to<typename Range<Iter>::value_type>>
-inline size_t qfind(const Range<Iter> & haystack,
-                    const Range<Iter> & needle,
-                    Comp eq = Comp());
+template <
+    class Iter,
+    class Comp = std::equal_to<typename Range<Iter>::value_type>>
+inline size_t
+qfind(const Range<Iter>& haystack, const Range<Iter>& needle, Comp eq = Comp());
 
 /**
  * Finds the first occurrence of needle in haystack. The result is the
@@ -81,8 +80,9 @@ inline size_t qfind(const Range<Iter> & haystack,
  * needle wasn't found.
  */
 template <class Iter>
-size_t qfind(const Range<Iter> & haystack,
-             const typename Range<Iter>::value_type& needle);
+size_t qfind(
+    const Range<Iter>& haystack,
+    const typename Range<Iter>::value_type& needle);
 
 /**
  * Finds the last occurrence of needle in haystack. The result is the
@@ -90,17 +90,18 @@ size_t qfind(const Range<Iter> & haystack,
  * needle wasn't found.
  */
 template <class Iter>
-size_t rfind(const Range<Iter> & haystack,
-             const typename Range<Iter>::value_type& needle);
-
+size_t rfind(
+    const Range<Iter>& haystack,
+    const typename Range<Iter>::value_type& needle);
 
 /**
  * Finds the first occurrence of any element of needle in
  * haystack. The algorithm is O(haystack.size() * needle.size()).
  */
 template <class Iter>
-inline size_t qfind_first_of(const Range<Iter> & haystack,
-                             const Range<Iter> & needle);
+inline size_t qfind_first_of(
+    const Range<Iter>& haystack,
+    const Range<Iter>& needle);
 
 /**
  * Small internal helper - returns the value just before an iterator.
@@ -112,9 +113,10 @@ namespace detail {
  */
 template <class Iter>
 typename std::enable_if<
-  std::is_same<typename std::iterator_traits<Iter>::iterator_category,
-               std::random_access_iterator_tag>::value,
-  typename std::iterator_traits<Iter>::reference>::type
+    std::is_same<
+        typename std::iterator_traits<Iter>::iterator_category,
+        std::random_access_iterator_tag>::value,
+    typename std::iterator_traits<Iter>::reference>::type
 value_before(Iter i) {
   return i[-1];
 }
@@ -124,9 +126,10 @@ value_before(Iter i) {
  */
 template <class Iter>
 typename std::enable_if<
-  !std::is_same<typename std::iterator_traits<Iter>::iterator_category,
-                std::random_access_iterator_tag>::value,
-  typename std::iterator_traits<Iter>::reference>::type
+    !std::is_same<
+        typename std::iterator_traits<Iter>::iterator_category,
+        std::random_access_iterator_tag>::value,
+    typename std::iterator_traits<Iter>::reference>::type
 value_before(Iter i) {
   return *--i;
 }
@@ -135,7 +138,8 @@ value_before(Iter i) {
  * Use IsCharPointer<T>::type to enable const char* or char*.
  * Use IsCharPointer<T>::const_type to enable only const char*.
  */
-template <class T> struct IsCharPointer {};
+template <class T>
+struct IsCharPointer {};
 
 template <>
 struct IsCharPointer<char*> {
@@ -162,14 +166,13 @@ struct IsCharPointer<const char*> {
  * wouldn't.)
  */
 template <class Iter>
-class Range : private boost::totally_ordered<Range<Iter> > {
-public:
+class Range : private boost::totally_ordered<Range<Iter>> {
+ public:
   typedef std::size_t size_type;
   typedef Iter iterator;
   typedef Iter const_iterator;
   typedef typename std::remove_reference<
-    typename std::iterator_traits<Iter>::reference>::type
-  value_type;
+      typename std::iterator_traits<Iter>::reference>::type value_type;
   using difference_type = typename std::iterator_traits<Iter>::difference_type;
   typedef typename std::iterator_traits<Iter>::reference reference;
 
@@ -180,39 +183,39 @@ public:
    * args which are const.
    */
   typedef typename std::conditional<
-    std::is_same<Iter, char*>::value
-      || std::is_same<Iter, unsigned char*>::value,
-    Range<const value_type*>,
-    Range<Iter>>::type const_range_type;
+      std::is_same<Iter, char*>::value ||
+          std::is_same<Iter, unsigned char*>::value,
+      Range<const value_type*>,
+      Range<Iter>>::type const_range_type;
 
   typedef std::char_traits<typename std::remove_const<value_type>::type>
-    traits_type;
+      traits_type;
 
   static const size_type npos;
 
   // Works for all iterators
-  constexpr Range() : b_(), e_() {
-  }
+  constexpr Range() : b_(), e_() {}
 
   constexpr Range(const Range&) = default;
   constexpr Range(Range&&) = default;
 
-public:
+ public:
   // Works for all iterators
-  constexpr Range(Iter start, Iter end) : b_(start), e_(end) {
-  }
+  constexpr Range(Iter start, Iter end) : b_(start), e_(end) {}
 
   // Works only for random-access iterators
-  constexpr Range(Iter start, size_t size)
-      : b_(start), e_(start + size) { }
+  constexpr Range(Iter start, size_t size) : b_(start), e_(start + size) {}
 
-# if !__clang__ || __CLANG_PREREQ(3, 7) // Clang 3.6 crashes on this line
+#if !__clang__ || __CLANG_PREREQ(3, 7) // Clang 3.6 crashes on this line
   /* implicit */ Range(std::nullptr_t) = delete;
-# endif
+#endif
 
-  template <class T = Iter, typename detail::IsCharPointer<T>::type = 0>
   constexpr /* implicit */ Range(Iter str)
-      : b_(str), e_(str + constexpr_strlen(str)) {}
+      : b_(str), e_(str + constexpr_strlen(str)) {
+    static_assert(
+        std::is_same<int, typename detail::IsCharPointer<Iter>::type>::value,
+        "This constructor is only available for character ranges");
+  }
 
   template <class T = Iter, typename detail::IsCharPointer<T>::const_type = 0>
   /* implicit */ Range(const std::string& str)
@@ -228,9 +231,10 @@ public:
   }
 
   template <class T = Iter, typename detail::IsCharPointer<T>::const_type = 0>
-  Range(const std::string& str,
-        std::string::size_type startFrom,
-        std::string::size_type size) {
+  Range(
+      const std::string& str,
+      std::string::size_type startFrom,
+      std::string::size_type size) {
     if (UNLIKELY(startFrom > str.size())) {
       std::__throw_out_of_range("index out of range");
     }
@@ -242,34 +246,61 @@ public:
     }
   }
 
-  Range(const Range& other,
-        size_type first,
-        size_type length = npos)
-      : Range(other.subpiece(first, length))
-    { }
+  Range(const Range& other, size_type first, size_type length = npos)
+      : Range(other.subpiece(first, length)) {}
 
-  template <class T = Iter, typename detail::IsCharPointer<T>::const_type = 0>
-  /* implicit */ Range(const fbstring& str)
-    : b_(str.data()), e_(b_ + str.size()) { }
+  template <
+      class Container,
+      class = typename std::enable_if<
+          std::is_same<Iter, typename Container::const_pointer>::value>::type,
+      class = decltype(
+          Iter(std::declval<Container const&>().data()),
+          Iter(
+              std::declval<Container const&>().data() +
+              std::declval<Container const&>().size()))>
+  /* implicit */ constexpr Range(Container const& container)
+      : b_(container.data()), e_(b_ + container.size()) {}
 
-  template <class T = Iter, typename detail::IsCharPointer<T>::const_type = 0>
-  Range(const fbstring& str, fbstring::size_type startFrom) {
-    if (UNLIKELY(startFrom > str.size())) {
+  template <
+      class Container,
+      class = typename std::enable_if<
+          std::is_same<Iter, typename Container::const_pointer>::value>::type,
+      class = decltype(
+          Iter(std::declval<Container const&>().data()),
+          Iter(
+              std::declval<Container const&>().data() +
+              std::declval<Container const&>().size()))>
+  Range(Container const& container, typename Container::size_type startFrom) {
+    auto const cdata = container.data();
+    auto const csize = container.size();
+    if (UNLIKELY(startFrom > csize)) {
       std::__throw_out_of_range("index out of range");
     }
-    b_ = str.data() + startFrom;
-    e_ = str.data() + str.size();
+    b_ = cdata + startFrom;
+    e_ = cdata + csize;
   }
 
-  template <class T = Iter, typename detail::IsCharPointer<T>::const_type = 0>
-  Range(const fbstring& str, fbstring::size_type startFrom,
-        fbstring::size_type size) {
-    if (UNLIKELY(startFrom > str.size())) {
+  template <
+      class Container,
+      class = typename std::enable_if<
+          std::is_same<Iter, typename Container::const_pointer>::value>::type,
+      class = decltype(
+          Iter(std::declval<Container const&>().data()),
+          Iter(
+              std::declval<Container const&>().data() +
+              std::declval<Container const&>().size()))>
+  Range(
+      Container const& container,
+      typename Container::size_type startFrom,
+      typename Container::size_type size) {
+    auto const cdata = container.data();
+    auto const csize = container.size();
+    if (UNLIKELY(startFrom > csize)) {
       std::__throw_out_of_range("index out of range");
     }
-    b_ = str.data() + startFrom;
-    if (str.size() - startFrom < size) {
-      e_ = str.data() + str.size();
+    b_ = cdata + startFrom;
+    if (csize - startFrom < size) {
+      e_ = cdata + csize;
     } else {
       e_ = b_ + size;
     }
@@ -279,60 +310,70 @@ public:
   // Range<const unsigned char*> (aka ByteRange), as they're both frequently
   // used to represent ranges of bytes.  Allow explicit conversion in the other
   // direction.
-  template <class OtherIter, typename std::enable_if<
-      (std::is_same<Iter, const unsigned char*>::value &&
-       (std::is_same<OtherIter, const char*>::value ||
-        std::is_same<OtherIter, char*>::value)), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (std::is_same<Iter, const unsigned char*>::value &&
+           (std::is_same<OtherIter, const char*>::value ||
+            std::is_same<OtherIter, char*>::value)),
+          int>::type = 0>
   /* implicit */ Range(const Range<OtherIter>& other)
-    : b_(reinterpret_cast<const unsigned char*>(other.begin())),
-      e_(reinterpret_cast<const unsigned char*>(other.end())) {
-  }
+      : b_(reinterpret_cast<const unsigned char*>(other.begin())),
+        e_(reinterpret_cast<const unsigned char*>(other.end())) {}
 
-  template <class OtherIter, typename std::enable_if<
-      (std::is_same<Iter, unsigned char*>::value &&
-       std::is_same<OtherIter, char*>::value), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (std::is_same<Iter, unsigned char*>::value &&
+           std::is_same<OtherIter, char*>::value),
+          int>::type = 0>
   /* implicit */ Range(const Range<OtherIter>& other)
-    : b_(reinterpret_cast<unsigned char*>(other.begin())),
-      e_(reinterpret_cast<unsigned char*>(other.end())) {
-  }
+      : b_(reinterpret_cast<unsigned char*>(other.begin())),
+        e_(reinterpret_cast<unsigned char*>(other.end())) {}
 
-  template <class OtherIter, typename std::enable_if<
-      (std::is_same<Iter, const char*>::value &&
-       (std::is_same<OtherIter, const unsigned char*>::value ||
-        std::is_same<OtherIter, unsigned char*>::value)), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (std::is_same<Iter, const char*>::value &&
+           (std::is_same<OtherIter, const unsigned char*>::value ||
+            std::is_same<OtherIter, unsigned char*>::value)),
+          int>::type = 0>
   explicit Range(const Range<OtherIter>& other)
-    : b_(reinterpret_cast<const char*>(other.begin())),
-      e_(reinterpret_cast<const char*>(other.end())) {
-  }
+      : b_(reinterpret_cast<const char*>(other.begin())),
+        e_(reinterpret_cast<const char*>(other.end())) {}
 
-  template <class OtherIter, typename std::enable_if<
-      (std::is_same<Iter, char*>::value &&
-       std::is_same<OtherIter, unsigned char*>::value), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (std::is_same<Iter, char*>::value &&
+           std::is_same<OtherIter, unsigned char*>::value),
+          int>::type = 0>
   explicit Range(const Range<OtherIter>& other)
-    : b_(reinterpret_cast<char*>(other.begin())),
-      e_(reinterpret_cast<char*>(other.end())) {
-  }
+      : b_(reinterpret_cast<char*>(other.begin())),
+        e_(reinterpret_cast<char*>(other.end())) {}
 
   // Allow implicit conversion from Range<From> to Range<To> if From is
   // implicitly convertible to To.
-  template <class OtherIter, typename std::enable_if<
-     (!std::is_same<Iter, OtherIter>::value &&
-      std::is_convertible<OtherIter, Iter>::value), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (!std::is_same<Iter, OtherIter>::value &&
+           std::is_convertible<OtherIter, Iter>::value),
+          int>::type = 0>
   constexpr /* implicit */ Range(const Range<OtherIter>& other)
-    : b_(other.begin()),
-      e_(other.end()) {
-  }
+      : b_(other.begin()), e_(other.end()) {}
 
   // Allow explicit conversion from Range<From> to Range<To> if From is
   // explicitly convertible to To.
-  template <class OtherIter, typename std::enable_if<
-    (!std::is_same<Iter, OtherIter>::value &&
-     !std::is_convertible<OtherIter, Iter>::value &&
-     std::is_constructible<Iter, const OtherIter&>::value), int>::type = 0>
+  template <
+      class OtherIter,
+      typename std::enable_if<
+          (!std::is_same<Iter, OtherIter>::value &&
+           !std::is_convertible<OtherIter, Iter>::value &&
+           std::is_constructible<Iter, const OtherIter&>::value),
+          int>::type = 0>
   constexpr explicit Range(const Range<OtherIter>& other)
-    : b_(other.begin()),
-      e_(other.end()) {
-  }
+      : b_(other.begin()), e_(other.end()) {}
 
   /**
    * Allow explicit construction of Range() from a std::array of a
@@ -433,12 +474,19 @@ public:
     assert(b_ < e_);
     return detail::value_before(e_);
   }
+
+  template <typename Tgt>
+  auto to() const
+      -> decltype(Tgt(std::declval<Iter const&>(), std::declval<size_type>())) {
+    return Tgt(b_, size());
+  }
   // Works only for Range<const char*> and Range<char*>
-  std::string str() const { return std::string(b_, size()); }
-  std::string toString() const { return str(); }
-  // Works only for Range<const char*> and Range<char*>
-  fbstring fbstr() const { return fbstring(b_, size()); }
-  fbstring toFbstring() const { return fbstr(); }
+  std::string str() const {
+    return to<std::string>();
+  }
+  std::string toString() const {
+    return to<std::string>();
+  }
 
   const_range_type castToConst() const {
     return const_range_type(*this);
@@ -454,8 +502,9 @@ public:
       // We check the signed bit of the subtraction and bit shift it
       // to produce either 0 or 2. The subtraction yields the
       // comparison values of either -1 or 1.
-      r = (static_cast<int>(
-             (osize - tsize) >> (CHAR_BIT * sizeof(size_t) - 1)) << 1) - 1;
+      r = (static_cast<int>((osize - tsize) >> (CHAR_BIT * sizeof(size_t) - 1))
+           << 1) -
+          1;
     }
     return r;
   }
@@ -471,12 +520,16 @@ public:
   }
 
   value_type& at(size_t i) {
-    if (i >= size()) std::__throw_out_of_range("index out of range");
+    if (i >= size()) {
+      std::__throw_out_of_range("index out of range");
+    }
     return b_[i];
   }
 
   const value_type& at(size_t i) const {
-    if (i >= size()) std::__throw_out_of_range("index out of range");
+    if (i >= size()) {
+      std::__throw_out_of_range("index out of range");
+    }
     return b_[i];
   }
 
@@ -563,13 +616,17 @@ public:
   }
 
   size_type find(const_range_type str, size_t pos) const {
-    if (pos > size()) return std::string::npos;
+    if (pos > size()) {
+      return std::string::npos;
+    }
     size_t ret = qfind(castToConst().subpiece(pos), str);
     return ret == npos ? ret : ret + pos;
   }
 
   size_type find(Iter s, size_t pos, size_t n) const {
-    if (pos > size()) return std::string::npos;
+    if (pos > size()) {
+      return std::string::npos;
+    }
     auto forFinding = castToConst();
     size_t ret = qfind(
         pos ? forFinding.subpiece(pos) : forFinding, const_range_type(s, n));
@@ -583,7 +640,9 @@ public:
 
   // Works only for Range<(const) (unsigned) char*> which have Range(Iter) ctor
   size_type find(const Iter s, size_t pos) const {
-    if (pos > size()) return std::string::npos;
+    if (pos > size()) {
+      return std::string::npos;
+    }
     size_type ret = qfind(castToConst().subpiece(pos), const_range_type(s));
     return ret == npos ? ret : ret + pos;
   }
@@ -597,7 +656,9 @@ public:
   }
 
   size_type find(value_type c, size_t pos) const {
-    if (pos > size()) return std::string::npos;
+    if (pos > size()) {
+      return std::string::npos;
+    }
     size_type ret = qfind(castToConst().subpiece(pos), c);
     return ret == npos ? ret : ret + pos;
   }
@@ -607,7 +668,9 @@ public:
   }
 
   size_type find_first_of(const_range_type needles, size_t pos) const {
-    if (pos > size()) return std::string::npos;
+    if (pos > size()) {
+      return std::string::npos;
+    }
     size_type ret = qfind_first_of(castToConst().subpiece(pos), needles);
     return ret == npos ? ret : ret + pos;
   }
@@ -656,8 +719,8 @@ public:
    * Does this Range start with another range?
    */
   bool startsWith(const const_range_type& other) const {
-    return size() >= other.size()
-      && castToConst().subpiece(0, other.size()) == other;
+    return size() >= other.size() &&
+        castToConst().subpiece(0, other.size()) == other;
   }
   bool startsWith(value_type c) const {
     return !empty() && front() == c;
@@ -677,8 +740,8 @@ public:
    * Does this Range end with another range?
    */
   bool endsWith(const const_range_type& other) const {
-    return size() >= other.size()
-      && castToConst().subpiece(size() - other.size()) == other;
+    return size() >= other.size() &&
+        castToConst().subpiece(size() - other.size()) == other;
   }
   bool endsWith(value_type c) const {
     return !empty() && back() == c;
@@ -914,16 +977,18 @@ public:
    * @author: Marcelo Juchem <marcelo@fb.com>
    */
   template <typename TProcess, typename... Args>
-  auto split_step(value_type delimiter, TProcess &&process, Args &&...args)
-    -> decltype(process(std::declval<Range>(), std::forward<Args>(args)...))
-  { return process(split_step(delimiter), std::forward<Args>(args)...); }
+  auto split_step(value_type delimiter, TProcess&& process, Args&&... args)
+      -> decltype(process(std::declval<Range>(), std::forward<Args>(args)...)) {
+    return process(split_step(delimiter), std::forward<Args>(args)...);
+  }
 
   template <typename TProcess, typename... Args>
-  auto split_step(Range delimiter, TProcess &&process, Args &&...args)
-    -> decltype(process(std::declval<Range>(), std::forward<Args>(args)...))
-  { return process(split_step(delimiter), std::forward<Args>(args)...); }
+  auto split_step(Range delimiter, TProcess&& process, Args&&... args)
+      -> decltype(process(std::declval<Range>(), std::forward<Args>(args)...)) {
+    return process(split_step(delimiter), std::forward<Args>(args)...);
+  }
 
-private:
+ private:
   Iter b_, e_;
 };
 
@@ -947,22 +1012,43 @@ constexpr Range<Iter> range(Iter first, Iter last) {
  * Creates a range to reference the contents of a contiguous-storage container.
  */
 // Use pointers for types with '.data()' member
-template <
-    class Collection,
-    class T = typename std::remove_pointer<
-        decltype(std::declval<Collection>().data())>::type>
-constexpr Range<T*> range(Collection&& v) {
-  return Range<T*>(v.data(), v.data() + v.size());
+template <class Collection>
+constexpr auto range(Collection& v) -> Range<decltype(v.data())> {
+  return Range<decltype(v.data())>(v.data(), v.data() + v.size());
+}
+template <class Collection>
+constexpr auto range(Collection const& v) -> Range<decltype(v.data())> {
+  return Range<decltype(v.data())>(v.data(), v.data() + v.size());
+}
+template <class Collection>
+constexpr auto crange(Collection const& v) -> Range<decltype(v.data())> {
+  return Range<decltype(v.data())>(v.data(), v.data() + v.size());
 }
 
 template <class T, size_t n>
 constexpr Range<T*> range(T (&array)[n]) {
   return Range<T*>(array, array + n);
 }
+template <class T, size_t n>
+constexpr Range<T const*> range(T const (&array)[n]) {
+  return Range<T const*>(array, array + n);
+}
+template <class T, size_t n>
+constexpr Range<T const*> crange(T const (&array)[n]) {
+  return Range<T const*>(array, array + n);
+}
 
 template <class T, size_t n>
-constexpr Range<const T*> range(const std::array<T, n>& array) {
-  return Range<const T*>{array};
+constexpr Range<T*> range(std::array<T, n>& array) {
+  return Range<T*>{array};
+}
+template <class T, size_t n>
+constexpr Range<T const*> range(std::array<T, n> const& array) {
+  return Range<T const*>{array};
+}
+template <class T, size_t n>
+constexpr Range<T const*> crange(std::array<T, n> const& array) {
+  return Range<T const*>{array};
 }
 
 typedef Range<const char*> StringPiece;
@@ -1009,12 +1095,10 @@ namespace detail {
 template <class A, class B>
 struct ComparableAsStringPiece {
   enum {
-    value =
-    (std::is_convertible<A, StringPiece>::value
-     && std::is_same<B, StringPiece>::value)
-    ||
-    (std::is_convertible<B, StringPiece>::value
-     && std::is_same<A, StringPiece>::value)
+    value = (std::is_convertible<A, StringPiece>::value &&
+             std::is_same<B, StringPiece>::value) ||
+        (std::is_convertible<B, StringPiece>::value &&
+         std::is_same<A, StringPiece>::value)
   };
 };
 
@@ -1024,8 +1108,7 @@ struct ComparableAsStringPiece {
  * operator== through conversion for Range<const char*>
  */
 template <class T, class U>
-typename
-std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>::type
+_t<std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>>
 operator==(const T& lhs, const U& rhs) {
   return StringPiece(lhs) == StringPiece(rhs);
 }
@@ -1034,8 +1117,7 @@ operator==(const T& lhs, const U& rhs) {
  * operator< through conversion for Range<const char*>
  */
 template <class T, class U>
-typename
-std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>::type
+_t<std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>>
 operator<(const T& lhs, const U& rhs) {
   return StringPiece(lhs) < StringPiece(rhs);
 }
@@ -1044,8 +1126,7 @@ operator<(const T& lhs, const U& rhs) {
  * operator> through conversion for Range<const char*>
  */
 template <class T, class U>
-typename
-std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>::type
+_t<std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>>
 operator>(const T& lhs, const U& rhs) {
   return StringPiece(lhs) > StringPiece(rhs);
 }
@@ -1054,8 +1135,7 @@ operator>(const T& lhs, const U& rhs) {
  * operator< through conversion for Range<const char*>
  */
 template <class T, class U>
-typename
-std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>::type
+_t<std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>>
 operator<=(const T& lhs, const U& rhs) {
   return StringPiece(lhs) <= StringPiece(rhs);
 }
@@ -1064,8 +1144,7 @@ operator<=(const T& lhs, const U& rhs) {
  * operator> through conversion for Range<const char*>
  */
 template <class T, class U>
-typename
-std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>::type
+_t<std::enable_if<detail::ComparableAsStringPiece<T, U>::value, bool>>
 operator>=(const T& lhs, const U& rhs) {
   return StringPiece(lhs) >= StringPiece(rhs);
 }
@@ -1074,16 +1153,16 @@ operator>=(const T& lhs, const U& rhs) {
  * Finds substrings faster than brute force by borrowing from Boyer-Moore
  */
 template <class Iter, class Comp>
-size_t qfind(const Range<Iter>& haystack,
-             const Range<Iter>& needle,
-             Comp eq) {
+size_t qfind(const Range<Iter>& haystack, const Range<Iter>& needle, Comp eq) {
   // Don't use std::search, use a Boyer-Moore-like trick by comparing
   // the last characters first
   auto const nsize = needle.size();
   if (haystack.size() < nsize) {
     return std::string::npos;
   }
-  if (!nsize) return 0;
+  if (!nsize) {
+    return 0;
+  }
   auto const nsize_1 = nsize - 1;
   auto const lastNeedle = needle[nsize_1];
 
@@ -1105,7 +1184,7 @@ size_t qfind(const Range<Iter>& haystack,
     }
     // Here we know that the last char matches
     // Continue in pedestrian mode
-    for (size_t j = 0; ; ) {
+    for (size_t j = 0;;) {
       assert(j < nsize);
       if (!eq(i[j], needle[j])) {
         // Not found, we can skip
@@ -1131,23 +1210,24 @@ size_t qfind(const Range<Iter>& haystack,
 
 namespace detail {
 
-inline size_t qfind_first_byte_of(const StringPiece haystack,
-                                  const StringPiece needles) {
-  static auto const qfind_first_byte_of_fn =
-    folly::CpuId().sse42() ? qfind_first_byte_of_sse42
-                           : qfind_first_byte_of_nosse;
+inline size_t qfind_first_byte_of(
+    const StringPiece haystack,
+    const StringPiece needles) {
+  static auto const qfind_first_byte_of_fn = folly::CpuId().sse42()
+      ? qfind_first_byte_of_sse42
+      : qfind_first_byte_of_nosse;
   return qfind_first_byte_of_fn(haystack, needles);
 }
 
 } // namespace detail
 
 template <class Iter, class Comp>
-size_t qfind_first_of(const Range<Iter> & haystack,
-                      const Range<Iter> & needles,
-                      Comp eq) {
-  auto ret = std::find_first_of(haystack.begin(), haystack.end(),
-                                needles.begin(), needles.end(),
-                                eq);
+size_t qfind_first_of(
+    const Range<Iter>& haystack,
+    const Range<Iter>& needles,
+    Comp eq) {
+  auto ret = std::find_first_of(
+      haystack.begin(), haystack.end(), needles.begin(), needles.end(), eq);
   return ret == haystack.end() ? std::string::npos : ret - haystack.begin();
 }
 
@@ -1165,24 +1245,30 @@ struct AsciiCaseSensitive {
 struct AsciiCaseInsensitive {
   bool operator()(char lhs, char rhs) const {
     char k = lhs ^ rhs;
-    if (k == 0) return true;
-    if (k != 32) return false;
+    if (k == 0) {
+      return true;
+    }
+    if (k != 32) {
+      return false;
+    }
     k = lhs | rhs;
     return (k >= 'a' && k <= 'z');
   }
 };
 
 template <class Iter>
-size_t qfind(const Range<Iter>& haystack,
-             const typename Range<Iter>::value_type& needle) {
+size_t qfind(
+    const Range<Iter>& haystack,
+    const typename Range<Iter>::value_type& needle) {
   auto pos = std::find(haystack.begin(), haystack.end(), needle);
   return pos == haystack.end() ? std::string::npos : pos - haystack.data();
 }
 
 template <class Iter>
-size_t rfind(const Range<Iter>& haystack,
-             const typename Range<Iter>::value_type& needle) {
-  for (auto i = haystack.size(); i-- > 0; ) {
+size_t rfind(
+    const Range<Iter>& haystack,
+    const typename Range<Iter>::value_type& needle) {
+  for (auto i = haystack.size(); i-- > 0;) {
     if (haystack[i] == needle) {
       return i;
     }
@@ -1198,7 +1284,7 @@ inline size_t qfind(const Range<const char*>& haystack, const char& needle) {
     return std::string::npos;
   }
   auto pos = static_cast<const char*>(
-    ::memchr(haystack.data(), needle, haystack.size()));
+      ::memchr(haystack.data(), needle, haystack.size()));
   return pos == nullptr ? std::string::npos : pos - haystack.data();
 }
 
@@ -1209,76 +1295,106 @@ inline size_t rfind(const Range<const char*>& haystack, const char& needle) {
     return std::string::npos;
   }
   auto pos = static_cast<const char*>(
-    ::memrchr(haystack.data(), needle, haystack.size()));
+      ::memrchr(haystack.data(), needle, haystack.size()));
   return pos == nullptr ? std::string::npos : pos - haystack.data();
 }
 
 // specialization for ByteRange
 template <>
-inline size_t qfind(const Range<const unsigned char*>& haystack,
-                    const unsigned char& needle) {
+inline size_t qfind(
+    const Range<const unsigned char*>& haystack,
+    const unsigned char& needle) {
   // memchr expects a not-null pointer, early return if the range is empty.
   if (haystack.empty()) {
     return std::string::npos;
   }
   auto pos = static_cast<const unsigned char*>(
-    ::memchr(haystack.data(), needle, haystack.size()));
+      ::memchr(haystack.data(), needle, haystack.size()));
   return pos == nullptr ? std::string::npos : pos - haystack.data();
 }
 
 template <>
-inline size_t rfind(const Range<const unsigned char*>& haystack,
-                    const unsigned char& needle) {
+inline size_t rfind(
+    const Range<const unsigned char*>& haystack,
+    const unsigned char& needle) {
   // memchr expects a not-null pointer, early return if the range is empty.
   if (haystack.empty()) {
     return std::string::npos;
   }
   auto pos = static_cast<const unsigned char*>(
-    ::memrchr(haystack.data(), needle, haystack.size()));
+      ::memrchr(haystack.data(), needle, haystack.size()));
   return pos == nullptr ? std::string::npos : pos - haystack.data();
 }
 
 template <class Iter>
-size_t qfind_first_of(const Range<Iter>& haystack,
-                      const Range<Iter>& needles) {
+size_t qfind_first_of(const Range<Iter>& haystack, const Range<Iter>& needles) {
   return qfind_first_of(haystack, needles, AsciiCaseSensitive());
 }
 
 // specialization for StringPiece
 template <>
-inline size_t qfind_first_of(const Range<const char*>& haystack,
-                             const Range<const char*>& needles) {
+inline size_t qfind_first_of(
+    const Range<const char*>& haystack,
+    const Range<const char*>& needles) {
   return detail::qfind_first_byte_of(haystack, needles);
 }
 
 // specialization for ByteRange
 template <>
-inline size_t qfind_first_of(const Range<const unsigned char*>& haystack,
-                             const Range<const unsigned char*>& needles) {
-  return detail::qfind_first_byte_of(StringPiece(haystack),
-                                     StringPiece(needles));
+inline size_t qfind_first_of(
+    const Range<const unsigned char*>& haystack,
+    const Range<const unsigned char*>& needles) {
+  return detail::qfind_first_byte_of(
+      StringPiece(haystack), StringPiece(needles));
 }
 
-template<class Key, class Enable>
+template <class Key, class Enable>
 struct hasher;
 
 template <class T>
-struct hasher<folly::Range<T*>,
-              typename std::enable_if<std::is_pod<T>::value, void>::type> {
+struct hasher<
+    folly::Range<T*>,
+    typename std::enable_if<std::is_pod<T>::value, void>::type> {
   size_t operator()(folly::Range<T*> r) const {
     return hash::SpookyHashV2::Hash64(r.begin(), r.size() * sizeof(T), 0);
   }
 };
 
 /**
- * Ubiquitous helper template for knowing what's a string
+ * _sp is a user-defined literal suffix to make an appropriate Range
+ * specialization from a literal string.
+ *
+ * Modeled after C++17's `sv` suffix.
  */
-template <class T> struct IsSomeString {
-  enum { value = std::is_same<T, std::string>::value
-         || std::is_same<T, fbstring>::value };
-};
+inline namespace literals {
+inline namespace string_piece_literals {
+constexpr Range<char const*> operator"" _sp(
+    char const* str,
+    size_t len) noexcept {
+  return Range<char const*>(str, len);
+}
+
+constexpr Range<char16_t const*> operator"" _sp(
+    char16_t const* str,
+    size_t len) noexcept {
+  return Range<char16_t const*>(str, len);
+}
+
+constexpr Range<char32_t const*> operator"" _sp(
+    char32_t const* str,
+    size_t len) noexcept {
+  return Range<char32_t const*>(str, len);
+}
+
+constexpr Range<wchar_t const*> operator"" _sp(
+    wchar_t const* str,
+    size_t len) noexcept {
+  return Range<wchar_t const*>(str, len);
+}
+} // namespace string_piece_literals
+} // namespace literals
 
-}  // !namespace folly
+} // namespace folly
 
 FOLLY_POP_WARNING