Skip to content

F
folly
Commit 5a122efc authored by Phil Willoughby's avatar Phil Willoughby Committed by Facebook Github Bot
Browse files
Options

Improve string comparisons 

Summary:
Any pair of read-compatible (same type, same traits) basic_strings (`basic_fbstring` or `std::basic_string`) can now be compared to each other with the `==`, `!=`, `<`, `>`, `<=`, and `>=` operators.

If you have a C++14 environment this allows you to use the heterogeneous comparison lookup methods from N3657: you can query containers which store either string type with either string type efficiently.

Reviewed By: yfeldblum, ot

Differential Revision: D4905697

fbshipit-source-id: 2ea976ebf40af45d64c1d8c1c08847feb3b9db68
parent 14c1d806
Hide whitespace changes
Inline Side-by-side
Showing with 279 additions and 16 deletions
folly/FBString.h
View file @ 5a122efc
......@@ -2725,34 +2725,90 @@ constexpr typename basic_fbstring<E1, T, A, S>::size_type
#ifndef _LIBSTDCXX_FBSTRING
// basic_string compatibility routines
template <typename E, class T, class A, class S>
inline
bool operator==(const basic_fbstring<E, T, A, S>& lhs,
const std::string& rhs) {
template <typename E, class T, class A, class S, class A2>
inline bool operator==(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return lhs.compare(0, lhs.size(), rhs.data(), rhs.size()) == 0;
}
template <typename E, class T, class A, class S>
inline
bool operator==(const std::string& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
template <typename E, class T, class A, class S, class A2>
inline bool operator==(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return rhs == lhs;
}
template <typename E, class T, class A, class S>
inline
bool operator!=(const basic_fbstring<E, T, A, S>& lhs,
const std::string& rhs) {
template <typename E, class T, class A, class S, class A2>
inline bool operator!=(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return !(lhs == rhs);
}
template <typename E, class T, class A, class S>
inline
bool operator!=(const std::string& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
template <typename E, class T, class A, class S, class A2>
inline bool operator!=(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return !(lhs == rhs);
}
template <typename E, class T, class A, class S, class A2>
inline bool operator<(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return lhs.compare(0, lhs.size(), rhs.data(), rhs.size()) < 0;
}
template <typename E, class T, class A, class S, class A2>
inline bool operator>(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return lhs.compare(0, lhs.size(), rhs.data(), rhs.size()) > 0;
}
template <typename E, class T, class A, class S, class A2>
inline bool operator<(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return rhs > lhs;
}
template <typename E, class T, class A, class S, class A2>
inline bool operator>(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return rhs < lhs;
}
template <typename E, class T, class A, class S, class A2>
inline bool operator<=(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return !(lhs > rhs);
}
template <typename E, class T, class A, class S, class A2>
inline bool operator>=(
const basic_fbstring<E, T, A, S>& lhs,
const std::basic_string<E, T, A2>& rhs) {
return !(lhs < rhs);
}
template <typename E, class T, class A, class S, class A2>
inline bool operator<=(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return !(lhs > rhs);
}
template <typename E, class T, class A, class S, class A2>
inline bool operator>=(
const std::basic_string<E, T, A2>& lhs,
const basic_fbstring<E, T, A, S>& rhs) {
return !(lhs < rhs);
}
#if !defined(_LIBSTDCXX_FBSTRING)
typedef basic_fbstring<char> fbstring;
#endif
......
folly/test/FBStringTest.cpp
View file @ 5a122efc
......@@ -1438,3 +1438,210 @@ TEST(FBStringCtorTest, NullZeroConstruction) {
folly::fbstring f(p, n);
EXPECT_EQ(f.size(), 0);
}
// Tests for the comparison operators. I use EXPECT_TRUE rather than EXPECT_LE
// because what's under test is the operator rather than the relation between
// the objects.
TEST(FBString, compareToStdString) {
using folly::fbstring;
using namespace std::string_literals;
auto stdA = "a"s;
auto stdB = "b"s;
fbstring fbA("a");
fbstring fbB("b");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(U16FBString, compareToStdU16String) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = u"a"s;
auto stdB = u"b"s;
basic_fbstring<char16_t> fbA(u"a");
basic_fbstring<char16_t> fbB(u"b");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(U32FBString, compareToStdU32String) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = U"a"s;
auto stdB = U"b"s;
basic_fbstring<char32_t> fbA(U"a");
basic_fbstring<char32_t> fbB(U"b");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(WFBString, compareToStdWString) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = L"a"s;
auto stdB = L"b"s;
basic_fbstring<wchar_t> fbA(L"a");
basic_fbstring<wchar_t> fbB(L"b");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
// Same again, but with a more challenging input - a common prefix and different
// lengths.
TEST(FBString, compareToStdStringLong) {
using folly::fbstring;
using namespace std::string_literals;
auto stdA = "1234567890a"s;
auto stdB = "1234567890ab"s;
fbstring fbA("1234567890a");
fbstring fbB("1234567890ab");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(U16FBString, compareToStdU16StringLong) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = u"1234567890a"s;
auto stdB = u"1234567890ab"s;
basic_fbstring<char16_t> fbA(u"1234567890a");
basic_fbstring<char16_t> fbB(u"1234567890ab");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(U32FBString, compareToStdU32StringLong) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = U"1234567890a"s;
auto stdB = U"1234567890ab"s;
basic_fbstring<char32_t> fbA(U"1234567890a");
basic_fbstring<char32_t> fbB(U"1234567890ab");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
TEST(WFBString, compareToStdWStringLong) {
using folly::basic_fbstring;
using namespace std::string_literals;
auto stdA = L"1234567890a"s;
auto stdB = L"1234567890ab"s;
basic_fbstring<wchar_t> fbA(L"1234567890a");
basic_fbstring<wchar_t> fbB(L"1234567890ab");
EXPECT_TRUE(stdA == fbA);
EXPECT_TRUE(fbB == stdB);
EXPECT_TRUE(stdA != fbB);
EXPECT_TRUE(fbA != stdB);
EXPECT_TRUE(stdA < fbB);
EXPECT_TRUE(fbA < stdB);
EXPECT_TRUE(stdB > fbA);
EXPECT_TRUE(fbB > stdA);
EXPECT_TRUE(stdA <= fbB);
EXPECT_TRUE(fbA <= stdB);
EXPECT_TRUE(stdA <= fbA);
EXPECT_TRUE(fbA <= stdA);
EXPECT_TRUE(stdB >= fbA);
EXPECT_TRUE(fbB >= stdA);
EXPECT_TRUE(stdB >= fbB);
EXPECT_TRUE(fbB >= stdB);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment