Backed out changeset 35afcb18f192 (bug 662669) for build failures
authorEd Morley <emorley@mozilla.com>
Fri, 16 Aug 2013 14:55:15 +0100
changeset 142872 0415635dba49c6cba37591a4e89b34a310f0fb09
parent 142871 d959083ba5f637f3be439102853c792fdc9ad690
child 142873 20a7cbb1e01f9e10296d452267852323799462d3
push id1
push userroot
push dateMon, 20 Oct 2014 17:29:22 +0000
bugs662669
milestone26.0a1
backs out35afcb18f192a06f1ca5b672711af9723632c380
Backed out changeset 35afcb18f192 (bug 662669) for build failures
xpcom/ds/nsCharSeparatedTokenizer.h
xpcom/ds/nsWhitespaceTokenizer.h
--- a/xpcom/ds/nsCharSeparatedTokenizer.h
+++ b/xpcom/ds/nsCharSeparatedTokenizer.h
@@ -1,18 +1,16 @@
 /* -*- 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.
@@ -41,37 +39,37 @@ public:
 
     nsCharSeparatedTokenizerTemplate(const nsSubstring& aSource,
                                      PRUnichar aSeparatorChar,
                                      uint32_t  aFlags = 0)
         : mFirstTokenBeganWithWhitespace(false),
           mLastTokenEndedWithWhitespace(false),
           mLastTokenEndedWithSeparator(false),
           mSeparatorChar(aSeparatorChar),
-          mFlags(aFlags),
-          mIter(aSource.Data(), aSource.Length()),
-          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
-               aSource.Length())
+          mFlags(aFlags)
     {
+        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
@@ -84,67 +82,66 @@ public:
         return mLastTokenEndedWithWhitespace;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentSubstring nextToken()
     {
-        mozilla::RangedPtr<const PRUnichar> tokenStart = mIter, tokenEnd = mIter;
+        nsSubstring::const_char_iterator end = mIter, begin = 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;
           }
-          tokenEnd = mIter;
+          end = 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(tokenStart.get(), tokenEnd.get());
+        return Substring(begin, end);
     }
 
 private:
-    mozilla::RangedPtr<const PRUnichar> mIter;
-    const mozilla::RangedPtr<const PRUnichar> mEnd;
+    nsSubstring::const_char_iterator mIter, mEnd;
     bool mFirstTokenBeganWithWhitespace;
     bool mLastTokenEndedWithWhitespace;
     bool mLastTokenEndedWithSeparator;
     PRUnichar mSeparatorChar;
     uint32_t  mFlags;
 };
 
 class nsCharSeparatedTokenizer: public nsCharSeparatedTokenizerTemplate<>
@@ -158,71 +155,69 @@ public:
     }
 };
 
 class nsCCharSeparatedTokenizer
 {
 public:
     nsCCharSeparatedTokenizer(const nsCSubstring& aSource,
                               char aSeparatorChar)
-        : mSeparatorChar(aSeparatorChar),
-          mIter(aSource.Data(), aSource.Length()),
-          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
-               aSource.Length())
+        : mSeparatorChar(aSeparatorChar)
     {
+        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()
     {
-        mozilla::RangedPtr<const char> tokenStart = mIter,tokenEnd = mIter;
+        nsCSubstring::const_char_iterator end = mIter, begin = 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;
           }
-          tokenEnd = mIter;
+          end = 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(tokenStart.get(), tokenEnd.get());
+        return Substring(begin, end);
     }
 
 private:
-    mozilla::RangedPtr<const char> mIter;
-    const mozilla::RangedPtr<const char> mEnd;
+    nsCSubstring::const_char_iterator mIter, 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,108 +1,105 @@
 /* -*- 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())
     {
-        while (mIter < mEnd && isWhitespace(*mIter)) {
+        aSource.BeginReading(mIter);
+        aSource.EndReading(mEnd);
+
+        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()
     {
-        const mozilla::RangedPtr<const PRUnichar> tokenStart = mIter;
-        while (mIter < mEnd && !isWhitespace(*mIter)) {
+        nsSubstring::const_char_iterator begin = mIter;
+        while (mIter != mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        const mozilla::RangedPtr<const PRUnichar> tokenEnd = mIter;
-        while (mIter < mEnd && isWhitespace(*mIter)) {
+        nsSubstring::const_char_iterator end = mIter;
+        while (mIter != mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(tokenStart.get(), tokenEnd.get());
+        return Substring(begin, end);
     }
 
 private:
-    mozilla::RangedPtr<const PRUnichar> mIter;
-    const mozilla::RangedPtr<const PRUnichar> mEnd;
+    nsSubstring::const_char_iterator mIter, 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())
     {
-        while (mIter < mEnd && isWhitespace(*mIter)) {
+        aSource.BeginReading(mIter);
+        aSource.EndReading(mEnd);
+
+        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()
     {
-        const mozilla::RangedPtr<const char> tokenStart = mIter;
-        while (mIter < mEnd && !isWhitespace(*mIter)) {
+        nsCSubstring::const_char_iterator begin = mIter;
+        while (mIter != mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        const mozilla::RangedPtr<const char> tokenEnd = mIter;
-        while (mIter < mEnd && isWhitespace(*mIter)) {
+        nsCSubstring::const_char_iterator end = mIter;
+        while (mIter != mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(tokenStart.get(), tokenEnd.get());
+        return Substring(begin, end);
     }
 
 private:
-    mozilla::RangedPtr<const char> mIter;
-    const mozilla::RangedPtr<const char> mEnd;
+    nsCSubstring::const_char_iterator mIter, mEnd;
 
     bool isWhitespace(char aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
 };