Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * 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.*;
Base string token splitter.

Author(s):
M. Ranganathan
Version:
1.2
 
 
 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.toCharArray();
          = buffer.length();
          = 0;
     }
 
     public String nextToken() {
         int startIdx = ;
         
         while ( < ) {
             char c = [];
             ++;
             if (c == '\n') {
                 break;
             }
         }
 
         return String.valueOf(startIdx - startIdx);
     }
 
     public boolean hasMoreChars() {
         return  < ;
     }
 
     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 = ;
        while ( <  && [] != '\n') {
            ++;
        }
        if ( <  && [] == '\n') {
            ++;
        }
        return String.valueOf(,startIdx - startIdx);
    }
    public String peekLine() {
        int curPos = ;
        String retval = this.getLine();
         = curPos;
        return retval;
    }
    public char lookAhead() throws ParseException {
        return lookAhead(0);
    }
    public char lookAhead(int kthrows ParseException {
        // Debug.out.println("ptr = " + ptr);
        try {
            return [ + k];
        }
        catch (IndexOutOfBoundsException e) {
            return '\0';
        }
    }
    public char getNextChar() throws ParseException {
        if ( >= )
            throw new ParseException(
                 + " getNextChar: End of buffer",
                );
        else
            return [++];
    }
    public void consume() {
         = ;
    }
    public void consume(int k) {
         += k;
    }

    
Get a Vector of the buffer tokenized by lines
    public Vector<StringgetLines() {
        Vector<Stringresult = new Vector<String>();
        while (hasMoreChars()) {
            String line = getLine();
            result.addElement(line);
        }
        return result;
    }

    
Get the next token from the buffer.
    public String getNextToken(char delimthrows ParseException {
        int startIdx = ;
        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(startIdx - startIdx);
    }

    
get the SDP field name of the line

Returns:
String
    public static String getSDPFieldName(String line) {
        if (line == null)
            return null;
        String fieldName = null;
        try {
            int begin = line.indexOf(.);
            fieldName = line.substring(0, begin);
        } catch (IndexOutOfBoundsException e) {
            return null;
        }
        return fieldName;
    }
New to GrepCode? Check out our FAQ X