gov.nist.core.StringTokenizer Maven / Gradle / Ivy
/*
* Conditions Of Use
*
* This software was developed by employees of the National Institute of
* Standards and Technology (NIST), an agency of the Federal Government.
* Pursuant to title 15 Untied States Code Section 105, works of NIST
* employees are not subject to copyright protection in the United States
* and are considered to be in the public domain. As a result, a formal
* license is not needed to use the software.
*
* This software is provided by NIST as a service and is expressly
* provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
* AND DATA ACCURACY. NIST does not warrant or make any representations
* regarding the use of the software or the results thereof, including but
* not limited to the correctness, accuracy, reliability or usefulness of
* the software.
*
* Permission to use this software is contingent upon your acceptance
* of the terms of this agreement
*
* .
*
*/
package gov.nist.core;
import java.util.*;
import java.text.ParseException;
/** Base string token splitter.
*
*@version 1.2
*
*@author M. Ranganathan
*
*
*
*/
public class StringTokenizer {
// jeand : moving to char array instead of string, more efficient CPU and mem wise
protected char[] buffer;
protected int bufferLen;
protected int ptr;
protected int savedPtr;
protected StringTokenizer() {
}
public StringTokenizer(String buffer) {
this.buffer = buffer.toCharArray();
bufferLen = buffer.length();
ptr = 0;
}
public String nextToken() {
int startIdx = ptr;
while (ptr < bufferLen) {
char c = buffer[ptr];
ptr++;
if (c == '\n') {
break;
}
}
return String.valueOf(buffer, startIdx, ptr - startIdx);
}
public boolean hasMoreChars() {
return ptr < bufferLen;
}
public static boolean isHexDigit(char ch) {
return (ch >= 'A' && ch <= 'F') ||
(ch >= 'a' && ch <= 'f') ||
isDigit(ch);
}
public static boolean isAlpha(char ch) {
if (ch <= 127) {
return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
}
else {
return Character.isLowerCase(ch) || Character.isUpperCase(ch);
}
}
public static boolean isDigit(char ch) {
if (ch <= 127) {
return (ch <= '9' && ch >= '0');
}
else {
return Character.isDigit(ch);
}
}
public static boolean isAlphaDigit(char ch) {
if (ch <= 127) {
return (ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z') ||
(ch <= '9' && ch >= '0');
}
else {
return Character.isLowerCase(ch) ||
Character.isUpperCase(ch) ||
Character.isDigit(ch);
}
}
public String getLine() {
int startIdx = ptr;
while (ptr < bufferLen && buffer[ptr] != '\n') {
ptr++;
}
if (ptr < bufferLen && buffer[ptr] == '\n') {
ptr++;
}
return String.valueOf(buffer,startIdx, ptr - startIdx);
}
public String peekLine() {
int curPos = ptr;
String retval = this.getLine();
ptr = curPos;
return retval;
}
public char lookAhead() throws ParseException {
return lookAhead(0);
}
public char lookAhead(int k) throws ParseException {
// Debug.out.println("ptr = " + ptr);
try {
return buffer[ptr + k];
}
catch (IndexOutOfBoundsException e) {
return '\0';
}
}
public char getNextChar() throws ParseException {
if (ptr >= bufferLen)
throw new ParseException(
buffer + " getNextChar: End of buffer",
ptr);
else
return buffer[ptr++];
}
public void consume() {
ptr = savedPtr;
}
public void consume(int k) {
ptr += k;
}
/** Get a Vector of the buffer tokenized by lines
*/
public Vector getLines() {
Vector result = new Vector();
while (hasMoreChars()) {
String line = getLine();
result.addElement(line);
}
return result;
}
/** Get the next token from the buffer.
*/
public String getNextToken(char delim) throws ParseException {
int startIdx = ptr;
while (true) {
char la = lookAhead(0);
if (la == delim)
break;
else if (la == '\0')
throw new ParseException("EOL reached", 0);
consume(1);
}
return String.valueOf(buffer, startIdx, ptr - startIdx);
}
/** get the SDP field name of the line
* @return String
*/
public static String getSDPFieldName(String line) {
if (line == null)
return null;
String fieldName = null;
try {
int begin = line.indexOf(Separators.EQUALS);
fieldName = line.substring(0, begin);
} catch (IndexOutOfBoundsException e) {
return null;
}
return fieldName;
}
}