source/mir/util/StringRoutines.java

   1 /*\r
   2  * Copyright (C) 2001, 2002 The Mir-coders group\r
   3  *\r
   4  * This file is part of Mir.\r
   5  *\r
   6  * Mir is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation; either version 2 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * Mir is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with Mir; if not, write to the Free Software\r
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
  19  *\r
  20  * In addition, as a special exception, The Mir-coders gives permission to link\r
  21  * the code of this program with  any library licensed under the Apache Software License,\r
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library\r
  23  * (or with modified versions of the above that use the same license as the above),\r
  24  * and distribute linked combinations including the two.  You must obey the\r
  25  * GNU General Public License in all respects for all of the code used other than\r
  26  * the above mentioned libraries.  If you modify this file, you may extend this\r
  27  * exception to your version of the file, but you are not obligated to do so.\r
  28  * If you do not wish to do so, delete this exception statement from your version.\r
  29  */\r
  30 package mir.util;\r
  31 \r
  32 import gnu.regexp.RE;\r
  33 import gnu.regexp.REException;\r
  34 \r
  35 import java.util.List;\r
  36 import java.util.Vector;\r
  37 \r
  38 public class StringRoutines {\r
  39 \r
  40   private StringRoutines() {\r
  41   }\r
  42 \r
  43   public static int indexOfCharacters(String aString, char[] aCharacters, int aFrom) {\r
  44     int i;\r
  45     int result=-1;\r
  46     int position;\r
  47 \r
  48     for (i=0; i<aCharacters.length ; i++) {\r
  49       position = aString.indexOf(aCharacters[i], aFrom);\r
  50 \r
  51       if (position != -1 && ( result == -1 || position < result )) {\r
  52         result = position;\r
  53       }\r
  54     }\r
  55 \r
  56     return result;\r
  57   }\r
  58 \r
  59   public static String replaceStringCharacters(String aText, char[] aCharactersToReplace, String[] aStringsToSubstitute) {\r
  60     if (aText==null)\r
  61       return null;\r
  62 \r
  63     int position, nextPosition;\r
  64     int i;\r
  65     StringBuffer result = new StringBuffer();\r
  66 \r
  67     position=0;\r
  68     do {\r
  69       nextPosition = StringRoutines.indexOfCharacters(aText, aCharactersToReplace, position);\r
  70 \r
  71       if (nextPosition<0)\r
  72         nextPosition = aText.length();\r
  73 \r
  74       result.append(aText.substring(position, nextPosition));\r
  75 \r
  76       if (nextPosition<aText.length())\r
  77         for (i=0; i<aCharactersToReplace.length; i++) {\r
  78           if (aCharactersToReplace[i] == aText.charAt(nextPosition)) {\r
  79             result.append(aStringsToSubstitute[i]);\r
  80             break;\r
  81           }\r
  82         }\r
  83       position=nextPosition+1;\r
  84     }\r
  85     while (nextPosition<aText.length()) ;\r
  86 \r
  87     return result.toString();\r
  88   }\r
  89 \r
  90 \r
  91   public static String interpretAsString(Object aValue) throws Exception {\r
  92     if (aValue instanceof String)\r
  93       return (String) aValue;\r
  94 \r
  95     if (aValue instanceof Integer)\r
  96       return ((Integer) aValue).toString();\r
  97 \r
  98     if (aValue == null)\r
  99       return "";\r
 100 \r
 101     throw new Exception("String expected, "+aValue+" found");\r
 102   }\r
 103 \r
 104   public static int interpretAsInteger(Object aValue) throws Exception {\r
 105     if (aValue instanceof Integer)\r
 106       return ((Integer) aValue).intValue();\r
 107 \r
 108     if (aValue instanceof String)\r
 109       try {\r
 110         return Integer.parseInt((String) aValue);\r
 111       }\r
 112       catch (Throwable t) {\r
 113         throw new Exception("Integer expected, "+aValue+" found");\r
 114       }\r
 115 \r
 116     throw new Exception("Integer expected, "+aValue+" found");\r
 117   }\r
 118 \r
 119   /**\r
 120    *\r
 121    * @param aSource\r
 122    * @param aSearchExpression\r
 123    * @param aReplacement\r
 124    * @return\r
 125    * @throws Exception\r
 126    */\r
 127   public static String performRegularExpressionReplacement(String aSource,\r
 128       String aSearchExpression, String aReplacement) throws Exception {\r
 129 \r
 130     RE regularExpression;\r
 131 \r
 132     regularExpression = new RE(aSearchExpression);\r
 133 \r
 134     return regularExpression.substituteAll(aSource, aReplacement);\r
 135   }\r
 136 \r
 137   /**\r
 138    *\r
 139    * @param aSource\r
 140    * @param aSearchExpression\r
 141    * @return\r
 142    * @throws REException\r
 143    */\r
 144   public static boolean performRegularExpressionSearch(String aSource,\r
 145       String aSearchExpression) throws REException {\r
 146     RE regularExpression;\r
 147 \r
 148     regularExpression = new RE(aSearchExpression);\r
 149 \r
 150     return regularExpression.isMatch(aSource);\r
 151   }\r
 152 \r
 153   /**\r
 154    * Separates a string based on a separator:\r
 155    *     <code>seperateString("a:b:c", ":");</code> will lead to\r
 156    *     a List with 3 Strings: <code>"a"</code>, <code>"b"</code> and <code>"c"</code>\r
 157    *\r
 158    * @param aString     The string to split\r
 159    * @param aSeparator\r
 160    * @return\r
 161    */\r
 162 \r
 163   public static List splitString(String aString, String aSeparator) {\r
 164     List result= new Vector();\r
 165     int previousPosition = 0;\r
 166     int position;\r
 167     int endOfNamePosition;\r
 168 \r
 169     if (aString!=null) {\r
 170       while ( (position = aString.indexOf(aSeparator, previousPosition)) >= 0) {\r
 171         result.add(aString.substring(previousPosition, position));\r
 172         previousPosition = position + aSeparator.length();\r
 173       }\r
 174       result.add(aString.substring(previousPosition, aString.length()));\r
 175     }\r
 176 \r
 177     return result;\r
 178   }\r
 179 \r
 180   /**\r
 181    * Separates a String into at most 2 parts based on a separator:\r
 182    * <ul>\r
 183    *   <li>\r
 184    *     <code>seperateString("a:b:c", ":");</code> will lead to\r
 185    *     a List with 2 Strings: <code>"a"</code> and <code>"b:c"</code>\r
 186    *   <li>\r
 187    *     <code>seperateString("abc", ":");</code> will lead to\r
 188    *     a List with a single String: <code>"abc"</code>\r
 189    * </ul>\r
 190    *\r
 191    *\r
 192    * @param aString\r
 193    * @param aSeparator\r
 194    * @return\r
 195    */\r
 196   public static List separateString(String aString, String aSeparator) {\r
 197     List result= new Vector();\r
 198     int previousPosition = 0;\r
 199     int position;\r
 200 \r
 201     if((position = aString.indexOf(aSeparator, previousPosition))>=0) {\r
 202       result.add(aString.substring(previousPosition, position));\r
 203       previousPosition = position + aSeparator.length();\r
 204     }\r
 205 \r
 206     result.add(aString.substring(previousPosition, aString.length()));\r
 207 \r
 208     return result;\r
 209   }\r
 210 \r
 211   public static List splitStringWithEscape(String aString, char aSeparator, char anEscape) {\r
 212     List result= new Vector();\r
 213     int previousPosition = 0;\r
 214     int position;\r
 215     int endOfNamePosition;\r
 216     StringBuffer currentItem = new StringBuffer();\r
 217 \r
 218     if (aString!=null) {\r
 219       while ((position = indexOfCharacters(aString, new char[] {aSeparator, anEscape}, previousPosition))>=0) {\r
 220         currentItem.append(aString.substring(previousPosition, position));\r
 221 \r
 222         if (aString.charAt(position)==aSeparator) {\r
 223           result.add(currentItem.toString());\r
 224           currentItem.delete(0, currentItem.length());\r
 225         }\r
 226         else {\r
 227           if (aString.length()>position+1) {\r
 228             position=position+1;\r
 229             currentItem.append(aString.charAt(position));\r
 230           }\r
 231         }\r
 232         previousPosition = position + 1;\r
 233       }\r
 234       currentItem.append(aString.substring(previousPosition, aString.length()));\r
 235       result.add(currentItem.toString());\r
 236     }\r
 237 \r
 238     return result;\r
 239   }\r
 240 \r
 241   public static String replicateString(String aString, int aCount) {\r
 242     StringBuffer result = new StringBuffer();\r
 243 \r
 244     for (int i=0; i<aCount; i++)\r
 245       result.append(aString);\r
 246 \r
 247     return result.toString();\r
 248   }\r
 249 \r
 250   public static String replicateChar(char aCharacter, int aCount) {\r
 251     char result[] = new char[aCount];\r
 252 \r
 253     for (int i=0; i<aCount; i++)\r
 254       result[i]= aCharacter;\r
 255 \r
 256     return new String(result);\r
 257   }\r
 258 \r
 259   public static String padStringLeft(String aString, int aLength, char aPadCharacter) {\r
 260     if (aString.length()<aLength)\r
 261       return replicateChar(aPadCharacter, aLength-aString.length()) + aString;\r
 262     else\r
 263       return aString;\r
 264   }\r
 265 \r
 266   private static final char HEX_CHARACTERS[] = {\r
 267       '0', '1', '2', '3', '4', '5', '6', '7',\r
 268       '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'\r
 269   };\r
 270 \r
 271   public static String convertToHex(long aData, int aNumberOfDigits) {\r
 272     StringBuffer result = new StringBuffer();\r
 273 \r
 274     for (int digit = aNumberOfDigits-1; digit>=0; digit--) {\r
 275       int value = (int) (aData >> (digit*4)) & 0xf;\r
 276       result.append(HEX_CHARACTERS[value]);\r
 277     }\r
 278 \r
 279     return result.toString();\r
 280   }\r
 281 \r
 282   public static String convertToHex(byte[] aData) {\r
 283     StringBuffer result = new StringBuffer();\r
 284 \r
 285     for (int i = 0; i<aData.length; i++) {\r
 286       result.append(convertToHex(aData[i], 2));\r
 287 \r
 288     }\r
 289 \r
 290     return result.toString();\r
 291   }\r
 292 }