Advanced navigation over the underlying string. : String char « Data Type « Java






Advanced navigation over the underlying string.

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

   
    
    
    
    
  








Related examples in the same category

1.StrCharAt - show String.charAt()
2.Basic tab-character handling stuff
3.Convert Characters to Lower Case
4.Convert Characters to Upper Case
5.Replace Characters in a String
6.Character array to String conversion
7.Convert String to character array
8.Last occurrence of a character
9.Extract Ascii codes from a String
10.To remove a character
11.Removes specified chars from a string
12.Checks if a String is not empty (""), not null and not whitespace only.
13.Checks if a String is whitespace, empty ("") or null.
14.Checks if the String contains any character in the given set of characters.
15.Checks if the String contains only certain characters.
16.Checks if the String contains only whitespace.
17.Checks if the string contains only ASCII printable characters.
18.Checks that the String does not contain certain characters.
19.The character array based string
20.Checks whether the String contains only digit characters.
21.Remove char from a string
22.Remove whitespace from the ends as well as excessive whitespace within the inside of the string between non-whitespace characters.
23.Removes any hypens ( - ) from the given string
24.Returns a new string with all the whitespace removed
25.Is char a white space character
26.Simple scanner that allows to navigate over the characters of a string.
27.Returns a string with size of count and all characters initialized with ch.
28.Returns a string that contains all characters of the given string in reverse order.
29.Returns a string that is equivalent to the specified string with its first character converted to uppercase
30.Count the number of occurrences of character c in a string.
31.A fast way to convert character arrays into Strings.
32.XML utilities that pertain to character handling (markup or character data), without use of any XML libraries.
33.Check whether the given String contains any whitespace characters.
34.Character utilities.
35.Provides a number of static methods which interact with java.nio.charset.Charset to analyze and transform the strings identifing character encodings.
36.Operations on char primitives and Character objects.
37.Cleans strings of illegal characters with respect to the XML specification.
38.Return the result of adding the specified character to the specified sorted character array.
39.Return a displayable version of the character sequence, followed by integer positions at various powers of 10.
40.Returns the string constructed from the specified character sequence by deaccenting each of its characters.
41.Returns a hash code for a character sequence that is equivalent to the hash code generated for a its string yield.
42.Return true if the two character sequences have the same length and the same characters.
43.Returns an array of substrings of the specified string, in order, with divisions before and after any instance of the specified character.
44.Returns true if specified character is a punctuation character.
45.Appends a whitespace-normalized form of the specified character sequence into the specified string buffer.
46.Determine whether characters may appear in certain roles in XML documents.
47.Compare two char sequences
48.Contents As CharSequence