Mega Code Archive
Advanced navigation over the underlying string
<![CDATA[
/*
* SSHTools - Java SSH2 API
*
* Copyright (C) 2002-2003 Lee David Painter and Contributors.
*
* Contributions made by:
*
* Brett Smith
* Richard Pernavas
* Erwin Bolwidt
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
// CONTENT : CLASS StringExaminer
// AUTHOR : Manfred Duchrow
// VERSION : 1.0 - 29/09/2002
// HISTORY :
// 29/09/2002 duma CREATED
//
// Copyright (c) 2002, by Manfred Duchrow. All rights reserved.
//package com.sshtools.daemon.util;
// IMPORTS
/**
* As a subclass of StringScanner this class allows more advanced navigation
* over the underlying string. <br>
* That includes moving to positions of specific substrings etc.
*
* @author Manfred Duchrow
* @version $Id: StringExaminer.java,v 1.7 2003/09/11 15:37:07 martianx Exp $
*/
public class StringExaminer extends StringScanner {
// CONSTANTS
// INSTANCE VARIABLES
private boolean ignoreCase = false;
// CLASS METHODS
// CONSTRUCTORS
/**
* Initialize the new instance with the string to examine. <br>
* The string will be treated case-sensitive.
*
* @param stringToExamine The string that should be examined
*/
public StringExaminer(String stringToExamine) {
this(stringToExamine, false);
}
// StringExaminer()
// -------------------------------------------------------------------------
/**
* Initialize the new instance with the string to examine.
*
* @param stringToExamine The string that should be examined
* @param ignoreCase Specified whether or not treating the string case
* insensitive
*/
public StringExaminer(String stringToExamine, boolean ignoreCase) {
super(stringToExamine);
this.ignoreCase(ignoreCase);
}
// StringExaminer()
/**
*
*
* @return
*/
protected boolean ignoreCase() {
return ignoreCase;
}
/**
*
*
* @param newValue
*/
protected void ignoreCase(boolean newValue) {
ignoreCase = newValue;
}
// -------------------------------------------------------------------------
// PUBLIC INSTANCE METHODS
/**
* Increments the position pointer up to the last character that matched
* the character sequence in the given matchString. Returns true, if the
* matchString was found, otherwise false.
*
* <p>
* If the matchString was found, the next invocation of method nextChar()
* returns the first character after that matchString.
* </p>
*
* @param matchString The string to look up
*
* @return
*/
public boolean skipAfter(String matchString) {
char ch = '-';
char matchChar = ' ';
boolean found = false;
int index = 0;
if ((matchString == null) || (matchString.length() == 0)) {
return false;
}
ch = this.nextChar();
while ((endNotReached(ch)) && (!found)) {
matchChar = matchString.charAt(index);
if (this.charsAreEqual(ch, matchChar)) {
index++;
if (index >= matchString.length()) { // whole matchString checked ?
found = true;
} else {
ch = this.nextChar();
}
} else {
if (index == 0) {
ch = this.nextChar();
} else {
index = 0;
}
}
}
return found;
}
// skipAfter()
// -------------------------------------------------------------------------
/**
* Increments the position pointer up to the first character before the
* character sequence in the given matchString. Returns true, if the
* matchString was found, otherwise false.
*
* <p>
* If the matchString was found, the next invocation of method nextChar()
* returns the first character of that matchString from the position where
* it was found inside the examined string.
* </p>
*
* @param matchString The string to look up
*
* @return
*/
public boolean skipBefore(String matchString) {
boolean found;
found = this.skipAfter(matchString);
if (found) {
this.skip(0 - matchString.length());
}
return found;
}
// skipBefore()
// -------------------------------------------------------------------------
/**
* Returns the a string containing all characters from the current position
* up to the end of the examined string. <br>
* The character position of the examiner is not changed by this method.
*
* @return
*/
public String peekUpToEnd() {
return this.upToEnd(true);
}
// peekUpToEnd()
// -------------------------------------------------------------------------
/**
* Returns the a string containing all characters from the current position
* up to the end of the examined string. <br>
* The character position is put to the end by this method. That means the
* next invocation of nextChar() returns END_REACHED.
*
* @return
*/
public String upToEnd() {
return this.upToEnd(false);
}
// upToEnd()
/**
*
*
* @param char1
* @param char2
*
* @return
*/
protected boolean charsAreEqual(char char1, char char2) {
return (this.ignoreCase())
? (Character.toUpperCase(char1) == Character.toUpperCase(char2))
: (char1 == char2);
}
// charsAreEqual()
// -------------------------------------------------------------------------
/**
* Returns the a string containing all characters from the current position
* up to the end of the examined string. <br>
* Depending on the peek flag the character position of the examiner is
* unchanged (true) after calling this method or points behind the strings
* last character.
*
* @param peek
*
* @return
*/
protected String upToEnd(boolean peek) {
char result = '-';
int lastPosition = 0;
StringBuffer buffer = new StringBuffer(100);
lastPosition = this.getPosition();
result = this.nextChar();
while (endNotReached(result)) {
buffer.append(result);
result = this.nextChar();
}
if (peek) {
this.setPosition(lastPosition);
}
return buffer.toString();
}
// upToEnd()
// -------------------------------------------------------------------------
}
// class StringExaminer
/*
* SSHTools - Java SSH2 API
*
* Copyright (C) 2002-2003 Lee David Painter and Contributors.
*
* Contributions made by:
*
* Brett Smith
* Richard Pernavas
* Erwin Bolwidt
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
// CONTENT : CLASS StringScanner
// AUTHOR : Manfred Duchrow
// VERSION : 1.1 - 29/09/2002
// HISTORY :
// 11/07/2001 duma CREATED
// 29/09/2002 duma added -> endReached(), endNotReached()
//
// Copyright (c) 2001-2002, by Manfred Duchrow. All rights reserved.
//package com.sshtools.daemon.util;
// IMPORTS
/**
* Simple scanner that allows to navigate over the characters of a string.
*
* @author Manfred Duchrow
* @version 1.1
*/
class StringScanner {
// CONSTANTS
/** */
public static final char END_REACHED = (char) -1;
// INSTANCE VARIABLES
/** */
protected int length = 0;
/** */
protected int position = 0;
/** */
protected int pos_marker = 0;
/** */
protected char[] buffer = null;
// -------------------------------------------------------------------------
// CONSTRUCTORS
/**
* Initialize the new instance with the string that should be scanned.
*
* @param stringToScan
*/
public StringScanner(String stringToScan) {
super();
length = stringToScan.length();
buffer = new char[length];
stringToScan.getChars(0, length, buffer, 0);
}
// StringScanner()
// PUBLIC CLASS METHODS
/**
* Returns true, if the given character indicates that the end of the
* scanned string is reached.
*
* @param character
*
* @return
*/
public boolean endReached(char character) {
return (character == END_REACHED);
}
// endReached()
// -------------------------------------------------------------------------
/**
* Returns true, if the given character does <b>not</b> indicate that the
* end of the scanned string si reached.
*
* @param character
*
* @return
*/
public boolean endNotReached(char character) {
return (!endReached(character));
}
// endNotReached()
// PUBLIC INSTANCE METHODS
/**
* Returns the string the scanner was initialized with
*
* @return
*/
public String toString() {
return new String(buffer);
}
// toString()
// -------------------------------------------------------------------------
/**
* Moves the position pointer count characters. positive values move
* forwards, negative backwards. The position never becomes negative !
*
* @param count
*/
public void skip(int count) {
position += count;
if (position < 0) {
position = 0;
}
}
// skip()
// -------------------------------------------------------------------------
/**
* Returns the character at the current position without changing the
* position, that is subsequent calls to this method return always the
* same character.
*
* @return
*/
public char peek() {
return ((position < length()) ? buffer[position] : END_REACHED);
}
// skip()
// -------------------------------------------------------------------------
/**
* Returns the character at the current position and increments the
* position afterwards by 1.
*
* @return
*/
public char nextChar() {
char next = this.peek();
if (endNotReached(next)) {
this.skip(1);
}
return next;
}
// nextChar()
// -------------------------------------------------------------------------
/**
* Returns true, if the scanner has reached the end and a further
* invocation of nextChar() would return the END_REACHED character.
*
* @return
*/
public boolean atEnd() {
return (endReached(this.peek()));
}
// atEnd()
// -------------------------------------------------------------------------
/**
* Returns true, if the scanner has not yet reached the end.
*
* @return
*/
public boolean hasNext() {
return !this.atEnd();
}
// hasNext()
// -------------------------------------------------------------------------
/**
* Returns the next character that is no whitespace and leaves the position
* pointer one character after the returned one.
*
* @return
*/
public char nextNoneWhitespaceChar() {
char next = this.nextChar();
while ((endNotReached(next)) && (Character.isWhitespace(next))) {
next = this.nextChar();
}
return next;
}
// nextNoneWhitespaceChar()
// -------------------------------------------------------------------------
/**
* Returns the current position in the string
*
* @return
*/
public int getPosition() {
return position;
}
// getPosition()
// -------------------------------------------------------------------------
/**
* Remembers the current position for later use with restorePosition()
*/
public void markPosition() {
pos_marker = position;
}
// markPosition()
// -------------------------------------------------------------------------
/**
* Restores the position to the value of the latest markPosition() call
*/
public void restorePosition() {
this.setPosition(pos_marker);
}
// restorePosition()
/**
*
*
* @return
*/
protected int length() {
return length;
}
// length()
// -------------------------------------------------------------------------
protected void setPosition(int pos) {
if ((pos >= 0) && (pos <= this.length())) {
position = pos;
}
}
// setPosition()
// -------------------------------------------------------------------------
}
// class StringScanner
]]>