Java tutorial
/* * 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