001/*
002 * $Id$
003 */
004
005package edu.jas.kern;
006
007
008import java.io.IOException;
009import java.io.Reader;
010import java.io.StringWriter;
011
012
013/**
014 * Static String and Reader methods.
015 * @author Heinz Kredel
016 */
017
018public class StringUtil {
019
020
021    /**
022     * Parse white space delimited String from Reader.
023     * @param r Reader.
024     * @return next non white space String from r.
025     */
026    public static String nextString(Reader r) {
027        StringWriter sw = new StringWriter();
028        try {
029            char buffer;
030            int i;
031            // skip white space
032            while ((i = r.read()) > -1) {
033                buffer = (char) i;
034                if (!Character.isWhitespace(buffer)) {
035                    sw.write(buffer);
036                    break;
037                }
038            }
039            // read non white space, ignore new lines ?
040            while ((i = r.read()) > -1) {
041                buffer = (char) i;
042                if (Character.isWhitespace(buffer)) {
043                    break;
044                }
045                sw.write(buffer);
046            }
047        } catch (IOException e) {
048            e.printStackTrace();
049        }
050        return sw.toString();
051    }
052
053
054    /**
055     * Parse String with given delimiter from Reader.
056     * @param c delimiter.
057     * @param r Reader.
058     * @return next String up to c from r.
059     */
060    public static String nextString(Reader r, char c) {
061        StringWriter sw = new StringWriter();
062        try {
063            char buffer;
064            int i;
065            // read chars != c, ignore new lines ?
066            while ((i = r.read()) > -1) {
067                buffer = (char) i;
068                if (buffer == c) {
069                    break;
070                }
071                sw.write(buffer);
072            }
073        } catch (IOException e) {
074            e.printStackTrace();
075        }
076        return sw.toString().trim();
077    }
078
079
080    /**
081     * Parse paired String with given delimiters from Reader.
082     * @param b opposite delimiter.
083     * @param c delimiter, != b.
084     * @param r Reader.
085     * @return next nested matching String from b up to c from r.
086     */
087    public static String nextPairedString(Reader r, char b, char c) {
088        if (b == c) {
089            throw new IllegalArgumentException("b == c, not allowed " + b);
090        }
091        StringWriter sw = new StringWriter();
092        try {
093            int level = 0;
094            boolean first = true;
095            char buffer;
096            int i;
097            // read chars != c, ignore new lines ?
098            while ((i = r.read()) > -1) {
099                buffer = (char) i;
100                if (buffer == b) {
101                    level++;
102                    if (first) { // skip first opening 'brace'
103                        first = false;
104                        continue;
105                    }
106                }
107                if (buffer == c) {
108                    level--;
109                    if (level <= 0) {
110                        break; // skip last closing 'brace'
111                    }
112                }
113                if (level > 0) {
114                    sw.write(buffer);
115                }
116            }
117        } catch (IOException e) {
118            e.printStackTrace();
119        }
120        return sw.toString().trim();
121    }
122
123
124    /**
125     * Select stack trace parts.
126     * @param expr regular matching expression.
127     * @return stack trace with elements matching expr.
128     */
129    public static String selectStackTrace(String expr) {
130        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
131        StringBuffer sb = new StringBuffer();
132        for (int i = 0; i < stack.length; i++) {
133            String s = stack[i].toString();
134            if (s.indexOf("selectStackTrace") >= 0) {
135                continue;
136            }
137            if (s.matches(expr)) {
138                sb.append("\nstack[" + i + "] = ");
139                sb.append(s);
140            }
141            //System.out.println("stack["+i+"] = " + s);
142        }
143        return sb.toString();
144    }
145
146}