X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=source%2Fmir%2Futil%2FStringRoutines.java;h=a7a41b61cc83a3abc72c1f4187df4911610f936e;hb=63e0ee1fb8038eb6d8f0190cf38c3b3ab2727216;hp=0edc27fc278687c9512b4253d997fc7351fe15f3;hpb=33f34b6346bc6ef0304e43fd402993e6e7cc403c;p=mir.git

diff --git a/source/mir/util/StringRoutines.java b/source/mir/util/StringRoutines.java
index 0edc27fc..a7a41b61 100755
--- a/source/mir/util/StringRoutines.java
+++ b/source/mir/util/StringRoutines.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2001, 2002  The Mir-coders group
+ * Copyright (C) 2001, 2002 The Mir-coders group
  *
  * This file is part of Mir.
  *
@@ -18,28 +18,28 @@
  * 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.List;
+import java.util.ArrayList;
 
 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;
@@ -55,6 +55,92 @@ public class StringRoutines {
     return result;
   }
 
+  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);
+
+      if (nextPosition<0)
+        nextPosition = aText.length();
+
+      result.append(aText.substring(position, nextPosition));
+
+      if (nextPosition<aText.length())
+        for (i=0; i<aCharactersToReplace.length; i++) {
+          if (aCharactersToReplace[i] == aText.charAt(nextPosition)) {
+            result.append(aStringsToSubstitute[i]);
+            break;
+          }
+        }
+      position=nextPosition+1;
+    }
+    while (nextPosition<aText.length()) ;
+
+    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 aValue.toString();
+
+    if (aValue == null)
+      return "";
+
+    throw new Exception("String expected, "+aValue+" found");
+  }
+
   public static int interpretAsInteger(Object aValue) throws Exception {
     if (aValue instanceof Integer)
       return ((Integer) aValue).intValue();
@@ -70,32 +156,93 @@ public class StringRoutines {
     throw new Exception("Integer expected, "+aValue+" found");
   }
 
-  public static String performRegularExpressionReplacement(String aSource,
-      String aSearchExpression, String aReplacement) throws Exception {
+  public static String performRegularExpressionReplacement(String aSource, String aSearchExpression, String aReplacement) {
+    try {
+      RE regularExpression;
 
-    RE regularExpression;
+      regularExpression = new RE(aSearchExpression);
 
-    regularExpression = new RE(aSearchExpression);
+      return regularExpression.substituteAll(aSource, aReplacement);
+    }
+    catch (Throwable t) {
+      throw new UtilFailure("StringRoutines.performRegularExpressionReplacement: " + t.toString(), t);
+    }
+  }
+
+  public static String performCaseInsensitiveRegularExpressionReplacement(String aSource, String aSearchExpression, String aReplacement) {
+    try {
+      RE regularExpression;
 
-    return regularExpression.substituteAll(aSource, aReplacement);
+      regularExpression = new RE(aSearchExpression, RE.REG_ICASE);
+
+      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;
+  public static boolean performRegularExpressionSearch(String aSource, String aSearchExpression) {
+    try {
+      RE regularExpression;
 
-    regularExpression = new RE(aSearchExpression);
+      regularExpression = new RE(aSearchExpression);
 
-    return regularExpression.isMatch(aSource);
+      return regularExpression.isMatch(aSource);
+    }
+    catch (Throwable t) {
+      throw new UtilFailure("StringRoutines.performRegularExpressionSearch: " + t.toString(), t);
+    }
   }
 
+  /**
+   * 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 Vector();
+    List result= new ArrayList();
     int previousPosition = 0;
     int position;
-    int endOfNamePosition;
 
-    while ((position = aString.indexOf(aSeparator, previousPosition))>=0) {
+    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 result;
+  }
+
+  /**
+   * 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;
+
+    if((position = aString.indexOf(aSeparator, previousPosition))>=0) {
       result.add(aString.substring(previousPosition, position));
       previousPosition = position + aSeparator.length();
     }
@@ -104,4 +251,99 @@ public class StringRoutines {
 
     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;
+    else
+      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();
+  }
+}