The Tor Browser: xpcom/ds/nsWhitespaceTokenizer.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef __nsWhitespaceTokenizer_h

     7 #define __nsWhitespaceTokenizer_h

     9 #include "mozilla/RangedPtr.h"

    10 #include "nsDependentSubstring.h"

    11 #include "nsCRT.h"

    13 template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>

    14 class nsWhitespaceTokenizerTemplate

    15 {

    16 public:

    17     nsWhitespaceTokenizerTemplate(const nsSubstring& aSource)

    18         : mIter(aSource.Data(), aSource.Length()),

    19           mEnd(aSource.Data() + aSource.Length(), aSource.Data(),

    20                aSource.Length()),

    21           mWhitespaceBeforeFirstToken(false),

    22           mWhitespaceAfterCurrentToken(false)

    23     {

    24         while (mIter < mEnd && IsWhitespace(*mIter)) {

    25             mWhitespaceBeforeFirstToken = true;

    26             ++mIter;

    27         }

    28     }

    30     /**

    31      * Checks if any more tokens are available.

    32      */

    33     bool hasMoreTokens() const

    34     {

    35         return mIter < mEnd;

    36     }

    38     /*

    39      * Returns true if there is whitespace prior to the first token.

    40      */

    41     bool whitespaceBeforeFirstToken() const

    42     {

    43         return mWhitespaceBeforeFirstToken;

    44     }

    46     /*

    47      * Returns true if there is any whitespace after the current token.

    48      * This is always true unless we're reading the last token.

    49      */

    50     bool whitespaceAfterCurrentToken() const

    51     {

    52         return mWhitespaceAfterCurrentToken;

    53     }

    55     /**

    56      * Returns the next token.

    57      */

    58     const nsDependentSubstring nextToken()

    59     {

    60         const mozilla::RangedPtr<const char16_t> tokenStart = mIter;

    61         while (mIter < mEnd && !IsWhitespace(*mIter)) {

    62             ++mIter;

    63         }

    64         const mozilla::RangedPtr<const char16_t> tokenEnd = mIter;

    65         mWhitespaceAfterCurrentToken = false;

    66         while (mIter < mEnd && IsWhitespace(*mIter)) {

    67             mWhitespaceAfterCurrentToken = true;

    68             ++mIter;

    69         }

    70         return Substring(tokenStart.get(), tokenEnd.get());

    71     }

    73 private:

    74     mozilla::RangedPtr<const char16_t> mIter;

    75     const mozilla::RangedPtr<const char16_t> mEnd;

    76     bool mWhitespaceBeforeFirstToken;

    77     bool mWhitespaceAfterCurrentToken;

    78 };

    80 class nsWhitespaceTokenizer: public nsWhitespaceTokenizerTemplate<>

    81 {

    82 public:

    83     nsWhitespaceTokenizer(const nsSubstring& aSource)

    84       : nsWhitespaceTokenizerTemplate<>(aSource)

    85     {

    86     }

    87 };

    89 template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>

    90 class nsCWhitespaceTokenizerTemplate

    91 {

    92 public:

    93     nsCWhitespaceTokenizerTemplate(const nsCSubstring& aSource)

    94         : mIter(aSource.Data(), aSource.Length()),

    95           mEnd(aSource.Data() + aSource.Length(), aSource.Data(),

    96                aSource.Length()),

    97           mWhitespaceBeforeFirstToken(false),

    98           mWhitespaceAfterCurrentToken(false)

    99     {

   100         while (mIter < mEnd && IsWhitespace(*mIter)) {

   101             mWhitespaceBeforeFirstToken = true;

   102             ++mIter;

   103         }

   104     }

   106     /**

   107      * Checks if any more tokens are available.

   108      */

   109     bool hasMoreTokens() const

   110     {

   111         return mIter < mEnd;

   112     }

   114     /*

   115      * Returns true if there is whitespace prior to the first token.

   116      */

   117     bool whitespaceBeforeFirstToken() const

   118     {

   119         return mWhitespaceBeforeFirstToken;

   120     }

   122     /*

   123      * Returns true if there is any whitespace after the current token.

   124      * This is always true unless we're reading the last token.

   125      */

   126     bool whitespaceAfterCurrentToken() const

   127     {

   128         return mWhitespaceAfterCurrentToken;

   129     }

   131     /**

   132      * Returns the next token.

   133      */

   134     const nsDependentCSubstring nextToken()

   135     {

   136         const mozilla::RangedPtr<const char> tokenStart = mIter;

   137         while (mIter < mEnd && !IsWhitespace(*mIter)) {

   138             ++mIter;

   139         }

   140         const mozilla::RangedPtr<const char> tokenEnd = mIter;

   141         mWhitespaceAfterCurrentToken = false;

   142         while (mIter < mEnd && IsWhitespace(*mIter)) {

   143             mWhitespaceAfterCurrentToken = true;

   144             ++mIter;

   145         }

   146         return Substring(tokenStart.get(), tokenEnd.get());

   147     }

   149 private:

   150     mozilla::RangedPtr<const char> mIter;

   151     const mozilla::RangedPtr<const char> mEnd;

   152     bool mWhitespaceBeforeFirstToken;

   153     bool mWhitespaceAfterCurrentToken;

   154 };

   156 class nsCWhitespaceTokenizer: public nsCWhitespaceTokenizerTemplate<>

   157 {

   158 public:

   159     nsCWhitespaceTokenizer(const nsCSubstring& aSource)

   160       : nsCWhitespaceTokenizerTemplate<>(aSource)

   161     {

   162     }

   163 };

   165 #endif /* __nsWhitespaceTokenizer_h */

The Tor Browser / file revision