Simplify and clean up StringTypeAdaptor and StringAppend.

third_party/WebKit/Source/wtf/text/StringConcatenate.h

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 32 matching lines @@
 
 template<typename StringType>
 class StringTypeAdapter {
     DISALLOW_NEW();
 };
 
 template<>
 class StringTypeAdapter<char> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<char>(char buffer)
-        : m_buffer(buffer)
-    {
-    }
+    explicit StringTypeAdapter<char>(char buffer)
+        : m_buffer(buffer) {}
 
-    unsigned length() { return 1; }
+    unsigned length() const { return 1; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination)
+    void writeTo(LChar* destination) const
     {
         *destination = m_buffer;
     }
 
-    void writeTo(UChar* destination) { *destination = m_buffer; }
+    void writeTo(UChar* destination) const { *destination = m_buffer; }
 
 private:
     unsigned char m_buffer;
 };
 
 template<>
 class StringTypeAdapter<LChar> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<LChar>(LChar buffer)
-        : m_buffer(buffer)
-    {
-    }
+    explicit StringTypeAdapter<LChar>(LChar buffer)
+        : m_buffer(buffer) {}
 
-    unsigned length() { return 1; }
+    unsigned length() const { return 1; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination)
+    void writeTo(LChar* destination) const
     {
         *destination = m_buffer;
     }
 
-    void writeTo(UChar* destination) { *destination = m_buffer; }
+    void writeTo(UChar* destination) const { *destination = m_buffer; }
 
 private:
     LChar m_buffer;
 };
 
 template<>
 class StringTypeAdapter<UChar> {
     DISALLOW_NEW();
 public:
     StringTypeAdapter<UChar>(UChar buffer)
-        : m_buffer(buffer)
-    {
-    }
+        : m_buffer(buffer) {}
 
-    unsigned length() { return 1; }
+    unsigned length() const { return 1; }
+    bool is8Bit() const { return m_buffer <= 0xff; }
 
-    bool is8Bit() { return m_buffer <= 0xff; }
-
-    void writeTo(LChar* destination)
+    void writeTo(LChar* destination) const
     {
         ASSERT(is8Bit());
         *destination = static_cast<LChar>(m_buffer);
     }
 
-    void writeTo(UChar* destination) { *destination = m_buffer; }
+    void writeTo(UChar* destination) const { *destination = m_buffer; }
 
 private:
     UChar m_buffer;
 };
 
 template<>
 class WTF_EXPORT StringTypeAdapter<char*> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<char*>(char* buffer)
+    explicit StringTypeAdapter<char*>(char* buffer)
         : m_buffer(buffer)
-        , m_length(strlen(buffer))
-    {
-    }
+        , m_length(strlen(buffer)) {}
 
-    unsigned length() { return m_length; }
+    unsigned length() const { return m_length; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
+    void writeTo(LChar* destination) const;
+    void writeTo(UChar* destination) const;
 
 private:
     const char* m_buffer;
     unsigned m_length;
 };
 
 template<>
 class WTF_EXPORT StringTypeAdapter<LChar*> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<LChar*>(LChar* buffer);
+    explicit StringTypeAdapter<LChar*>(LChar* buffer);
 
