cms/util/StringUtils.java

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

//---PACKAGE DECLARATION---
package uk.org.iscream.cms.util;

//---IMPORTS---
import java.util.*;

/**
 * A class containing useful methods for manipulating
 * String objects.
 *
 * @author  $Author: tdb $
 * @version $Id: StringUtils.java,v 1.8 2002/05/21 16:47:20 tdb Exp $
 */
public class StringUtils {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public static final String REVISION = "$Revision: 1.8 $";
    
//---STATIC METHODS---

    /**
     * Searches a string and replaces all occurences 
     * of the given search text with the given replacement
     * text.
     *
     * @param text the text to search and replace in
     * @param search the string to look for and replace
     * @param replace the text to replace with
     * @return the updated version of text
     */
    public static String replaceText(String text, String search, String replace) {
        StringBuffer textBuffer = new StringBuffer(text);
        int currIndex = 0;
        currIndex = text.indexOf(search, currIndex);
        while(currIndex != -1) {
            if (currIndex != -1) {
                textBuffer.delete(currIndex, currIndex + search.length());
                textBuffer.insert(currIndex, replace);
            }
            text = textBuffer.toString();
            currIndex = text.indexOf(search, currIndex + search.length());
        }
        return new String(textBuffer);
    }
    
    /**
     * This method takes an array of String's and a 
     * String to look for and returns the position
     * in the array that the string occurs.
     *
     * @param search the string to look for
     * @param array the array to look in
     *
     * @return the position in the array
     */
    public static int getStringPos(String search, String[] array) {
        for(int x = 0; x < array.length; x++) {
            if (array[x].equals(search)) {
                return x;
            }
        }
        return -1;
    }
    
    /**
     * Checks if a given string matches a
     * wildcard expression. For example:<br>
     * <br>
     * Given "testingstring"<br>
     * And   "test*ing"<br>
     * <br>
     * This method would return true as there is a match.
     * 
     * @param in the string to check
     * @param expression the wildcard expression to match against
     *
     * @return if there is a match
     */
    public static boolean wildcardMatch(String in, String expression) {
        // check actually has wildcards
        if(expression.indexOf("*") != -1) {
            StringTokenizer st = new StringTokenizer(expression, "*");
            String part = "";
            int index = 0;
            // the first token will be everything at the start
            // unless it starts with a wildcard
            // -- if it starts with a wildcard the start
            //    will always match
            if(!expression.startsWith("*")) {
                part = st.nextToken();
                if (in.startsWith(part)) {
                    index = part.length();
                }
                else {
                    // doesn't start with the first part
                    // can't be a match
                    return false;
                }
            }
            while (st.hasMoreTokens()) {
                part = st.nextToken();
                // if the next section can't be matched
                // then this isn't in the input string
                if(in.substring(index).indexOf(part) == -1) {
                    // we don't want to look through any more of it
                    // can't be a match if this part isn't there
                    return false;
                }
                else {
                    // move index pointer to start of the "rest"
                    // where the rest is everything after what we just matched
                    index += in.substring(index).indexOf(part) + part.length();
                }
            }
            // if we reach here and we've found a match
            // we want to check that the last part
            // of the wildcard string is the last part
            // of the input string, if it is, we break out
            // and finish as we've found a match.
            // if the end of the wildcard is a *, then
            // we don't care
            if (!expression.endsWith("*")) {
                if ((in.endsWith(part))) {
                    return true;
                }
                else {
                    // doesn't end with the first part
                    // can't be a match
                    return false;
                }
            // ends with a *, so it matches the
            // end regardless
            }
            else {
                return true;
            }
        }
        else if(in.equals(expression)) {
            // might as well do a check if they're the same
            // bit daft to call this whole method if they are though :)
            return true;
        }
        else {
            // obviously doesn't match if it's not a wildcard
            // expression or isn't equal :)
            return false;
        }
    }

//---CONSTRUCTORS---

//---PUBLIC METHODS---

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.org.iscream.cms.server.util.FormatName class
     * to format the toString()
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return FormatName.getName(
            _name,
            getClass().getName(),
            REVISION);
    }

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---

//---ATTRIBUTES---

    /**
     * This is the friendly identifier of the
     * component this class is running in.
     * eg, a Filter may be called "filter1",
     * If this class does not have an owning
     * component,  a name from the configuration
     * can be placed here.  This name could also
     * be changed to null for utility classes.
     */
    private String _name = null;

