001    /*
002     * $Id: StringUtil.java 3354 2010-10-23 15:51:37Z kredel $
003     */
004    
005    package edu.jas.kern;
006    
007    
008    import java.io.Reader;
009    import java.io.StringWriter;
010    import java.io.IOException;
011    
012    
013    
014    /**
015     * Static String and Reader methods.
016     * @author Heinz Kredel
017     */
018    
019    public class StringUtil {
020    
021    
022        /**
023         * Parse white space delimited String from Reader.
024         * @param r Reader.
025         * @return next non white space String from r.
026         */
027        public static String nextString(Reader r) {
028            StringWriter sw = new StringWriter();
029            try {
030                char buffer;
031                int i;
032                // skip white space
033                while ((i = r.read()) > -1) {
034                    buffer = (char) i;
035                    if (!Character.isWhitespace(buffer)) {
036                        sw.write(buffer);
037                        break;
038                    }
039                }
040                // read non white space, ignore new lines ?
041                while ((i = r.read()) > -1) {
042                    buffer = (char) i;
043                    if (Character.isWhitespace(buffer)) {
044                        break;
045                    }
046                    sw.write(buffer);
047                }
048            } catch (IOException e) {
049                e.printStackTrace();
050            }
051            return sw.toString();
052        }
053    
054    
055        /**
056         * Parse String with given delimiter from Reader.
057         * @param c delimiter.
058         * @param r Reader.
059         * @return next String up to c from r.
060         */
061        public static String nextString(Reader r, char c) {
062            StringWriter sw = new StringWriter();
063            try {
064                char buffer;
065                int i;
066                // read chars != c, ignore new lines ?
067                while ((i = r.read()) > -1) {
068                    buffer = (char) i;
069                    if (buffer == c) {
070                        break;
071                    }
072                    sw.write(buffer);
073                }
074            } catch (IOException e) {
075                e.printStackTrace();
076            }
077            return sw.toString();
078        }
079    
080    
081        /**
082         * Parse paired String with given delimiters from Reader.
083         * @param b opposite delimiter.
084         * @param c delimiter.
085         * @param r Reader.
086         * @return next nested matching String up to c from r.
087         */
088        public static String nextPairedString(Reader r, char b, char c) {
089            StringWriter sw = new StringWriter();
090            try {
091                int level = 0;
092                char buffer;
093                int i;
094                // read chars != c, ignore new lines ?
095                while ((i = r.read()) > -1) {
096                    buffer = (char) i;
097                    if (buffer == b) {
098                        level++;
099                    }
100                    if (buffer == c) {
101                        level--;
102                        if (level < 0) {
103                            break; // skip last closing 'brace' 
104                        }
105                    }
106                    sw.write(buffer);
107                }
108            } catch (IOException e) {
109                e.printStackTrace();
110            }
111            return sw.toString();
112        }
113    
114    }