-    unsigned length() { return m_length; }
+    unsigned length() const { return m_length; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
+    void writeTo(LChar* destination) const;
+    void writeTo(UChar* destination) const;
 
 private:
     const LChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
 class WTF_EXPORT StringTypeAdapter<const UChar*> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter(const UChar* buffer);
+    explicit StringTypeAdapter(const UChar* buffer);
 
-    unsigned length() { return m_length; }
+    unsigned length() const { return m_length; }
+    bool is8Bit() const { return false; }
 
-    bool is8Bit() { return false; }
-
-    NO_RETURN_DUE_TO_CRASH void writeTo(LChar*)
+    NO_RETURN_DUE_TO_CRASH void writeTo(LChar*) const
     {
         RELEASE_ASSERT(false);
     }
 
-    void writeTo(UChar* destination);
+    void writeTo(UChar* destination) const;
 
 private:
     const UChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
 class WTF_EXPORT StringTypeAdapter<const char*> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<const char*>(const char* buffer);
+    explicit StringTypeAdapter<const char*>(const char* buffer);
 
-    unsigned length() { return m_length; }
+    unsigned length() const { return m_length; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
+    void writeTo(LChar* destination) const;
+    void writeTo(UChar* destination) const;
 
 private:
     const char* m_buffer;
     unsigned m_length;
 };
 
 template<>
 class WTF_EXPORT StringTypeAdapter<const LChar*> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<const LChar*>(const LChar* buffer);
+    explicit StringTypeAdapter<const LChar*>(const LChar* buffer);
 
-    unsigned length() { return m_length; }
+    unsigned length() const { return m_length; }
+    bool is8Bit() const { return true; }
 
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
+    void writeTo(LChar* destination) const;
+    void writeTo(UChar* destination) const;
 
 private:
     const LChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class WTF_EXPORT StringTypeAdapter<Vector<char>> {
-    DISALLOW_NEW();
-public:
-    StringTypeAdapter<Vector<char>>(const Vector<char>& buffer)
-        : m_buffer(buffer)
-    {
-    }
-
-    size_t length() { return m_buffer.size(); }
-
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
-
-private:
-    const Vector<char>& m_buffer;
-};
-
-template<>
-class StringTypeAdapter<Vector<LChar>> {
-    DISALLOW_NEW();
-public:
-    StringTypeAdapter<Vector<LChar>>(const Vector<LChar>& buffer)
-        : m_buffer(buffer)
-    {
-    }
-
-    size_t length() { return m_buffer.size(); }
-
-    bool is8Bit() { return true; }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
-
-private:
-    const Vector<LChar>& m_buffer;
-};
-
-template<>
 class WTF_EXPORT StringTypeAdapter<String> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<String>(const String& string)
-        : m_buffer(string)
-    {
-    }
+    explicit StringTypeAdapter<String>(const String& string)
+        : m_buffer(string) {}
 
-    unsigned length() { return m_buffer.length(); }
+    unsigned length() const { return m_buffer.length(); }
+    bool is8Bit() const { return m_buffer.isNull() || m_buffer.is8Bit(); }
 
-    bool is8Bit() { return m_buffer.isNull() || m_buffer.is8Bit(); }
-
-    void writeTo(LChar* destination);
-
-    void writeTo(UChar* destination);
+    void writeTo(LChar* destination) const;
+    void writeTo(UChar* destination) const;
 
 private:
     const String& m_buffer;
 };
 
 template<>
 class StringTypeAdapter<AtomicString> {
     DISALLOW_NEW();
 public:
-    StringTypeAdapter<AtomicString>(const AtomicString& string)
-        : m_adapter(string.getString())
-    {
-    }
+    explicit StringTypeAdapter<AtomicString>(const AtomicString& string)
+        : m_adapter(string.getString()) {}
 
-    unsigned length() { return m_adapter.length(); }
+    unsigned length() const { return m_adapter.length(); }
+    bool is8Bit() const { return m_adapter.is8Bit(); }
 
-    bool is8Bit() { return m_adapter.is8Bit(); }
-
-    void writeTo(LChar* destination) { m_adapter.writeTo(destination); }
-    void writeTo(UChar* destination) { m_adapter.writeTo(destination); }
+    void writeTo(LChar* destination) const { m_adapter.writeTo(destination); }
+    void writeTo(UChar* destination) const { m_adapter.writeTo(destination); }
 
 private:
     StringTypeAdapter<String> m_adapter;
 };
 
 inline void sumWithOverflow(unsigned& total, unsigned addend, bool& overflow)
 {
     unsigned oldTotal = total;
     total = oldTotal + addend;
     if (total < oldTotal)
         overflow = true;
 }
 
 template<typename StringType1, typename StringType2>
-PassRefPtr<StringImpl> makeString(StringType1 string1, StringType2 string2)
+PassRefPtr<StringImpl> makeString(const StringTypeAdapter<StringType1>& adapter1, const StringTypeAdapter<StringType2>& adapter2)
 {
-    StringTypeAdapter<StringType1> adapter1(string1);
-    StringTypeAdapter<StringType2> adapter2(string2);
-
     bool overflow = false;
     unsigned length = adapter1.length();
     sumWithOverflow(length, adapter2.length(), overflow);
     if (overflow)
         return nullptr;
 
     if (adapter1.is8Bit() && adapter2.is8Bit()) {
         LChar* buffer;
         RefPtr<StringImpl> resultImpl = StringImpl::createUninitialized(length, buffer);
         if (!resultImpl)
@@ skipping 17 matching lines @@
     result += adapter1.length();
     adapter2.writeTo(result);
 
     return resultImpl.release();
 }
 
 } // namespace WTF
 
 #include "wtf/text/StringOperators.h"
 #endif