Return true if we can read some whitespace.
<p>
This is simply a convenience method.
<p>
This method will push back a character rather than an array whenever
possible (probably the majority of cases).

@return true if whitespace was found.
963298
private boolean tryWhitespace() throws SAXException, IOException {
        char c;
        c = readCh();
        if (isWhitespace(c)) {
            skipWhitespace();
            return true;
        } else {
            unread(c);
            return false;
        }
    }
1345210
@Override
    public boolean hasNext(int startPosition, int contentLength) {
        char ch = this.text[++this.position];
        if (ch == ',') return true;
        if (ch == '}' || ch == ']') return false;
        if (ch <= ' ') {
            for (;;) {
                ch = this.text[++this.position];
                if (ch > ' ') break;
            }
            if (ch == ',') return true;
            if (ch == '}' || ch == ']') return false;
        }
        this.position--; // { [ 交由 readObjectB 或 readMapB 或 readArrayB 读取
        return true;
    }
1125837
private int _readChar ()
  {
    try
    {
      final int c = m_aReader.read ();

      if (m_bTrackPosition)
      {
        if (m_nBackupChars > 0)
        {
          // If previously a char was backed up, don't increase the position!
          m_nBackupChars--;
        }
        else
          m_aPos.updatePosition (c, m_nTabSize);
      }
      return c;
    }
    catch (final IOException ex)
    {
      return EOI;
    }
  }
823179
protected function is_linear_whitespace()
	{
		return (bool) ($this->data[$this->position] === "\x09"
			|| $this->data[$this->position] === "\x20"
			|| ($this->data[$this->position] === "\x0A"
				&& isset($this->data[$this->position + 1])
				&& ($this->data[$this->position + 1] === "\x09" || $this->data[$this->position + 1] === "\x20")));
	}
232898
@Override
    protected boolean isTokenChar(int c) {

      if(!Character.isWhitespace(c) && searchCharacters.indexOf(c) == -1){
        return true;
      }
      return false;
    }
794844
public boolean hasNext() {
		if(next != null) {
			return true;
		}
		// find lowest next:
		PeekableIterator<E> nextSource = null;
		for(int i = 0; i < components.size(); i++) {
			PeekableIterator<E> pi = components.get(i);
			if(pi.hasNext()) {
				E piNext = pi.peekNext();
				if((next == null) || (comparator.compare(next,piNext) > 0)) {
					nextSource = pi;
					next = piNext;
				}
			}
		}
		if(nextSource != null) {
			nextSource.next();
		}
		return next != null;
	}
112632
protected boolean isDelimiter( String character )
  {
    String operands = ".;:()\\[]+-/%<=>!&|^~*";
    return Character.isWhitespace( character.charAt( 0 ) ) || operands.contains( character );
  }
999137
public static boolean isNullOrWhiteSpace(String arg) {

        if (Strings.isNullOrEmpty(arg) || arg.trim().isEmpty()) {
            return true;
        }

        return false;
    }
663492
public static boolean isWhiteSpace(String w) {
		for(int i=0;i<w.length();i++){
			char c = w.charAt(i);
			if(!Character.isWhitespace(c)){
				return false;
			}
		}
		return true;
	}
804833
private boolean isWhitespace(char c) {
        if (c > 0x20) {
            return false;
        }
        if ((c == 0x20) || (c == 0x0a) || (c == 0x09) || (c == 0x0d)) {
            return true;
        }
        return false; // illegal ...
    }
647606
public boolean hasNext() {
        if(_rs == null)
            return false;

        if(_primed)
            return true;

        try {
            _primed = _rs.next();
            return _primed;
        }
        catch(SQLException sql) {
            String msg = "An exception occurred reading from the Iterator.  Cause: " + sql;
            LOGGER.error(msg, sql);
            throw new IllegalStateException(msg, sql);
        }
    }
655877
public static boolean isAllWhitespace(CharSequence self) {
        String s = self.toString();
        for (int i = 0; i < s.length(); i++) {
            if (!Character.isWhitespace(s.charAt(i)))
                return false;
        }
        return true;
    }
440850
public static boolean isNullOrWhitespaceOnly(String str) {
		if (str == null || str.length() == 0) {
			return true;
		}

		final int len = str.length();
		for (int i = 0; i < len; i++) {
			if (!Character.isWhitespace(str.charAt(i))) {
				return false;
			}
		}
		return true;
	}
50221
public boolean isElementContentWhitespace() {
	// dynamic load to support jre 1.4 and 1.5
	try {
	    Method m = section.getClass().getMethod("isElementContentWhitespace", new Class[] {});
	    return Caster.toBooleanValue(m.invoke(section, ArrayUtil.OBJECT_EMPTY));
	}
	catch (Exception e) {
	    throw new PageRuntimeException(Caster.toPageException(e));
	}
    }
170114
public boolean removeSpace() {
	int start = pos;
	while (pos < text.length && lcText[pos] == ' ') {
	    pos++;
	}
	return (start < pos);
    }
1207968
private boolean _readChar()
	{
		int endIndex = pos + 1;
		if( endIndex <= len )
		{
			_char = text.substring( pos, endIndex );
			pos++;
			return true;
		}
		pos = len;
		return false;
	}
397963
private boolean isWhitespace(Chars data){
        char chars[] = data.array();
        int end = data.offset()+data.length();
        for(int i=data.offset(); i<end; i++){
            if(!XMLChar.isSpace(chars[i]))
                return false;
        }
        return true;
    }