//---STATIC ATTRIBUTES---

}
Revision:	1.9
Committed:	Wed Feb 5 14:27:59 2003 UTC (21 years, 3 months ago) by tdb
Branch:	MAIN
Changes since 1.8:	+3 -3 lines
Log Message:	Util package has been pulled out of the server. Next step will be to modify the server and conient (and anything else?) to use this instead. New package name is uk.org.iscream.cms.util. All the java files were moved with a repo copy, so they retain their history.
#	Content
1	/*
2	* i-scream central monitoring system
3	* http://www.i-scream.org.uk
4	* Copyright (C) 2000-2002 i-scream
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	*/
20
21	//---PACKAGE DECLARATION---
22	package uk.org.iscream.cms.util;
23
24	//---IMPORTS---
25	import java.util.*;
26
27	/**
28	* A class containing useful methods for manipulating
29	* String objects.
30	*
31	* @author $Author: tdb $
32	* @version $Id: StringUtils.java,v 1.8 2002/05/21 16:47:20 tdb Exp $
33	*/
34	public class StringUtils {
35
36	//---FINAL ATTRIBUTES---
37
38	/**
39	* The current CVS revision of this class
40	*/
41	public static final String REVISION = "$Revision: 1.8 $";
42
43	//---STATIC METHODS---
44
45	/**
46	* Searches a string and replaces all occurences
47	* of the given search text with the given replacement
48	* text.
49	*
50	* @param text the text to search and replace in
51	* @param search the string to look for and replace
52	* @param replace the text to replace with
53	* @return the updated version of text
54	*/
55	public static String replaceText(String text, String search, String replace) {
56	StringBuffer textBuffer = new StringBuffer(text);
57	int currIndex = 0;
58	currIndex = text.indexOf(search, currIndex);
59	while(currIndex != -1) {
60	if (currIndex != -1) {
61	textBuffer.delete(currIndex, currIndex + search.length());
62	textBuffer.insert(currIndex, replace);
63	}
64	text = textBuffer.toString();
65	currIndex = text.indexOf(search, currIndex + search.length());
66	}
67	return new String(textBuffer);
68	}
69
70	/**
71	* This method takes an array of String's and a
72	* String to look for and returns the position
73	* in the array that the string occurs.
74	*
75	* @param search the string to look for
76	* @param array the array to look in
77	*
78	* @return the position in the array
79	*/
80	public static int getStringPos(String search, String[] array) {
81	for(int x = 0; x < array.length; x++) {
82	if (array[x].equals(search)) {
83	return x;
84	}
85	}
86	return -1;
87	}
88
89	/**
90	* Checks if a given string matches a
91	* wildcard expression. For example:<br>
92	* <br>
93	* Given "testingstring"<br>
94	* And "test*ing"<br>
95	* <br>
96	* This method would return true as there is a match.
97	*
98	* @param in the string to check
99	* @param expression the wildcard expression to match against
100	*
101	* @return if there is a match
102	*/
103	public static boolean wildcardMatch(String in, String expression) {
104	// check actually has wildcards
105	if(expression.indexOf("*") != -1) {
106	StringTokenizer st = new StringTokenizer(expression, "*");
107	String part = "";
108	int index = 0;
109	// the first token will be everything at the start
110	// unless it starts with a wildcard
111	// -- if it starts with a wildcard the start
112	// will always match
113	if(!expression.startsWith("*")) {
114	part = st.nextToken();
115	if (in.startsWith(part)) {
116	index = part.length();
117	}
118	else {
119	// doesn't start with the first part
120	// can't be a match
121	return false;
122	}
123	}
124	while (st.hasMoreTokens()) {
125	part = st.nextToken();
126	// if the next section can't be matched
127	// then this isn't in the input string
128	if(in.substring(index).indexOf(part) == -1) {
129	// we don't want to look through any more of it
130	// can't be a match if this part isn't there
131	return false;
132	}
133	else {
134	// move index pointer to start of the "rest"
135	// where the rest is everything after what we just matched
136	index += in.substring(index).indexOf(part) + part.length();
137	}
138	}
139	// if we reach here and we've found a match
140	// we want to check that the last part
141	// of the wildcard string is the last part
142	// of the input string, if it is, we break out
143	// and finish as we've found a match.
144	// if the end of the wildcard is a *, then
145	// we don't care
146	if (!expression.endsWith("*")) {
147	if ((in.endsWith(part))) {
148	return true;
149	}
150	else {
151	// doesn't end with the first part
152	// can't be a match
153	return false;
154	}
155	// ends with a *, so it matches the
156	// end regardless
157	}
158	else {
159	return true;
160	}
161	}
162	else if(in.equals(expression)) {
163	// might as well do a check if they're the same
164	// bit daft to call this whole method if they are though :)
165	return true;
166	}
167	else {
168	// obviously doesn't match if it's not a wildcard
169	// expression or isn't equal :)
170	return false;
171	}
172	}
173
174	//---CONSTRUCTORS---
175
176	//---PUBLIC METHODS---
177
178	/**
179	* Overrides the {@link java.lang.Object#toString() Object.toString()}
180	* method to provide clean logging (every class should have this).
181	*
182	* This uses the uk.org.iscream.cms.server.util.FormatName class
183	* to format the toString()
184	*
185	* @return the name of this class and its CVS revision
186	*/
187	public String toString() {
188	return FormatName.getName(
189	_name,
190	getClass().getName(),
191	REVISION);
192	}
193
194	//---PRIVATE METHODS---
195
196	//---ACCESSOR/MUTATOR METHODS---
197
198	//---ATTRIBUTES---
199
200	/**
201	* This is the friendly identifier of the
202	* component this class is running in.
203	* eg, a Filter may be called "filter1",
204	* If this class does not have an owning
205	* component, a name from the configuration
206	* can be placed here. This name could also
207	* be changed to null for utility classes.
208	*/
209	private String _name = null;
210
211	//---STATIC ATTRIBUTES---
212
213	}