Changeset 143049 in webkit

Timestamp:

Feb 15, 2013 1:53:07 PM (11 years ago)

Author:

Christophe Dumez

Message:

Add CString operators for comparison with const char*
​https://bugs.webkit.org/show_bug.cgi?id=109947

Reviewed by Darin Adler.

Source/WTF:

Add operators to WTF::CString for equality/inequality comparison
with const char* strings. This avoids constructing a CString
from a const char* in such cases, which is can be expensive as
it would copy it and call strlen().

• wtf/text/CString.cpp:

(WTF::operator==): Use memcmp instead of strncmp to compare the
CString buffers as we know they are the same size and we don't
want to scan for terminating null byte.
(WTF):

• wtf/text/CString.h:

(WTF):
(WTF::operator!=):

Tools:

Add tests for WTF::CString's comparison operators.

• TestWebKitAPI/Tests/WTF/CString.cpp:

(TEST):

Location:

trunk

Files:

• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/text/CString.cpp (modified) (1 diff)
• Source/WTF/wtf/text/CString.h (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WTF/CString.cpp (modified) (1 diff)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2013-02-15  Christophe Dumez  <ch.dumez@sisa.samsung.com>
+
+        Add CString operators for comparison with const char*
+        https://bugs.webkit.org/show_bug.cgi?id=109947
+
+        Reviewed by Darin Adler.
+
+        Add operators to WTF::CString for equality/inequality comparison
+        with const char* strings. This avoids constructing a CString
+        from a const char* in such cases, which is can be expensive as
+        it would copy it and call strlen().
+
+        * wtf/text/CString.cpp:
+        (WTF::operator==): Use memcmp instead of strncmp to compare the
+        CString buffers as we know they are the same size and we don't
+        want to scan for terminating null byte.
+        (WTF):
+        * wtf/text/CString.h:
+        (WTF):
+        (WTF::operator!=):
+
 2013-02-15  Geoffrey Garen  <ggaren@apple.com>
 

trunk/Source/WTF/wtf/text/CString.cpp

@@ -111 +111 @@
     if (a.length() != b.length())
         return false;
-    return !strncmp(a.data(), b.data(), min(a.length(), b.length()));
+    return !memcmp(a.data(), b.data(), a.length());
+}
+
+bool operator==(const CString& a, const char* b)
+{
+    if (a.isNull() != !b)
+        return false;
+    if (!b)
+        return true;
+    return !strcmp(a.data(), b);
 }
 

trunk/Source/WTF/wtf/text/CString.h

@@ -85 +85 @@
 WTF_EXPORT_PRIVATE bool operator==(const CString& a, const CString& b);
 inline bool operator!=(const CString& a, const CString& b) { return !(a == b); }
+WTF_EXPORT_PRIVATE bool operator==(const CString& a, const char* b);
+inline bool operator!=(const CString& a, const char* b) { return !(a == b); }
 
 } // namespace WTF

trunk/Tools/ChangeLog

@@ +1 @@
+2013-02-15  Christophe Dumez  <ch.dumez@sisa.samsung.com>
+
+        Add CString operators for comparison with const char*
+        https://bugs.webkit.org/show_bug.cgi?id=109947
+
+        Reviewed by Darin Adler.
+
+        Add tests for WTF::CString's comparison operators.
+
+        * TestWebKitAPI/Tests/WTF/CString.cpp:
+        (TEST):
+
 2013-02-15  Zan Dobersek  <zdobersek@igalia.com>
 

trunk/Tools/TestWebKitAPI/Tests/WTF/CString.cpp

@@ -108 +108 @@
     ASSERT_STREQ(copy.data(), initialString);
 }
+
+TEST(WTF, CStringComparison)
+{
+    // Comparison with another CString.
+    CString a;
+    CString b;
+    ASSERT_TRUE(a == b);
+    ASSERT_FALSE(a != b);
+    a = "a";
+    b = CString();
+    ASSERT_FALSE(a == b);
+    ASSERT_TRUE(a != b);
+    a = "a";
+    b = "b";
+    ASSERT_FALSE(a == b);
+    ASSERT_TRUE(a != b);
+    a = "a";
+    b = "a";
+    ASSERT_TRUE(a == b);
+    ASSERT_FALSE(a != b);
+    a = "a";
+    b = "aa";
+    ASSERT_FALSE(a == b);
+    ASSERT_TRUE(a != b);
+    a = "";
+    b = "";
+    ASSERT_TRUE(a == b);
+    ASSERT_FALSE(a != b);
+    a = "";
+    b = CString();
+    ASSERT_FALSE(a == b);
+    ASSERT_TRUE(a != b);
+    a = "a";
+    b = "";
+    ASSERT_FALSE(a == b);
+    ASSERT_TRUE(a != b);
+
+    // Comparison with a const char*.
+    CString c;
+    const char* d = 0;
+    ASSERT_TRUE(c == d);
+    ASSERT_FALSE(c != d);
+    c = "c";
+    d = 0;
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = CString();
+    d = "d";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "c";
+    d = "d";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "c";
+    d = "c";
+    ASSERT_TRUE(c == d);
+    ASSERT_FALSE(c != d);
+    c = "c";
+    d = "cc";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "cc";
+    d = "c";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "";
+    d = "";
+    ASSERT_TRUE(c == d);
+    ASSERT_FALSE(c != d);
+    c = "";
+    d = 0;
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = CString();
+    d = "";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "a";
+    d = "";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+    c = "";
+    d = "b";
+    ASSERT_FALSE(c == d);
+    ASSERT_TRUE(c != d);
+}