Bug 662669 - nsCharSeparatedTokenizer/nsWhiteSpaceSeparatedTokenizer should use RangedPtr. r=Waldo
☠☠ backed out by 0415635dba49 ☠ ☠
authorSahil Chelaramani <Sahilc.2200@gmail.com>
Fri, 16 Aug 2013 09:18:13 -0400
changeset 142870 35afcb18f192a06f1ca5b672711af9723632c380
parent 142869 3b4b734eaa1af3aef432dc580aeffeb4d43c0af2
child 142871 d959083ba5f637f3be439102853c792fdc9ad690
push id1
push userroot
push dateMon, 20 Oct 2014 17:29:22 +0000
reviewersWaldo
bugs662669
milestone26.0a1
Bug 662669 - nsCharSeparatedTokenizer/nsWhiteSpaceSeparatedTokenizer should use RangedPtr. r=Waldo
xpcom/ds/nsCharSeparatedTokenizer.h
xpcom/ds/nsWhitespaceTokenizer.h
--- a/xpcom/ds/nsCharSeparatedTokenizer.h
+++ b/xpcom/ds/nsCharSeparatedTokenizer.h
@@ -1,16 +1,18 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __nsCharSeparatedTokenizer_h
 #define __nsCharSeparatedTokenizer_h
 
