/*
- * Copyright (C) 2001, 2002 The Mir-coders group
+ * Copyright (C) 2001, 2002 The Mir-coders group
*
* This file is part of Mir.
*
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, The Mir-coders gives permission to link
- * the code of this program with the com.oreilly.servlet library, any library
- * licensed under the Apache Software License, The Sun (tm) Java Advanced
- * Imaging library (JAI), The Sun JIMI library (or with modified versions of
- * the above that use the same license as the above), and distribute linked
- * combinations including the two. You must obey the GNU General Public
- * License in all respects for all of the code used other than the above
- * mentioned libraries. If you modify this file, you may extend this exception
- * to your version of the file, but you are not obligated to do so. If you do
- * not wish to do so, delete this exception statement from your version.
+ * the code of this program with any library licensed under the Apache Software License,
+ * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
+ * (or with modified versions of the above that use the same license as the above),
+ * and distribute linked combinations including the two. You must obey the
+ * GNU General Public License in all respects for all of the code used other than
+ * the above mentioned libraries. If you modify this file, you may extend this
+ * exception to your version of the file, but you are not obligated to do so.
+ * If you do not wish to do so, delete this exception statement from your version.
*/
-
package mir.util;
-import java.util.*;
-import gnu.regexp.*;
+import gnu.regexp.RE;
+
+import java.util.ArrayList;
+import java.util.List;
public class StringRoutines {
private StringRoutines() {
}
- static int indexOfCharacters(String aString, char[] aCharacters, int aFrom) {
+ public static int indexOfCharacters(String aString, char[] aCharacters, int aFrom) {
int i;
int result=-1;
int position;
return result;
}
- static String replaceStringCharacters(String aText, char[] aCharactersToReplace, String[] aStringsToSubstitute) {
+ public static String replaceStringCharacters(String aText, char[] aCharactersToReplace, String[] aStringsToSubstitute) {
+ if (aText==null)
+ return null;
+
int position, nextPosition;
int i;
StringBuffer result = new StringBuffer();
position=0;
-
do {
nextPosition = StringRoutines.indexOfCharacters(aText, aCharactersToReplace, position);
return result.toString();
}
+ /**
+ */
+
+ public static String replaceEscapedStringCharacters(String aText, char anEscapeCharacter, char[] aCharactersToReplace, String[] aStringsToSubstitute) {
+ if (aText==null)
+ return null;
+
+ int position, nextPosition;
+ int i;
+ StringBuffer result = new StringBuffer();
+
+ position=0;
+ do {
+ nextPosition = aText.indexOf(anEscapeCharacter, position);
+
+ if (nextPosition<0)
+ nextPosition = aText.length();
+
+ result.append(aText.substring(position, nextPosition));
+ if (nextPosition+1<aText.length()) {
+ nextPosition = nextPosition+1;
+
+ boolean found = false;
+ for (i = 0; i < aCharactersToReplace.length; i++) {
+ if (aCharactersToReplace[i] == aText.charAt(nextPosition)) {
+ result.append(aStringsToSubstitute[i]);
+ found=true;
+ break;
+ }
+ }
+
+ if (!found) {
+ result.append(aText.charAt(nextPosition));
+ }
+ }
+ position=nextPosition+1;
+ }
+ while (nextPosition<aText.length()) ;
+
+ return result.toString();
+ }
public static String interpretAsString(Object aValue) throws Exception {
if (aValue instanceof String)
return (String) aValue;
if (aValue instanceof Integer)
- return ((Integer) aValue).toString();
+ return aValue.toString();
if (aValue == null)
return "";
throw new Exception("Integer expected, "+aValue+" found");
}
- public static String performRegularExpressionReplacement(String aSource,
- String aSearchExpression, String aReplacement) throws Exception {
-
- RE regularExpression;
+ public static String performRegularExpressionReplacement(String aSource, String aSearchExpression, String aReplacement) {
+ try {
+ RE regularExpression;
- regularExpression = new RE(aSearchExpression);
+ regularExpression = new RE(aSearchExpression);
- return regularExpression.substituteAll(aSource, aReplacement);
+ return regularExpression.substituteAll(aSource, aReplacement);
+ }
+ catch (Throwable t) {
+ throw new UtilFailure("StringRoutines.performRegularExpressionReplacement: " + t.toString(), t);
+ }
}
- public static boolean performRegularExpressionSearch(String aSource,
- String aSearchExpression) throws REException {
- RE regularExpression;
+ /**
+ * Separates a string based on a separator:
+ * <code>seperateString("a:b:c", ":");</code> will lead to
+ * a List with 3 Strings: <code>"a"</code>, <code>"b"</code> and <code>"c"</code>
+ *
+ * @param aString The string to split
+ * @param aSeparator
+ * @return
+ */
+
+ public static List splitString(String aString, String aSeparator) {
+ List result= new ArrayList();
+ int previousPosition = 0;
+ int position;
- regularExpression = new RE(aSearchExpression);
+ if (aString!=null) {
+ while ( (position = aString.indexOf(aSeparator, previousPosition)) >= 0) {
+ result.add(aString.substring(previousPosition, position));
+ previousPosition = position + aSeparator.length();
+ }
+ result.add(aString.substring(previousPosition, aString.length()));
+ }
- return regularExpression.isMatch(aSource);
+ return result;
}
- public static List splitString(String aString, String aSeparator) {
- List result= new Vector();
+ /**
+ * Separates a String into at most 2 parts based on a separator:
+ * <ul>
+ * <li>
+ * <code>seperateString("a:b:c", ":");</code> will lead to
+ * a List with 2 Strings: <code>"a"</code> and <code>"b:c"</code>
+ * <li>
+ * <code>seperateString("abc", ":");</code> will lead to
+ * a List with a single String: <code>"abc"</code>
+ * </ul>
+ *
+ *
+ * @param aString
+ * @param aSeparator
+ * @return
+ */
+ public static List separateString(String aString, String aSeparator) {
+ List result= new ArrayList();
int previousPosition = 0;
int position;
- int endOfNamePosition;
- while ((position = aString.indexOf(aSeparator, previousPosition))>=0) {
+ if((position = aString.indexOf(aSeparator, previousPosition))>=0) {
result.add(aString.substring(previousPosition, position));
previousPosition = position + aSeparator.length();
}
return result;
}
-}
\ No newline at end of file
+
+ /**
+ * Separates a string based on a separator, taking into account an escape character:
+ * <code>seperateString("a:/::b", ":", "/");</code> will lead to
+ * a List with 3 Strings: <code>"a"</code>, <code>":"</code> and <code>"b"</code>
+ *
+ * @param aString The string to split
+ * @param aSeparator
+ * @return
+ */
+
+ public static List splitStringWithEscape(String aString, char aSeparator, char anEscape) {
+ List result= new ArrayList();
+ int previousPosition = 0;
+ int position;
+
+ StringBuffer currentItem = new StringBuffer();
+
+ if (aString!=null && aString.length()>0) {
+ while ((position = indexOfCharacters(aString, new char[] {aSeparator, anEscape}, previousPosition))>=0) {
+ currentItem.append(aString.substring(previousPosition, position));
+
+ if (aString.charAt(position)==aSeparator) {
+ result.add(currentItem.toString());
+ currentItem.delete(0, currentItem.length());
+ }
+ else {
+ if (aString.length()>position+1) {
+ position=position+1;
+ currentItem.append(aString.charAt(position));
+ }
+ else {
+ currentItem.append(aString.charAt(position));
+ }
+ }
+ previousPosition = position + 1;
+ }
+ currentItem.append(aString.substring(previousPosition, aString.length()));
+ result.add(currentItem.toString());
+ }
+
+ return result;
+ }
+
+ public static String replicateString(String aString, int aCount) {
+ StringBuffer result = new StringBuffer();
+
+ for (int i=0; i<aCount; i++)
+ result.append(aString);
+
+ return result.toString();
+ }
+
+ public static String replicateChar(char aCharacter, int aCount) {
+ char result[] = new char[aCount];
+
+ for (int i=0; i<aCount; i++)
+ result[i]= aCharacter;
+
+ return new String(result);
+ }
+
+ public static String padStringLeft(String aString, int aLength, char aPadCharacter) {
+ if (aString.length()<aLength)
+ return replicateChar(aPadCharacter, aLength-aString.length()) + aString;
+ return aString;
+ }
+
+ private static final char HEX_CHARACTERS[] = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+ };
+
+ public static String convertToHex(long aData, int aNumberOfDigits) {
+ StringBuffer result = new StringBuffer();
+
+ for (int digit = aNumberOfDigits-1; digit>=0; digit--) {
+ int value = (int) (aData >> (digit*4)) & 0xf;
+ result.append(HEX_CHARACTERS[value]);
+ }
+
+ return result.toString();
+ }
+
+ public static String convertToHex(byte[] aData) {
+ StringBuffer result = new StringBuffer();
+
+ for (int i = 0; i<aData.length; i++) {
+ result.append(convertToHex(aData[i], 2));
+
+ }
+
+ return result.toString();
+ }
+}