Quadcap Embeddable Server

com/quadcap/util/text/Text.java

Go to the documentation of this file.

package com.quadcap.util.text;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.ArrayList;

/**
 * This class is yet another approach to string parsing.  It's basically
 * an anchored glob-style match.  
 *
 * @author Stan Bailes
 */
public class Text {
    /**
     * Extract strings matching glob patterns
     *
     * Examples:
     *    sv[0,1,2] = extractN(w, "*(*)*")
     *    sv[0-3] = extractN(w, "*:*:*:*");
     */
     
    public static String[] extractN(String s, String p) {
        return extractN(s, p, '*');
    }

    public static String[] extractMatching(String s,
                                           String[] p,
                                           char d) {
        // ret[ret.length-1] = String.valueOf(idx)
        //    where idx is the index of the matching pattern
        String[] ret = null;
        int i;
        for (i = 0; i < p.length; i++) {
            ret = extractN(s, p[i], d);
            if (ret != null) {
                break;
            }
        }
        if (ret != null) {
            String[] nret = new String[ret.length + 1];
            System.arraycopy(ret, 0, nret, 0, ret.length);
            nret[ret.length] = String.valueOf(i);
            ret = nret;
        }
        return ret;
    }

   public static String[] extractN(String s, String p, char d) {
        if (p == null || p.length() == 0) p = "" + d;
        if (p.charAt(0) != d) p = "" + d + p;
        if (p.charAt(p.length()-1) != d) p = p + d;
        
        // count glob instances, that's the number of strings to return
        int cnt = 0;
        StringBuffer sb = new StringBuffer();
        ArrayList list = new ArrayList();
        for (int i = 0; i < p.length(); i++) {
            char c = p.charAt(i);
            if (c == d) {
                cnt++;
                list.add(sb.toString());
                //msg("[" + sb + "]");
                sb.setLength(0);
            } else {
                sb.append(c);
            }
        }
        list.add(sb.toString());
        if (cnt < list.size()) cnt = list.size();
        String[] lits = new String[cnt];
        for (int i = 0; i < cnt; i++) {
            lits[i] = list.get(i).toString();
        }
        String[] ret = new String[cnt-1];
        int[] ixs = new int[cnt];
        int lev = 0;
        int rlev = 0;
        for (int i = 0; lev >= 0 && lev < cnt; i++) {
            int pre = ixs[lev];
            final int len = lits[lev].length();
            int idx = len == 0 ? pre : s.indexOf(lits[lev], pre);
            if (idx < 0) {
                lev--;
            } else {
                if (len == 0) {
                    ++lev;
                    if (i == 0) {       // first time through
                        if (lev < cnt) {
                            rlev--;
                            ixs[lev] = idx;
                        }
                    } else if (lev == 1) {
                        lev = -1;
                    } else {
                        ret[lev + rlev - 1] = s.substring(idx);
                    }
                } else {
                    ret[lev + rlev] = s.substring(pre, idx);
                    ixs[lev] = idx + len;
                    if (++lev < cnt) {
                        ixs[lev] = idx + len;
                    }
                }
            }
        }
        //#ifdef DEBUG
//          sb.setLength(0);
//          for (int i = 0; i < ret.length; i++) {
//              sb.append("\n[" + i + "] " + ret[i]);
//          }
//          sb.append("\n");
        //msg("extract(" + s + ") [" + p + "]: " + sb);
        //#endif
        return lev < cnt ? null : ret;
    }

    /**
     * Extract a substring
     *
     * example:
     *
     * extract(s, "*.gif", 0);
     * extract(s, "http://*index.html", 1);
     */
    public static String extract(String s, String p, int n) {
        return extract(s, p, n, '*');
    }
                
    public static String extract(String s, String p, int n, char d) {
        String[] ret = extractN(s, p, d);
        if (ret == null) {
            return s;
        } else {
            return ret[n];
        }
    }

}