Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #ifndef __nsWhitespaceTokenizer_h
       8             : #define __nsWhitespaceTokenizer_h
       9             : 
      10             : #include "mozilla/RangedPtr.h"
      11             : #include "nsDependentSubstring.h"
      12             : #include "nsCRT.h"
      13             : 
      14             : template<typename DependentSubstringType, bool IsWhitespace(char16_t)>
      15             : class nsTWhitespaceTokenizer
      16             : {
      17             :   typedef typename DependentSubstringType::char_type CharType;
      18             :   typedef typename DependentSubstringType::substring_type SubstringType;
      19             : 
      20             : public:
      21           3 :   explicit nsTWhitespaceTokenizer(const SubstringType& aSource)
      22             :     : mIter(aSource.Data(), aSource.Length())
      23           3 :     , mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
      24             :            aSource.Length())
      25             :     , mWhitespaceBeforeFirstToken(false)
      26           6 :     , mWhitespaceAfterCurrentToken(false)
      27             :   {
      28           3 :     while (mIter < mEnd && IsWhitespace(*mIter)) {
      29           0 :       mWhitespaceBeforeFirstToken = true;
      30           0 :       ++mIter;
      31             :     }
      32           3 :   }
      33             : 
      34             :   /**
      35             :    * Checks if any more tokens are available.
      36             :    */
      37           6 :   bool hasMoreTokens() const
      38             :   {
      39           6 :     return mIter < mEnd;
      40             :   }
      41             : 
      42             :   /*
      43             :    * Returns true if there is whitespace prior to the first token.
      44             :    */
      45           3 :   bool whitespaceBeforeFirstToken() const
      46             :   {
      47           3 :     return mWhitespaceBeforeFirstToken;
      48             :   }
      49             : 
      50             :   /*
      51             :    * Returns true if there is any whitespace after the current token.
      52             :    * This is always true unless we're reading the last token.
      53             :    */
      54           3 :   bool whitespaceAfterCurrentToken() const
      55             :   {
      56           3 :     return mWhitespaceAfterCurrentToken;
      57             :   }
      58             : 
      59             :   /**
      60             :    * Returns the next token.
      61             :    */
      62           3 :   const DependentSubstringType nextToken()
      63             :   {
      64           3 :     const mozilla::RangedPtr<const CharType> tokenStart = mIter;
      65          35 :     while (mIter < mEnd && !IsWhitespace(*mIter)) {
      66          16 :       ++mIter;
      67             :     }
      68           3 :     const mozilla::RangedPtr<const CharType> tokenEnd = mIter;
      69           3 :     mWhitespaceAfterCurrentToken = false;
      70           3 :     while (mIter < mEnd && IsWhitespace(*mIter)) {
      71           0 :       mWhitespaceAfterCurrentToken = true;
      72           0 :       ++mIter;
      73             :     }
      74           3 :     return Substring(tokenStart.get(), tokenEnd.get());
      75             :   }
      76             : 
      77             : private:
      78             :   mozilla::RangedPtr<const CharType> mIter;
      79             :   const mozilla::RangedPtr<const CharType> mEnd;
      80             :   bool mWhitespaceBeforeFirstToken;
      81             :   bool mWhitespaceAfterCurrentToken;
      82             : };
      83             : 
      84             : template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
      85             : class nsWhitespaceTokenizerTemplate
      86             :   : public nsTWhitespaceTokenizer<nsDependentSubstring, IsWhitespace>
      87             : {
      88             : public:
      89           3 :   explicit nsWhitespaceTokenizerTemplate(const nsAString& aSource)
      90           3 :     : nsTWhitespaceTokenizer<nsDependentSubstring, IsWhitespace>(aSource)
      91             :   {
      92           3 :   }
      93             : };
      94             : 
      95             : typedef nsWhitespaceTokenizerTemplate<> nsWhitespaceTokenizer;
      96             : 
      97             : template<bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
      98             : class nsCWhitespaceTokenizerTemplate
      99             :   : public nsTWhitespaceTokenizer<nsDependentCSubstring, IsWhitespace>
     100             : {
     101             : public:
     102           0 :   explicit nsCWhitespaceTokenizerTemplate(const nsACString& aSource)
     103           0 :     : nsTWhitespaceTokenizer<nsDependentCSubstring, IsWhitespace>(aSource)
     104             :   {
     105           0 :   }
     106             : };
     107             : 
     108             : typedef nsCWhitespaceTokenizerTemplate<> nsCWhitespaceTokenizer;
     109             : 
     110             : #endif /* __nsWhitespaceTokenizer_h */