From 0c6b4675d1323d526d0817be8f89a65caab836af Mon Sep 17 00:00:00 2001
From: Birunthan Mohanathas <birunthan@mohanathas.com>
Date: Fri, 18 Jul 2014 14:52:29 -0700
Subject: [PATCH] Bug 1035884 - Template-ify nsWhitespaceTokenizer to remove
 duplicate code. r=froydnj

---
 xpcom/ds/nsWhitespaceTokenizer.h | 123 +++++++++++--------------------
 1 file changed, 44 insertions(+), 79 deletions(-)

diff --git a/xpcom/ds/nsWhitespaceTokenizer.h b/xpcom/ds/nsWhitespaceTokenizer.h
index 406632bd5d06..1ebb7c6614ac 100644
--- a/xpcom/ds/nsWhitespaceTokenizer.h
+++ b/xpcom/ds/nsWhitespaceTokenizer.h
@@ -10,11 +10,15 @@
 #include "nsDependentSubstring.h"
 #include "nsCRT.h"
 
-template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
-class nsWhitespaceTokenizerTemplate
+template<typename SubstringType,
+         typename DependentSubstringType,
+         bool IsWhitespace(char16_t)>
+class nsTWhitespaceTokenizer
 {
+  typedef typename SubstringType::char_type CharType;
+
 public:
-    nsWhitespaceTokenizerTemplate(const nsSubstring& aSource)
+    nsTWhitespaceTokenizer(const SubstringType& aSource)
         : mIter(aSource.Data(), aSource.Length()),
           mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
                aSource.Length()),
@@ -55,13 +59,13 @@ public:
     /**
      * Returns the next token.
      */
-    const nsDependentSubstring nextToken()
+    const DependentSubstringType nextToken()
     {
-        const mozilla::RangedPtr<const char16_t> tokenStart = mIter;
+        const mozilla::RangedPtr<const CharType> tokenStart = mIter;
         while (mIter < mEnd && !IsWhitespace(*mIter)) {
             ++mIter;
         }
-        const mozilla::RangedPtr<const char16_t> tokenEnd = mIter;
+        const mozilla::RangedPtr<const CharType> tokenEnd = mIter;
         mWhitespaceAfterCurrentToken = false;
         while (mIter < mEnd && IsWhitespace(*mIter)) {
             mWhitespaceAfterCurrentToken = true;
@@ -71,95 +75,56 @@ public:
     }
 
 private:
-    mozilla::RangedPtr<const char16_t> mIter;
-    const mozilla::RangedPtr<const char16_t> mEnd;
+    mozilla::RangedPtr<const CharType> mIter;
+    const mozilla::RangedPtr<const CharType> mEnd;
     bool mWhitespaceBeforeFirstToken;
     bool mWhitespaceAfterCurrentToken;
 };
 
-class nsWhitespaceTokenizer: public nsWhitespaceTokenizerTemplate<>
+template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
+class nsWhitespaceTokenizerTemplate
+  : public nsTWhitespaceTokenizer<nsSubstring, nsDependentSubstring,
+                                  IsWhitespace>
 {
 public:
-    nsWhitespaceTokenizer(const nsSubstring& aSource)
-      : nsWhitespaceTokenizerTemplate<>(aSource)
-    {
-    }
+  nsWhitespaceTokenizerTemplate(const nsSubstring& aSource)
+    : nsTWhitespaceTokenizer<nsSubstring, nsDependentSubstring,
+                             IsWhitespace>(aSource)
+  {
+  }
+};
+
+class nsWhitespaceTokenizer
+  : public nsWhitespaceTokenizerTemplate<>
+{
+public:
+  nsWhitespaceTokenizer(const nsSubstring& aSource)
+    : nsWhitespaceTokenizerTemplate<>(aSource)
+  {
+  }
 };
 
 template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
 class nsCWhitespaceTokenizerTemplate
+  : public nsTWhitespaceTokenizer<nsCSubstring, nsDependentCSubstring,
+                                  IsWhitespace>
 {
 public:
-    nsCWhitespaceTokenizerTemplate(const nsCSubstring& aSource)
-        : mIter(aSource.Data(), aSource.Length()),
-          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
-               aSource.Length()),
-          mWhitespaceBeforeFirstToken(false),
-          mWhitespaceAfterCurrentToken(false)
-    {
-        while (mIter < mEnd && IsWhitespace(*mIter)) {
-            mWhitespaceBeforeFirstToken = true;
-            ++mIter;
-        }
-    }
-
-    /**
-     * Checks if any more tokens are available.
-     */
-    bool hasMoreTokens() const
-    {
-        return mIter < mEnd;
-    }
-
-    /*
-     * Returns true if there is whitespace prior to the first token.
-     */
-    bool whitespaceBeforeFirstToken() const
-    {
-        return mWhitespaceBeforeFirstToken;
-    }
-
-    /*
-     * Returns true if there is any whitespace after the current token.
-     * This is always true unless we're reading the last token.
-     */
-    bool whitespaceAfterCurrentToken() const
-    {
-        return mWhitespaceAfterCurrentToken;
-    }
-
-    /**
-     * Returns the next token.
-     */
-    const nsDependentCSubstring nextToken()
-    {
-        const mozilla::RangedPtr<const char> tokenStart = mIter;
-        while (mIter < mEnd && !IsWhitespace(*mIter)) {
-            ++mIter;
-        }
-        const mozilla::RangedPtr<const char> tokenEnd = mIter;
-        mWhitespaceAfterCurrentToken = false;
-        while (mIter < mEnd && IsWhitespace(*mIter)) {
-            mWhitespaceAfterCurrentToken = true;
-            ++mIter;
-        }
-        return Substring(tokenStart.get(), tokenEnd.get());
-    }
-
-private:
-    mozilla::RangedPtr<const char> mIter;
-    const mozilla::RangedPtr<const char> mEnd;
-    bool mWhitespaceBeforeFirstToken;
-    bool mWhitespaceAfterCurrentToken;
+  nsCWhitespaceTokenizerTemplate(const nsCSubstring& aSource)
+    : nsTWhitespaceTokenizer<nsCSubstring, nsDependentCSubstring,
+                             IsWhitespace>(aSource)
+  {
+  }
 };
 
-class nsCWhitespaceTokenizer: public nsCWhitespaceTokenizerTemplate<>
+class nsCWhitespaceTokenizer
+  : public nsCWhitespaceTokenizerTemplate<>
 {
 public:
-    nsCWhitespaceTokenizer(const nsCSubstring& aSource)
-      : nsCWhitespaceTokenizerTemplate<>(aSource)
-    {
-    }
+  nsCWhitespaceTokenizer(const nsCSubstring& aSource)
+    : nsCWhitespaceTokenizerTemplate<>(aSource)
+  {
+  }
 };
 
 #endif /* __nsWhitespaceTokenizer_h */