From fc10d0b8b1506335b2ff811a4c7e9eeb2a7a7b67 Mon Sep 17 00:00:00 2001 From: Yedidya Feldblum Date: Sat, 5 Aug 2017 22:00:20 -0700 Subject: [PATCH] Apply clang-format to folly/**/*Range*.* Summary: [Folly] Apply `clang-format` to `folly/**/*Range*.*`. Reviewed By: meyering Differential Revision: D5570553 fbshipit-source-id: 230aa8557c2d402d741aaa541f96f4634dd13d3b --- folly/Range.h | 381 +++++++++++++++++------------- folly/detail/RangeCommon.cpp | 14 +- folly/detail/RangeCommon.h | 69 ++++-- folly/detail/RangeSse42.cpp | 102 ++++---- folly/detail/RangeSse42.h | 7 +- folly/test/RangeFindBenchmark.cpp | 14 +- folly/test/RangeTest.cpp | 286 +++++++++++----------- 7 files changed, 468 insertions(+), 405 deletions(-) diff --git a/folly/Range.h b/folly/Range.h index b6e428ea..3bfef1f2 100644 --- a/folly/Range.h +++ b/folly/Range.h @@ -50,8 +50,8 @@ #endif #include -#include #include +#include #include #include @@ -61,7 +61,8 @@ FOLLY_GCC_DISABLE_WARNING("-Wshadow") namespace folly { -template class Range; +template +class Range; /** * Finds the first occurrence of needle in haystack. The algorithm is on @@ -72,9 +73,8 @@ template class Range; template < class Iter, class Comp = std::equal_to::value_type>> -inline size_t qfind(const Range & haystack, - const Range & needle, - Comp eq = Comp()); +inline size_t +qfind(const Range& haystack, const Range& needle, Comp eq = Comp()); /** * Finds the first occurrence of needle in haystack. The result is the @@ -82,8 +82,9 @@ inline size_t qfind(const Range & haystack, * needle wasn't found. */ template -size_t qfind(const Range & haystack, - const typename Range::value_type& needle); +size_t qfind( + const Range& haystack, + const typename Range::value_type& needle); /** * Finds the last occurrence of needle in haystack. The result is the @@ -91,17 +92,18 @@ size_t qfind(const Range & haystack, * needle wasn't found. */ template -size_t rfind(const Range & haystack, - const typename Range::value_type& needle); - +size_t rfind( + const Range& haystack, + const typename Range::value_type& needle); /** * Finds the first occurrence of any element of needle in * haystack. The algorithm is O(haystack.size() * needle.size()). */ template -inline size_t qfind_first_of(const Range & haystack, - const Range & needle); +inline size_t qfind_first_of( + const Range& haystack, + const Range& needle); /** * Small internal helper - returns the value just before an iterator. @@ -113,9 +115,10 @@ namespace detail { */ template typename std::enable_if< - std::is_same::iterator_category, - std::random_access_iterator_tag>::value, - typename std::iterator_traits::reference>::type + std::is_same< + typename std::iterator_traits::iterator_category, + std::random_access_iterator_tag>::value, + typename std::iterator_traits::reference>::type value_before(Iter i) { return i[-1]; } @@ -125,9 +128,10 @@ value_before(Iter i) { */ template typename std::enable_if< - !std::is_same::iterator_category, - std::random_access_iterator_tag>::value, - typename std::iterator_traits::reference>::type + !std::is_same< + typename std::iterator_traits::iterator_category, + std::random_access_iterator_tag>::value, + typename std::iterator_traits::reference>::type value_before(Iter i) { return *--i; } @@ -136,7 +140,8 @@ value_before(Iter i) { * Use IsCharPointer::type to enable const char* or char*. * Use IsCharPointer::const_type to enable only const char*. */ -template struct IsCharPointer {}; +template +struct IsCharPointer {}; template <> struct IsCharPointer { @@ -163,14 +168,13 @@ struct IsCharPointer { * wouldn't.) */ template -class Range : private boost::totally_ordered > { +class Range : private boost::totally_ordered> { public: typedef std::size_t size_type; typedef Iter iterator; typedef Iter const_iterator; typedef typename std::remove_reference< - typename std::iterator_traits::reference>::type - value_type; + typename std::iterator_traits::reference>::type value_type; using difference_type = typename std::iterator_traits::difference_type; typedef typename std::iterator_traits::reference reference; @@ -181,35 +185,32 @@ class Range : private boost::totally_ordered > { * args which are const. */ typedef typename std::conditional< - std::is_same::value - || std::is_same::value, - Range, - Range>::type const_range_type; + std::is_same::value || + std::is_same::value, + Range, + Range>::type const_range_type; typedef std::char_traits::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: // 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 ::type = 0> constexpr /* implicit */ Range(Iter str) @@ -229,9 +230,10 @@ class Range : private boost::totally_ordered > { } template ::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"); } @@ -243,15 +245,12 @@ class Range : private boost::totally_ordered > { } } - 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 ::const_type = 0> /* implicit */ Range(const fbstring& str) - : b_(str.data()), e_(b_ + str.size()) { } + : b_(str.data()), e_(b_ + str.size()) {} template ::const_type = 0> Range(const fbstring& str, fbstring::size_type startFrom) { @@ -263,8 +262,10 @@ class Range : private boost::totally_ordered > { } template ::const_type = 0> - Range(const fbstring& str, fbstring::size_type startFrom, - fbstring::size_type size) { + Range( + const fbstring& str, + fbstring::size_type startFrom, + fbstring::size_type size) { if (UNLIKELY(startFrom > str.size())) { std::__throw_out_of_range("index out of range"); } @@ -280,60 +281,70 @@ class Range : private boost::totally_ordered > { // Range (aka ByteRange), as they're both frequently // used to represent ranges of bytes. Allow explicit conversion in the other // direction. - template ::value && - (std::is_same::value || - std::is_same::value)), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (std::is_same::value && + (std::is_same::value || + std::is_same::value)), + int>::type = 0> /* implicit */ Range(const Range& other) - : b_(reinterpret_cast(other.begin())), - e_(reinterpret_cast(other.end())) { - } + : b_(reinterpret_cast(other.begin())), + e_(reinterpret_cast(other.end())) {} - template ::value && - std::is_same::value), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (std::is_same::value && + std::is_same::value), + int>::type = 0> /* implicit */ Range(const Range& other) - : b_(reinterpret_cast(other.begin())), - e_(reinterpret_cast(other.end())) { - } + : b_(reinterpret_cast(other.begin())), + e_(reinterpret_cast(other.end())) {} - template ::value && - (std::is_same::value || - std::is_same::value)), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (std::is_same::value && + (std::is_same::value || + std::is_same::value)), + int>::type = 0> explicit Range(const Range& other) - : b_(reinterpret_cast(other.begin())), - e_(reinterpret_cast(other.end())) { - } + : b_(reinterpret_cast(other.begin())), + e_(reinterpret_cast(other.end())) {} - template ::value && - std::is_same::value), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (std::is_same::value && + std::is_same::value), + int>::type = 0> explicit Range(const Range& other) - : b_(reinterpret_cast(other.begin())), - e_(reinterpret_cast(other.end())) { - } + : b_(reinterpret_cast(other.begin())), + e_(reinterpret_cast(other.end())) {} // Allow implicit conversion from Range to Range if From is // implicitly convertible to To. - template ::value && - std::is_convertible::value), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (!std::is_same::value && + std::is_convertible::value), + int>::type = 0> constexpr /* implicit */ Range(const Range& other) - : b_(other.begin()), - e_(other.end()) { - } + : b_(other.begin()), e_(other.end()) {} // Allow explicit conversion from Range to Range if From is // explicitly convertible to To. - template ::value && - !std::is_convertible::value && - std::is_constructible::value), int>::type = 0> + template < + class OtherIter, + typename std::enable_if< + (!std::is_same::value && + !std::is_convertible::value && + std::is_constructible::value), + int>::type = 0> constexpr explicit Range(const Range& other) - : b_(other.begin()), - e_(other.end()) { - } + : b_(other.begin()), e_(other.end()) {} /** * Allow explicit construction of Range() from a std::array of a @@ -435,11 +446,19 @@ class Range : private boost::totally_ordered > { return detail::value_before(e_); } // Works only for Range and Range - std::string str() const { return std::string(b_, size()); } - std::string toString() const { return str(); } + std::string str() const { + return std::string(b_, size()); + } + std::string toString() const { + return str(); + } // Works only for Range and Range - fbstring fbstr() const { return fbstring(b_, size()); } - fbstring toFbstring() const { return fbstr(); } + fbstring fbstr() const { + return fbstring(b_, size()); + } + fbstring toFbstring() const { + return fbstr(); + } const_range_type castToConst() const { return const_range_type(*this); @@ -455,8 +474,9 @@ class Range : private boost::totally_ordered > { // 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( - (osize - tsize) >> (CHAR_BIT * sizeof(size_t) - 1)) << 1) - 1; + r = (static_cast((osize - tsize) >> (CHAR_BIT * sizeof(size_t) - 1)) + << 1) - + 1; } return r; } @@ -472,12 +492,16 @@ class Range : private boost::totally_ordered > { } 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]; } @@ -564,13 +588,17 @@ class Range : private boost::totally_ordered > { } 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)); @@ -584,7 +612,9 @@ class Range : private boost::totally_ordered > { // 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; } @@ -598,7 +628,9 @@ class Range : private boost::totally_ordered > { } 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; } @@ -608,7 +640,9 @@ class Range : private boost::totally_ordered > { } 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; } @@ -657,8 +691,8 @@ class Range : private boost::totally_ordered > { * 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; @@ -678,8 +712,8 @@ class Range : private boost::totally_ordered > { * 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; @@ -915,14 +949,16 @@ class Range : private boost::totally_ordered > { * @author: Marcelo Juchem */ template - auto split_step(value_type delimiter, TProcess &&process, Args &&...args) - -> decltype(process(std::declval(), std::forward(args)...)) - { return process(split_step(delimiter), std::forward(args)...); } + auto split_step(value_type delimiter, TProcess&& process, Args&&... args) + -> decltype(process(std::declval(), std::forward(args)...)) { + return process(split_step(delimiter), std::forward(args)...); + } template - auto split_step(Range delimiter, TProcess &&process, Args &&...args) - -> decltype(process(std::declval(), std::forward(args)...)) - { return process(split_step(delimiter), std::forward(args)...); } + auto split_step(Range delimiter, TProcess&& process, Args&&... args) + -> decltype(process(std::declval(), std::forward(args)...)) { + return process(split_step(delimiter), std::forward(args)...); + } private: Iter b_, e_; @@ -1010,12 +1046,10 @@ namespace detail { template struct ComparableAsStringPiece { enum { - value = - (std::is_convertible::value - && std::is_same::value) - || - (std::is_convertible::value - && std::is_same::value) + value = (std::is_convertible::value && + std::is_same::value) || + (std::is_convertible::value && + std::is_same::value) }; }; @@ -1025,8 +1059,7 @@ struct ComparableAsStringPiece { * operator== through conversion for Range */ template -typename -std::enable_if::value, bool>::type +_t::value, bool>> operator==(const T& lhs, const U& rhs) { return StringPiece(lhs) == StringPiece(rhs); } @@ -1035,8 +1068,7 @@ operator==(const T& lhs, const U& rhs) { * operator< through conversion for Range */ template -typename -std::enable_if::value, bool>::type +_t::value, bool>> operator<(const T& lhs, const U& rhs) { return StringPiece(lhs) < StringPiece(rhs); } @@ -1045,8 +1077,7 @@ operator<(const T& lhs, const U& rhs) { * operator> through conversion for Range */ template -typename -std::enable_if::value, bool>::type +_t::value, bool>> operator>(const T& lhs, const U& rhs) { return StringPiece(lhs) > StringPiece(rhs); } @@ -1055,8 +1086,7 @@ operator>(const T& lhs, const U& rhs) { * operator< through conversion for Range */ template -typename -std::enable_if::value, bool>::type +_t::value, bool>> operator<=(const T& lhs, const U& rhs) { return StringPiece(lhs) <= StringPiece(rhs); } @@ -1065,8 +1095,7 @@ operator<=(const T& lhs, const U& rhs) { * operator> through conversion for Range */ template -typename -std::enable_if::value, bool>::type +_t::value, bool>> operator>=(const T& lhs, const U& rhs) { return StringPiece(lhs) >= StringPiece(rhs); } @@ -1075,16 +1104,16 @@ operator>=(const T& lhs, const U& rhs) { * Finds substrings faster than brute force by borrowing from Boyer-Moore */ template -size_t qfind(const Range& haystack, - const Range& needle, - Comp eq) { +size_t qfind(const Range& haystack, const Range& 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]; @@ -1106,7 +1135,7 @@ size_t qfind(const Range& 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 @@ -1132,23 +1161,24 @@ size_t qfind(const Range& 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 -size_t qfind_first_of(const Range & haystack, - const Range & 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& haystack, + const Range& 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(); } @@ -1166,24 +1196,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 -size_t qfind(const Range& haystack, - const typename Range::value_type& needle) { +size_t qfind( + const Range& haystack, + const typename Range::value_type& needle) { auto pos = std::find(haystack.begin(), haystack.end(), needle); return pos == haystack.end() ? std::string::npos : pos - haystack.data(); } template -size_t rfind(const Range& haystack, - const typename Range::value_type& needle) { - for (auto i = haystack.size(); i-- > 0; ) { +size_t rfind( + const Range& haystack, + const typename Range::value_type& needle) { + for (auto i = haystack.size(); i-- > 0;) { if (haystack[i] == needle) { return i; } @@ -1199,7 +1235,7 @@ inline size_t qfind(const Range& haystack, const char& needle) { return std::string::npos; } auto pos = static_cast( - ::memchr(haystack.data(), needle, haystack.size())); + ::memchr(haystack.data(), needle, haystack.size())); return pos == nullptr ? std::string::npos : pos - haystack.data(); } @@ -1210,62 +1246,66 @@ inline size_t rfind(const Range& haystack, const char& needle) { return std::string::npos; } auto pos = static_cast( - ::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& haystack, - const unsigned char& needle) { +inline size_t qfind( + const Range& 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( - ::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& haystack, - const unsigned char& needle) { +inline size_t rfind( + const Range& 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( - ::memrchr(haystack.data(), needle, haystack.size())); + ::memrchr(haystack.data(), needle, haystack.size())); return pos == nullptr ? std::string::npos : pos - haystack.data(); } template -size_t qfind_first_of(const Range& haystack, - const Range& needles) { +size_t qfind_first_of(const Range& haystack, const Range& needles) { return qfind_first_of(haystack, needles, AsciiCaseSensitive()); } // specialization for StringPiece template <> -inline size_t qfind_first_of(const Range& haystack, - const Range& needles) { +inline size_t qfind_first_of( + const Range& haystack, + const Range& needles) { return detail::qfind_first_byte_of(haystack, needles); } // specialization for ByteRange template <> -inline size_t qfind_first_of(const Range& haystack, - const Range& needles) { - return detail::qfind_first_byte_of(StringPiece(haystack), - StringPiece(needles)); +inline size_t qfind_first_of( + const Range& haystack, + const Range& needles) { + return detail::qfind_first_byte_of( + StringPiece(haystack), StringPiece(needles)); } template struct hasher; template -struct hasher, - typename std::enable_if::value, void>::type> { +struct hasher< + folly::Range, + typename std::enable_if::value, void>::type> { size_t operator()(folly::Range r) const { return hash::SpookyHashV2::Hash64(r.begin(), r.size() * sizeof(T), 0); } @@ -1274,12 +1314,15 @@ struct hasher, /** * Ubiquitous helper template for knowing what's a string */ -template struct IsSomeString { - enum { value = std::is_same::value - || std::is_same::value }; +template +struct IsSomeString { + enum { + value = + std::is_same::value || std::is_same::value + }; }; -} // !namespace folly +} // namespace folly FOLLY_POP_WARNING diff --git a/folly/detail/RangeCommon.cpp b/folly/detail/RangeCommon.cpp index fa78f283..badf9bde 100644 --- a/folly/detail/RangeCommon.cpp +++ b/folly/detail/RangeCommon.cpp @@ -24,8 +24,9 @@ namespace folly { namespace detail { -size_t qfind_first_byte_of_bitset(const StringPieceLite haystack, - const StringPieceLite needles) { +size_t qfind_first_byte_of_bitset( + const StringPieceLite haystack, + const StringPieceLite needles) { std::bitset<256> s; for (auto needle : needles) { s[(uint8_t)needle] = true; @@ -38,10 +39,11 @@ size_t qfind_first_byte_of_bitset(const StringPieceLite haystack, return std::string::npos; } -size_t qfind_first_byte_of_byteset(const StringPieceLite haystack, - const StringPieceLite needles) { +size_t qfind_first_byte_of_byteset( + const StringPieceLite haystack, + const StringPieceLite needles) { SparseByteSet s; - for (auto needle: needles) { + for (auto needle : needles) { s.add(uint8_t(needle)); } for (size_t index = 0; index < haystack.size(); ++index) { @@ -51,7 +53,5 @@ size_t qfind_first_byte_of_byteset(const StringPieceLite haystack, } return std::string::npos; } - } - } diff --git a/folly/detail/RangeCommon.h b/folly/detail/RangeCommon.h index ce5325eb..ca8cc833 100644 --- a/folly/detail/RangeCommon.h +++ b/folly/detail/RangeCommon.h @@ -38,38 +38,60 @@ class StringPieceLite { public: StringPieceLite(const char* b, const char* e) : b_(b), e_(e) {} template - /* implicit */ StringPieceLite(const Range& r) : - StringPieceLite(r.data(), r.data() + r.size()) {} - const char* data() const { return b_; } - const char* begin() const { return b_; } - const char* end() const { return e_; } - size_t size() const { return size_t(e_ - b_); } - bool empty() const { return size() == 0; } - const char& operator[](size_t i) const { DCHECK_GT(size(), i); return b_[i]; } + /* implicit */ StringPieceLite(const Range& r) + : StringPieceLite(r.data(), r.data() + r.size()) {} + const char* data() const { + return b_; + } + const char* begin() const { + return b_; + } + const char* end() const { + return e_; + } + size_t size() const { + return size_t(e_ - b_); + } + bool empty() const { + return size() == 0; + } + const char& operator[](size_t i) const { + DCHECK_GT(size(), i); + return b_[i]; + } template - explicit operator Range() const { return Range(begin(), end()); } + explicit operator Range() const { + return Range(begin(), end()); + } + private: const char* b_; const char* e_; }; -inline size_t qfind_first_byte_of_std(const StringPieceLite haystack, - const StringPieceLite needles) { - auto ret = std::find_first_of(haystack.begin(), haystack.end(), - needles.begin(), needles.end(), - [](char a, char b) { return a == b; }); +inline size_t qfind_first_byte_of_std( + const StringPieceLite haystack, + const StringPieceLite needles) { + auto ret = std::find_first_of( + haystack.begin(), + haystack.end(), + needles.begin(), + needles.end(), + [](char a, char b) { return a == b; }); return ret == haystack.end() ? std::string::npos : ret - haystack.begin(); } +size_t qfind_first_byte_of_bitset( + const StringPieceLite haystack, + const StringPieceLite needles); -size_t qfind_first_byte_of_bitset(const StringPieceLite haystack, - const StringPieceLite needles); - -size_t qfind_first_byte_of_byteset(const StringPieceLite haystack, - const StringPieceLite needles); +size_t qfind_first_byte_of_byteset( + const StringPieceLite haystack, + const StringPieceLite needles); -inline size_t qfind_first_byte_of_nosse(const StringPieceLite haystack, - const StringPieceLite needles) { +inline size_t qfind_first_byte_of_nosse( + const StringPieceLite haystack, + const StringPieceLite needles) { if (UNLIKELY(needles.empty() || haystack.empty())) { return std::string::npos; } @@ -77,13 +99,10 @@ inline size_t qfind_first_byte_of_nosse(const StringPieceLite haystack, // This is not an exact science since it depends on the CPU, the size of // needles, and the size of haystack. if ((needles.size() >= 4 && haystack.size() <= 10) || - (needles.size() >= 16 && haystack.size() <= 64) || - needles.size() >= 32) { + (needles.size() >= 16 && haystack.size() <= 64) || needles.size() >= 32) { return qfind_first_byte_of_byteset(haystack, needles); } return qfind_first_byte_of_std(haystack, needles); } - } - } diff --git a/folly/detail/RangeSse42.cpp b/folly/detail/RangeSse42.cpp index 84dcfb85..651949fb 100644 --- a/folly/detail/RangeSse42.cpp +++ b/folly/detail/RangeSse42.cpp @@ -28,13 +28,14 @@ #if !FOLLY_SSE_PREREQ(4, 2) namespace folly { namespace detail { -size_t qfind_first_byte_of_sse42(const StringPieceLite haystack, - const StringPieceLite needles) { +size_t qfind_first_byte_of_sse42( + const StringPieceLite haystack, + const StringPieceLite needles) { return qfind_first_byte_of_nosse(haystack, needles); } } } -# else +#else #include #include #include @@ -49,15 +50,14 @@ size_t qfind_first_byte_of_sse42(const StringPieceLite haystack, // a function with always_inline fails to build. The _mm_* functions are marked // always_inline. // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368 -#if defined FOLLY_SANITIZE_ADDRESS && \ - FOLLY_SANITIZE_ADDRESS == 1 && \ +#if defined FOLLY_SANITIZE_ADDRESS && FOLLY_SANITIZE_ADDRESS == 1 && \ __GNUC_PREREQ(4, 9) -# define _mm_load_si128(p) (*(p)) -# define _mm_loadu_si128(p) ((__m128i)__builtin_ia32_loaddqu((const char*)(p))) -# ifdef _mm_cmpestri -# undef _mm_cmpestri -# endif -# define _mm_cmpestri(a, b, c, d, e) \ +#define _mm_load_si128(p) (*(p)) +#define _mm_loadu_si128(p) ((__m128i)__builtin_ia32_loaddqu((const char*)(p))) +#ifdef _mm_cmpestri +#undef _mm_cmpestri +#endif +#define _mm_cmpestri(a, b, c, d, e) \ __builtin_ia32_pcmpestri128((__v16qi)(a), b, (__v16qi)(c), d, e) #endif @@ -67,8 +67,9 @@ namespace detail { // It's okay if pages are bigger than this (as powers of two), but they should // not be smaller. static constexpr size_t kMinPageSize = 4096; -static_assert(kMinPageSize >= 16, - "kMinPageSize must be at least SSE register size"); +static_assert( + kMinPageSize >= 16, + "kMinPageSize must be at least SSE register size"); template static inline uintptr_t page_for(T* addr) { @@ -76,19 +77,20 @@ static inline uintptr_t page_for(T* addr) { } static inline size_t nextAlignedIndex(const char* arr) { - auto firstPossible = reinterpret_cast(arr) + 1; - return 1 + // add 1 because the index starts at 'arr' - ((firstPossible + 15) & ~0xF) // round up to next multiple of 16 - - firstPossible; + auto firstPossible = reinterpret_cast(arr) + 1; + return 1 + // add 1 because the index starts at 'arr' + ((firstPossible + 15) & ~0xF) // round up to next multiple of 16 + - firstPossible; } -static size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, - const StringPieceLite needles) - FOLLY_DISABLE_ADDRESS_SANITIZER; +static size_t qfind_first_byte_of_needles16( + const StringPieceLite haystack, + const StringPieceLite needles) FOLLY_DISABLE_ADDRESS_SANITIZER; // helper method for case where needles.size() <= 16 -size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, - const StringPieceLite needles) { +size_t qfind_first_byte_of_needles16( + const StringPieceLite haystack, + const StringPieceLite needles) { DCHECK_GT(haystack.size(), 0u); DCHECK_GT(needles.size(), 0u); DCHECK_LE(needles.size(), 16u); @@ -101,11 +103,10 @@ size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, return detail::qfind_first_byte_of_nosse(haystack, needles); } - auto arr2 = _mm_loadu_si128( - reinterpret_cast(needles.data())); + auto arr2 = _mm_loadu_si128(reinterpret_cast(needles.data())); // do an unaligned load for first block of haystack - auto arr1 = _mm_loadu_si128( - reinterpret_cast(haystack.data())); + auto arr1 = + _mm_loadu_si128(reinterpret_cast(haystack.data())); auto index = _mm_cmpestri(arr2, int(needles.size()), arr1, int(haystack.size()), 0); if (index < 16) { @@ -114,7 +115,7 @@ size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, // Now, we can do aligned loads hereafter... size_t i = nextAlignedIndex(haystack.data()); - for (; i < haystack.size(); i+= 16) { + for (; i < haystack.size(); i += 16) { arr1 = _mm_load_si128(reinterpret_cast(haystack.data() + i)); index = _mm_cmpestri( @@ -127,27 +128,30 @@ size_t qfind_first_byte_of_needles16(const StringPieceLite haystack, } template -size_t scanHaystackBlock(const StringPieceLite haystack, - const StringPieceLite needles, - uint64_t idx) -// Turn off ASAN because the "arr2 = ..." assignment in the loop below reads -// up to 15 bytes beyond end of the buffer in #needles#. That is ok because -// ptr2 is always 16-byte aligned, so the read can never span a page boundary. -// Also, the extra data that may be read is never actually used. - FOLLY_DISABLE_ADDRESS_SANITIZER; +size_t scanHaystackBlock( + const StringPieceLite haystack, + const StringPieceLite needles, + uint64_t idx) + // Turn off ASAN because the "arr2 = ..." assignment in the loop below reads + // up to 15 bytes beyond end of the buffer in #needles#. That is ok because + // ptr2 is always 16-byte aligned, so the read can never span a page + // boundary. Also, the extra data that may be read is never actually used. + FOLLY_DISABLE_ADDRESS_SANITIZER; // Scans a 16-byte block of haystack (starting at blockStartIdx) to find first // needle. If HAYSTACK_ALIGNED, then haystack must be 16byte aligned. // If !HAYSTACK_ALIGNED, then caller must ensure that it is safe to load the // block. template -size_t scanHaystackBlock(const StringPieceLite haystack, - const StringPieceLite needles, - uint64_t blockStartIdx) { +size_t scanHaystackBlock( + const StringPieceLite haystack, + const StringPieceLite needles, + uint64_t blockStartIdx) { DCHECK_GT(needles.size(), 16u); // should handled by *needles16() method - DCHECK(blockStartIdx + 16 <= haystack.size() || - (page_for(haystack.data() + blockStartIdx) == - page_for(haystack.data() + blockStartIdx + 15))); + DCHECK( + blockStartIdx + 16 <= haystack.size() || + (page_for(haystack.data() + blockStartIdx) == + page_for(haystack.data() + blockStartIdx + 15))); __m128i arr1; if (HAYSTACK_ALIGNED) { @@ -159,15 +163,13 @@ size_t scanHaystackBlock(const StringPieceLite haystack, } // This load is safe because needles.size() >= 16 - auto arr2 = _mm_loadu_si128( - reinterpret_cast(needles.data())); + auto arr2 = _mm_loadu_si128(reinterpret_cast(needles.data())); auto b = _mm_cmpestri(arr2, 16, arr1, int(haystack.size() - blockStartIdx), 0); size_t j = nextAlignedIndex(needles.data()); for (; j < needles.size(); j += 16) { - arr2 = _mm_load_si128( - reinterpret_cast(needles.data() + j)); + arr2 = _mm_load_si128(reinterpret_cast(needles.data() + j)); auto index = _mm_cmpestri( arr2, @@ -184,11 +186,13 @@ size_t scanHaystackBlock(const StringPieceLite haystack, return std::string::npos; } -size_t qfind_first_byte_of_sse42(const StringPieceLite haystack, - const StringPieceLite needles); +size_t qfind_first_byte_of_sse42( + const StringPieceLite haystack, + const StringPieceLite needles); -size_t qfind_first_byte_of_sse42(const StringPieceLite haystack, - const StringPieceLite needles) { +size_t qfind_first_byte_of_sse42( + const StringPieceLite haystack, + const StringPieceLite needles) { if (UNLIKELY(needles.empty() || haystack.empty())) { return std::string::npos; } else if (needles.size() <= 16) { diff --git a/folly/detail/RangeSse42.h b/folly/detail/RangeSse42.h index 1b74cfd3..8e89d0f0 100644 --- a/folly/detail/RangeSse42.h +++ b/folly/detail/RangeSse42.h @@ -24,9 +24,8 @@ namespace folly { namespace detail { -size_t qfind_first_byte_of_sse42(const StringPieceLite haystack, - const StringPieceLite needles); - +size_t qfind_first_byte_of_sse42( + const StringPieceLite haystack, + const StringPieceLite needles); } - } diff --git a/folly/test/RangeFindBenchmark.cpp b/folly/test/RangeFindBenchmark.cpp index 228b3b13..786553b2 100644 --- a/folly/test/RangeFindBenchmark.cpp +++ b/folly/test/RangeFindBenchmark.cpp @@ -80,9 +80,8 @@ void initFile(int len) { } } - string generateString(int len) { - std::uniform_int_distribution validChar(1, 255); // no null-char + std::uniform_int_distribution validChar(1, 255); // no null-char string ret; while (len--) { ret.push_back(validChar(rnd)); @@ -93,7 +92,7 @@ string generateString(int len) { void initDelims(int len) { ffoDelim.clear(); - string s(len - 1, '\0'); // find_first_of won't finish until last char + string s(len - 1, '\0'); // find_first_of won't finish until last char s.push_back('a'); ffoTestString = s; @@ -107,7 +106,7 @@ void initDelims(int len) { auto s = generateString(n); if (rnd() % 2) { // ~half of tests will find a hit - s[rnd() % s.size()] = 'a'; // yes, this could mean 'a' is a duplicate + s[rnd() % s.size()] = 'a'; // yes, this could mean 'a' is a duplicate } ffoDelim.push_back(s); } @@ -305,8 +304,9 @@ BENCHMARK_RELATIVE(FindFirstOf32NeedlesBitSet, n) { BENCHMARK_DRAW_LINE(); -const string delims64 = "!bcdefghijklmnopqrstuvwxyz_" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789$"; +const string delims64 = + "!bcdefghijklmnopqrstuvwxyz_" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789$"; BENCHMARK(FindFirstOf64NeedlesBase, n) { findFirstOfRange(delims64, detail::qfind_first_byte_of, n); @@ -400,7 +400,7 @@ BENCHMARK_DRAW_LINE(); int main(int argc, char** argv) { gflags::ParseCommandLineFlags(&argc, &argv, true); - for (int len : {1, 8, 10, 16, 32, 64, 128, 256, 10*1024, 1024*1024}) { + for (int len : {1, 8, 10, 16, 32, 64, 128, 256, 10 * 1024, 1024 * 1024}) { initStr(len); initDelims(len); initFile(len); diff --git a/folly/test/RangeTest.cpp b/folly/test/RangeTest.cpp index d9658a70..3538969c 100644 --- a/folly/test/RangeTest.cpp +++ b/folly/test/RangeTest.cpp @@ -50,8 +50,8 @@ TEST(StringPiece, All) { // we expect the compiler to optimize things so that there's only one copy // of the string literal "foo", even though we've got it in multiple places - EXPECT_EQ(foo, foo2); // remember, this uses ==, not strcmp, so it's a ptr - // comparison rather than lexical + EXPECT_EQ(foo, foo2); // remember, this uses ==, not strcmp, so it's a ptr + // comparison rather than lexical // the string object creates copies though, so the c_str of these should be // distinct @@ -61,17 +61,17 @@ TEST(StringPiece, All) { StringPiece s(foo); EXPECT_EQ(s.size(), 3); - EXPECT_EQ(s.start(), foo); // ptr comparison - EXPECT_NE(s.start(), fooStr.c_str()); // ptr comparison - EXPECT_NE(s.start(), foo2Str.c_str()); // ptr comparison + EXPECT_EQ(s.start(), foo); // ptr comparison + EXPECT_NE(s.start(), fooStr.c_str()); // ptr comparison + EXPECT_NE(s.start(), foo2Str.c_str()); // ptr comparison - EXPECT_EQ(s.toString(), foo); // lexical comparison - EXPECT_EQ(s.toString(), fooStr.c_str()); // lexical comparison - EXPECT_EQ(s.toString(), foo2Str.c_str()); // lexical comparison + EXPECT_EQ(s.toString(), foo); // lexical comparison + EXPECT_EQ(s.toString(), fooStr.c_str()); // lexical comparison + EXPECT_EQ(s.toString(), foo2Str.c_str()); // lexical comparison - EXPECT_EQ(s, foo); // lexical comparison - EXPECT_EQ(s, fooStr); // lexical comparison - EXPECT_EQ(s, foo2Str); // lexical comparison + EXPECT_EQ(s, foo); // lexical comparison + EXPECT_EQ(s, fooStr); // lexical comparison + EXPECT_EQ(s, foo2Str); // lexical comparison EXPECT_EQ(foo, s); // check using StringPiece to reference substrings @@ -96,7 +96,7 @@ TEST(StringPiece, All) { EXPECT_EQ(s.find("ba", 4), 6); EXPECT_EQ(s.find("notfound"), StringPiece::npos); EXPECT_EQ(s.find("notfound", 1), StringPiece::npos); - EXPECT_EQ(s.find("bar", 4), StringPiece::npos); // starting position too far + EXPECT_EQ(s.find("bar", 4), StringPiece::npos); // starting position too far // starting pos that is obviously past the end -- This works for std::string EXPECT_EQ(s.toString().find("notfound", 55), StringPiece::npos); EXPECT_EQ(s.find("z", s.size()), StringPiece::npos); @@ -112,7 +112,7 @@ TEST(StringPiece, All) { EXPECT_EQ(s.find('o', 2), 2); EXPECT_EQ(s.find('y'), StringPiece::npos); EXPECT_EQ(s.find('y', 1), StringPiece::npos); - EXPECT_EQ(s.find('o', 4), StringPiece::npos); // starting position too far + EXPECT_EQ(s.find('o', 4), StringPiece::npos); // starting position too far EXPECT_TRUE(s.contains('z')); // starting pos that is obviously past the end -- This works for std::string EXPECT_EQ(s.toString().find('y', 55), StringPiece::npos); @@ -265,10 +265,10 @@ TEST(StringPiece, EightBitComparisons) { TEST(StringPiece, ToByteRange) { StringPiece a("hello"); ByteRange b(a); - EXPECT_EQ(static_cast(a.begin()), - static_cast(b.begin())); - EXPECT_EQ(static_cast(a.end()), - static_cast(b.end())); + EXPECT_EQ( + static_cast(a.begin()), static_cast(b.begin())); + EXPECT_EQ( + static_cast(a.end()), static_cast(b.end())); // and convert back again StringPiece c(b); @@ -625,72 +625,72 @@ TEST(StringPiece, split_step_with_process_char_delimiter) { EXPECT_EQ(s, p); EXPECT_EQ(1, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 5), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("this", x); - return 1; - }))); + EXPECT_EQ(std::next(s, 5), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("this", x); + return 1; + }))); EXPECT_EQ(2, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 8), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("is", x); - return 2; - }))); + EXPECT_EQ(std::next(s, 8), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("is", x); + return 2; + }))); EXPECT_EQ(3, (p.split_step('u', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 10), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("j", x); - return 3; - }))); + EXPECT_EQ(std::next(s, 10), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("j", x); + return 3; + }))); EXPECT_EQ(4, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 13), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("st", x); - return 4; - }))); + EXPECT_EQ(std::next(s, 13), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("st", x); + return 4; + }))); EXPECT_EQ(5, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 14), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("", x); - return 5; - }))); + EXPECT_EQ(std::next(s, 14), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("", x); + return 5; + }))); EXPECT_EQ(6, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 16), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("a", x); - return 6; - }))); + EXPECT_EQ(std::next(s, 16), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("a", x); + return 6; + }))); EXPECT_EQ(7, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 21), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("test", x); - return 7; - }))); + EXPECT_EQ(std::next(s, 21), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("test", x); + return 7; + }))); EXPECT_EQ(8, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(e, p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("string", x); - return 8; - }))); + EXPECT_EQ(e, p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("string", x); + return 8; + }))); EXPECT_EQ(9, (p.split_step(' ', [&](folly::StringPiece x) { - EXPECT_EQ(e, p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("", x); - return 9; - }))); + EXPECT_EQ(e, p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("", x); + return 9; + }))); - EXPECT_TRUE((std::is_same< - void, - decltype(p.split_step(' ', split_step_with_process_noop)) - >::value)); + EXPECT_TRUE( + (std::is_same< + void, + decltype(p.split_step(' ', split_step_with_process_noop))>::value)); EXPECT_NO_THROW(p.split_step(' ', split_step_with_process_noop)); } @@ -708,79 +708,79 @@ TEST(StringPiece, split_step_with_process_range_delimiter) { EXPECT_EQ(s, p); EXPECT_EQ(1, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 6), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("this", x); - return 1; - }))); + EXPECT_EQ(std::next(s, 6), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("this", x); + return 1; + }))); EXPECT_EQ(2, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 10), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("is", x); - return 2; - }))); + EXPECT_EQ(std::next(s, 10), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("is", x); + return 2; + }))); EXPECT_EQ(3, (p.split_step("u", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 12), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("j", x); - return 3; - }))); + EXPECT_EQ(std::next(s, 12), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("j", x); + return 3; + }))); EXPECT_EQ(4, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 16), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("st", x); - return 4; - }))); + EXPECT_EQ(std::next(s, 16), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("st", x); + return 4; + }))); EXPECT_EQ(5, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 18), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("", x); - return 5; - }))); + EXPECT_EQ(std::next(s, 18), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("", x); + return 5; + }))); EXPECT_EQ(6, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 21), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("a", x); - return 6; - }))); + EXPECT_EQ(std::next(s, 21), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("a", x); + return 6; + }))); EXPECT_EQ(7, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(std::next(s, 28), p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ(" test", x); - return 7; - }))); + EXPECT_EQ(std::next(s, 28), p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ(" test", x); + return 7; + }))); EXPECT_EQ(8, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(e, p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("string", x); - return 8; - }))); + EXPECT_EQ(e, p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("string", x); + return 8; + }))); EXPECT_EQ(9, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(e, p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("", x); - return 9; - }))); + EXPECT_EQ(e, p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("", x); + return 9; + }))); EXPECT_EQ(10, (p.split_step(" ", [&](folly::StringPiece x) { - EXPECT_EQ(e, p.begin()); - EXPECT_EQ(e, p.end()); - EXPECT_EQ("", x); - return 10; - }))); + EXPECT_EQ(e, p.begin()); + EXPECT_EQ(e, p.end()); + EXPECT_EQ("", x); + return 10; + }))); - EXPECT_TRUE((std::is_same< - void, - decltype(p.split_step(' ', split_step_with_process_noop)) - >::value)); + EXPECT_TRUE( + (std::is_same< + void, + decltype(p.split_step(' ', split_step_with_process_noop))>::value)); EXPECT_NO_THROW(p.split_step(' ', split_step_with_process_noop)); } @@ -798,10 +798,7 @@ TEST(StringPiece, split_step_with_process_char_delimiter_additional_args) { EXPECT_EQ(e, p.end()); EXPECT_EQ(s, p); - auto const functor = []( - folly::StringPiece s, - folly::StringPiece expected - ) { + auto const functor = [](folly::StringPiece s, folly::StringPiece expected) { EXPECT_EQ(expected, s); return expected; }; @@ -836,10 +833,7 @@ TEST(StringPiece, split_step_with_process_range_delimiter_additional_args) { EXPECT_EQ(e, p.end()); EXPECT_EQ(s, p); - auto const functor = []( - folly::StringPiece s, - folly::StringPiece expected - ) { + auto const functor = [](folly::StringPiece s, folly::StringPiece expected) { EXPECT_EQ(expected, s); return expected; }; @@ -863,8 +857,12 @@ TEST(StringPiece, split_step_with_process_range_delimiter_additional_args) { TEST(StringPiece, NoInvalidImplicitConversions) { struct IsString { - bool operator()(folly::Range) { return false; } - bool operator()(folly::StringPiece) { return true; } + bool operator()(folly::Range) { + return false; + } + bool operator()(folly::StringPiece) { + return true; + } }; std::string s = "hello"; @@ -912,9 +910,8 @@ struct ByteSetNeedleFinder { } }; -typedef ::testing::Types NeedleFinders; +using NeedleFinders = + ::testing::Types; TYPED_TEST_CASE(NeedleFinderTest, NeedleFinders); TYPED_TEST(NeedleFinderTest, Null) { @@ -1047,13 +1044,13 @@ TYPED_TEST(NeedleFinderTest, NoSegFault) { // string(s1.data(), s1.size()).c_str(), s1.size(), // string(s2.data(), s2.size()).c_str(), s2.size()); auto r1 = this->find_first_byte_of(s1, s2); - auto f1 = std::find_first_of(s1.begin(), s1.end(), - s2.begin(), s2.end()); + auto f1 = + std::find_first_of(s1.begin(), s1.end(), s2.begin(), s2.end()); auto e1 = (f1 == s1.end()) ? StringPiece::npos : f1 - s1.begin(); EXPECT_EQ(r1, e1); auto r2 = this->find_first_byte_of(s2, s1); - auto f2 = std::find_first_of(s2.begin(), s2.end(), - s1.begin(), s1.end()); + auto f2 = + std::find_first_of(s2.begin(), s2.end(), s1.begin(), s1.end()); auto e2 = (f2 == s2.end()) ? StringPiece::npos : f2 - s2.begin(); EXPECT_EQ(r2, e2); freeProtectedBuf(buf1); @@ -1121,7 +1118,7 @@ TEST(RangeFunc, Array) { } TEST(RangeFunc, CArray) { - int x[] {1, 2, 3, 4}; + int x[]{1, 2, 3, 4}; testRangeFunc(x, 4); } @@ -1181,9 +1178,10 @@ TEST(RangeFunc, ConstexprCollection) { EXPECT_EQ(2, numCollRangeSize); } -std::string get_rand_str(size_t size, - std::uniform_int_distribution<>& dist, - std::mt19937& gen) { +std::string get_rand_str( + size_t size, + std::uniform_int_distribution<>& dist, + std::mt19937& gen) { std::string ret(size, '\0'); for (size_t i = 0; i < size; ++i) { ret[i] = static_cast(dist(gen)); @@ -1210,7 +1208,7 @@ TEST(ReplaceAt, exhaustiveTest) { std::mt19937 gen(rd()); std::uniform_int_distribution<> dist('a', 'z'); - for (int i=0; i < 100; ++i) { + for (int i = 0; i < 100; ++i) { for (size_t j = 1; j <= msp.size(); ++j) { auto replacement = get_rand_str(j, dist, gen); for (size_t pos = 0; pos < msp.size() - j; ++pos) { @@ -1266,7 +1264,7 @@ TEST(ReplaceAll, randomTest) { std::mt19937 gen(rd()); std::uniform_int_distribution<> dist('A', 'Z'); - for (int i=0; i < 100; ++i) { + for (int i = 0; i < 100; ++i) { for (size_t j = 1; j <= orig.size(); ++j) { auto replacement = get_rand_str(j, dist, gen); for (size_t pos = 0; pos < msp.size() - j; ++pos) { @@ -1285,7 +1283,7 @@ TEST(ReplaceAll, BadArg) { auto fst = "longer"; auto snd = "small"; char input[] = "meh meh meh"; - auto all = MutableStringPiece(input); + auto all = MutableStringPiece(input); try { all.replaceAll(fst, snd); -- 2.34.1