Add char_traits support (needed for sstream).

5 files changed, 162 insertions, 20 deletions

diff --git a/include/char_traits.h b/include/char_traits.h
new file mode 100644
index 0000000..e320d44
--- /dev/null
+++ b/include/char_traits.h
@@ -0,0 +1,93 @@
+/* -*- c++ -*- */
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef ANDROID_ASTL_CHAR_TRAITS_H__
+#define ANDROID_ASTL_CHAR_TRAITS_H__
+
+#include <ios_pos_types.h>  // For streampos
+#include <cstdio>           // For EOF
+#include <cstring>          // For memcmp, memchr, strlen
+
+namespace std {
+
+/**
+ * Android's char traits is not a template since we support only
+ * char. The state_type is missing because we don't support multibyte
+ * strings.
+ * Basic type and constants (eof) used in string and stream.
+ */
+
+struct char_traits
+{
+    typedef char       char_type;
+    typedef int        int_type;
+    typedef streampos  pos_type;
+    typedef streamoff  off_type;
+
+    static void assign(char& lhs, const char& rhs) { lhs = rhs; }
+
+    static bool eq(const char& lhs, const char& rhs) { return lhs == rhs; }
+
+    static bool lt(const char& lhs, const char& rhs) { return lhs < rhs; }
+
+    static int compare(const char* lhs, const char* rhs, size_t n)
+    { return std::memcmp(lhs, rhs, n); }
+
+    static size_t length(const char* str) { return std::strlen(str); }
+
+    static const char* find(const char* str, size_t n, const char& c)
+    { return static_cast<const char*>(std::memchr(str, c, n)); }
+
+    static char* move(char* lhs, const char* rhs, size_t n)
+    { return static_cast<char*>(std::memmove(lhs, rhs, n)); }
+
+    static char* copy(char* lhs, const char* rhs, size_t n)
+    { return static_cast<char*>(std::memcpy(lhs, rhs, n)); }
+
+    // Fill 'lhs' with 'n' occurences of 'c'
+    static char* assign(char* lhs, size_t n, char c)
+    { return static_cast<char*>(std::memset(lhs, c, n)); }
+
+    static char to_char(const int_type& c) { return static_cast<char>(c); }
+
+    static int_type to_int_type(const char& c)
+    { return static_cast<int_type>(static_cast<unsigned char>(c)); }
+
+    static bool eq_int_type(const int_type& lhs, const int_type& rhs)
+    { return lhs == rhs; }
+
+    static int_type eof() { return static_cast<int_type>(EOF); }
+
+    static int_type not_eof(const int_type& c)
+    { return (c == eof()) ? 0 : c; }
+  };
+
+}  // namespace std
+
+#endif
diff --git a/include/string b/include/string
index 6215bf3..9d5632e 100644
--- a/include/string
+++ b/include/string
@@ -32,6 +32,7 @@
 
 #include <cstddef>
 #include <iterator>
+#include <char_traits.h>
 
 namespace std {
 
@@ -54,13 +55,14 @@ namespace std {
 class string
 {
   public:
-    typedef size_t            size_type;
-    typedef char              value_type;
-    typedef ptrdiff_t         difference_type;
-    typedef value_type&       reference;
-    typedef const value_type& const_reference;
-    typedef value_type*       pointer;
-    typedef const value_type* const_pointer;
+    typedef char_traits            traits_type;
+    typedef traits_type::char_type value_type;
+    typedef size_t                 size_type;
+    typedef ptrdiff_t              difference_type;
+    typedef value_type&            reference;
+    typedef const value_type&      const_reference;
+    typedef value_type*            pointer;
+    typedef const value_type*      const_pointer;
     typedef __wrapper_iterator<pointer,string>  iterator;
     typedef __wrapper_iterator<const_pointer,string> const_iterator;
 
diff --git a/src/string.cpp b/src/string.cpp
index bb9e35a..6eed77d 100644
--- a/src/string.cpp
+++ b/src/string.cpp
@@ -207,7 +207,7 @@ string::string(const value_type *str)
 {
     if (NULL != str)
     {
-        Constructor(str, strlen(str));
+        Constructor(str, traits_type::length(str));
     }
     else
     {
@@ -301,7 +301,7 @@ string& string::append(const value_type *str)
 {
     if (NULL != str)
     {
-        Append(str, strlen(str));
+        Append(str, traits_type::length(str));
     }
     return *this;
 }
@@ -379,22 +379,16 @@ int string::compare(const value_type *other) const
 
 bool operator==(const string& left, const string& right)
 {
-    if (&left == &right)
-    {
+    if (&left == &right) {
         return true;
     }
-    else
-    {
-        // We can use strcmp here because even when the string is build from an
-        // array of char we insert the terminating '\0'.
-        return strcmp(left.mData, right.mData) == 0;
-    }
+    return (left.size() == right.size() &&
+            !char_traits::compare(left.mData, right.mData, left.size()));
 }
 
 bool operator==(const string& left, const string::value_type *right)
 {
-    if (NULL == right)
-    {
+    if (NULL == right) {
         return false;
     }
     // We can use strcmp here because even when the string is build from an
@@ -480,7 +474,7 @@ string& string::assign(const value_type *str)
         return *this;
     }
     clear();
-    Constructor(str, strlen(str));
+    Constructor(str, traits_type::length(str));
     return *this;
 }
 
diff --git a/tests/Android.mk b/tests/Android.mk
index e27bafa..88dd282 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -62,6 +62,7 @@ endef
 
 sources := \
    test_algorithm.cpp \
+   test_char_traits.cpp \
    test_functional.cpp \
    test_ios_base.cpp \
    test_ios_pos_types.cpp \
diff --git a/tests/test_char_traits.cpp b/tests/test_char_traits.cpp
new file mode 100644
index 0000000..590e934
--- /dev/null
+++ b/tests/test_char_traits.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "../include/char_traits.h"
+#ifndef ANDROID_ASTL_CHAR_TRAITS_H__
+#error "Wrong header included!!"
+#endif
+#include "common.h"
+
+namespace android {
+using std::char_traits;
+
+bool testCharToInt()
+{
+    // Check that to_int_type maps '\xff' to 0xff and NOT 0xffffffff
+    // which is eof().
+    EXPECT_TRUE(char_traits::to_int_type('\xff') == 0xff);
+    EXPECT_TRUE(char_traits::to_int_type('\xff') != char_traits::eof());
+    return true;
+}
+}  // namespace android
+
+int main(int argc, char **argv)
+{
+    FAIL_UNLESS(testCharToInt);
+    return kPassed;
+}