+#include "mozilla/RangedPtr.h"
+
 #include "nsDependentSubstring.h"
 #include "nsCRT.h"
 
 /**
  * This parses a SeparatorChar-separated string into tokens.
  * Whitespace surrounding tokens is not treated as part of tokens, however
  * whitespace inside a token is. If the final token is the empty string, it is
  * not returned.
@@ -39,37 +41,37 @@ public:
 
     nsCharSeparatedTokenizerTemplate(const nsSubstring& aSource,
                                      PRUnichar aSeparatorChar,
                                      uint32_t  aFlags = 0)
         : mFirstTokenBeganWithWhitespace(false),
           mLastTokenEndedWithWhitespace(false),
           mLastTokenEndedWithSeparator(false),
           mSeparatorChar(aSeparatorChar),
-          mFlags(aFlags)
+          mFlags(aFlags),
+          mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
         // Skip initial whitespace
-        while (mIter != mEnd && IsWhitespace(*mIter)) {
+        while (mIter < mEnd && IsWhitespace(*mIter)) {
             mFirstTokenBeganWithWhitespace = true;
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
         NS_ASSERTION(mIter == mEnd || !IsWhitespace(*mIter),
                      "Should be at beginning of token if there is one");
 
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     bool firstTokenBeganWithWhitespace() const
     {
         return mFirstTokenBeganWithWhitespace;
     }
 
     bool lastTokenEndedWithSeparator() const
@@ -82,66 +84,67 @@ public:
         return mLastTokenEndedWithWhitespace;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentSubstring nextToken()
     {
-        nsSubstring::const_char_iterator end = mIter, begin = mIter;
+        mozilla::RangedPtr<const PRUnichar> tokenStart = mIter, tokenEnd = mIter;
 
         NS_ASSERTION(mIter == mEnd || !IsWhitespace(*mIter),
                      "Should be at beginning of token if there is one");
 
         // Search until we hit separator or end (or whitespace, if separator
         // isn't required -- see clause with 'break' below).
-        while (mIter != mEnd && *mIter != mSeparatorChar) {
+        while (mIter < mEnd && *mIter != mSeparatorChar) {
           // Skip to end of current word.
-          while (mIter != mEnd &&
+          while (mIter < mEnd &&
                  !IsWhitespace(*mIter) && *mIter != mSeparatorChar) {
               ++mIter;
           }
-          end = mIter;
+          tokenEnd = mIter;
 
           // Skip whitespace after current word.
           mLastTokenEndedWithWhitespace = false;
-          while (mIter != mEnd && IsWhitespace(*mIter)) {
+          while (mIter < mEnd && IsWhitespace(*mIter)) {
               mLastTokenEndedWithWhitespace = true;
               ++mIter;
           }
           if (mFlags & SEPARATOR_OPTIONAL) {
             // We've hit (and skipped) whitespace, and that's sufficient to end
             // our token, regardless of whether we've reached a SeparatorChar.
             break;
           } // (else, we'll keep looping until we hit mEnd or SeparatorChar)
         }
 
         mLastTokenEndedWithSeparator = (mIter != mEnd &&
                                         *mIter == mSeparatorChar);
         NS_ASSERTION((mFlags & SEPARATOR_OPTIONAL) ||
-                     (mLastTokenEndedWithSeparator == (mIter != mEnd)),
+                     (mLastTokenEndedWithSeparator == (mIter < mEnd)),
                      "If we require a separator and haven't hit the end of "
                      "our string, then we shouldn't have left the loop "
                      "unless we hit a separator");
 
         // Skip separator (and any whitespace after it), if we're at one.
         if (mLastTokenEndedWithSeparator) {
             ++mIter;
 
-            while (mIter != mEnd && IsWhitespace(*mIter)) {
+            while (mIter < mEnd && IsWhitespace(*mIter)) {
                 ++mIter;
             }
         }
 
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const PRUnichar> mIter;
+    const mozilla::RangedPtr<const PRUnichar> mEnd;
     bool mFirstTokenBeganWithWhitespace;
     bool mLastTokenEndedWithWhitespace;
     bool mLastTokenEndedWithSeparator;
     PRUnichar mSeparatorChar;
     uint32_t  mFlags;
 };
 
 class nsCharSeparatedTokenizer: public nsCharSeparatedTokenizerTemplate<>
@@ -155,69 +158,71 @@ public:
     }
 };
 
 class nsCCharSeparatedTokenizer
 {
 public:
     nsCCharSeparatedTokenizer(const nsCSubstring& aSource,
                               char aSeparatorChar)
-        : mSeparatorChar(aSeparatorChar)
+        : mSeparatorChar(aSeparatorChar),
+          mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
 
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentCSubstring nextToken()
     {
-        nsCSubstring::const_char_iterator end = mIter, begin = mIter;
+        mozilla::RangedPtr<const char> tokenStart = mIter,tokenEnd = mIter;
 
         // Search until we hit separator or end.
-        while (mIter != mEnd && *mIter != mSeparatorChar) {
-          while (mIter != mEnd &&
+        while (mIter < mEnd && *mIter != mSeparatorChar) {
+          while (mIter < mEnd &&
                  !isWhitespace(*mIter) && *mIter != mSeparatorChar) {
               ++mIter;
           }
-          end = mIter;
+          tokenEnd = mIter;
 
-          while (mIter != mEnd && isWhitespace(*mIter)) {
+          while (mIter < mEnd && isWhitespace(*mIter)) {
               ++mIter;
           }
         }
 
         // Skip separator (and any whitespace after it).
-        if (mIter != mEnd) {
+        if (mIter < mEnd) {
             NS_ASSERTION(*mIter == mSeparatorChar, "Ended loop too soon");
             ++mIter;
 
-            while (mIter != mEnd && isWhitespace(*mIter)) {
+            while (mIter < mEnd && isWhitespace(*mIter)) {
                 ++mIter;
             }
         }
 
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsCSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const char> mIter;
+    const mozilla::RangedPtr<const char> mEnd;
     char mSeparatorChar;
 
     bool isWhitespace(unsigned char aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
--- a/xpcom/ds/nsWhitespaceTokenizer.h
+++ b/xpcom/ds/nsWhitespaceTokenizer.h
@@ -1,105 +1,108 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __nsWhitespaceTokenizer_h
 #define __nsWhitespaceTokenizer_h
 
+#include "mozilla/RangedPtr.h"
 #include "nsDependentSubstring.h"
 
 class nsWhitespaceTokenizer
 {
 public:
     nsWhitespaceTokenizer(const nsSubstring& aSource)
+        : mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentSubstring nextToken()
     {
-        nsSubstring::const_char_iterator begin = mIter;
-        while (mIter != mEnd && !isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const PRUnichar> tokenStart = mIter;
+        while (mIter < mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        nsSubstring::const_char_iterator end = mIter;
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const PRUnichar> tokenEnd = mIter;
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const PRUnichar> mIter;
+    const mozilla::RangedPtr<const PRUnichar> mEnd;
 
     bool isWhitespace(PRUnichar aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
 };
 
 class nsCWhitespaceTokenizer
 {
 public:
     nsCWhitespaceTokenizer(const nsCSubstring& aSource)
+        : mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentCSubstring nextToken()
     {
-        nsCSubstring::const_char_iterator begin = mIter;
-        while (mIter != mEnd && !isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const char> tokenStart = mIter;
+        while (mIter < mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        nsCSubstring::const_char_iterator end = mIter;
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const char> tokenEnd = mIter;
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsCSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const char> mIter;
+    const mozilla::RangedPtr<const char> mEnd;
 
     bool isWhitespace(char aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
 };