source/mir/misc/StringUtil.java

   1 /*
   2  * put your module comment here
   3  */
   4
   5
   6 package  mir.misc;
   7
   8 import  java.io.*;
   9 import  java.lang.*;
  10 import  java.util.*;
  11 import  gnu.regexp.*;
  12
  13 /**
  14  * Statische Hilfsmethoden zur Stringbehandlung
  15  *
  16  * @version 29.6.99
  17  * @author RK
  18  */
  19 public final class StringUtil {
  20
  21         /**
  22          * Wandelt Datum in einen 8-ziffrigen String um (yyyymmdd)
  23          * @param theDate
  24          * @return 8-ziffriger String (yyyymmdd)
  25          */
  26
  27         public static final String date2webdbDate (GregorianCalendar theDate) {
  28                 StringBuffer webdbDate = new StringBuffer();
  29                 webdbDate.append(String.valueOf(theDate.get(Calendar.YEAR)));
  30                 webdbDate.append(pad2(theDate.get(Calendar.MONTH) + 1));
  31                 webdbDate.append(pad2(theDate.get(Calendar.DATE)));
  32                 return  webdbDate.toString();
  33         }
  34
  35         /**
  36          * wandelt Calendar in dd.mm.yyyy / hh.mm um
  37          * @param theDate
  38          * @return String mit (dd.mm.yyyy / hh.mm um)
  39          */
  40         public static String date2readableDateTime (GregorianCalendar theDate) {
  41                 String readable = "";
  42                 int hour;
  43                 readable += pad2(theDate.get(Calendar.DATE));
  44                 readable += "." + pad2(theDate.get(Calendar.MONTH) + 1);
  45                 readable += "." + String.valueOf(theDate.get(Calendar.YEAR));
  46                 hour = theDate.get(Calendar.HOUR);
  47                 if (theDate.get(Calendar.AM_PM) == Calendar.PM)
  48                         hour += 12;
  49                 readable += " / " + pad2(hour);
  50                 readable += ":" + pad2(theDate.get(Calendar.MINUTE));
  51                 return  readable;
  52         }
  53
  54         /**
  55          * wandelt eine Datum in einen 8-buchstabigen String, der durch <code>/</code>
  56          * getrennt ist.
  57          *
  58          * @param webdbDate
  59          * @return String mit <code>/yyyy/mm/dd</code>
  60          */
  61         public static final String webdbDate2path (String webdbDate) {
  62                 StringBuffer path = new StringBuffer();
  63                 path.append("/").append(webdbDate.substring(0, 4));
  64                 path.append("/").append(webdbDate.substring(4, 6));
  65                 path.append("/").append(webdbDate.substring(6, 8));
  66                 return  path.toString();
  67         }
  68
  69         /**
  70          * wandelt Calendar in dd.mm.yyyy um
  71          *
  72          * @param theDate
  73          * @return String mit  <code>dd.mm.yyyy</code>
  74          */
  75         public static final String webdbDate2readableDate (String webdbDate) {
  76                 String date = "";
  77                 date += webdbDate.substring(6, 8);
  78                 date += "." + webdbDate.substring(4, 6);
  79                 date += "." + webdbDate.substring(0, 4);
  80                 return  date;
  81         }
  82
  83
  84   /**
  85    * converts string from format: yyyy-mm-dd__hh:mm:ss.d
  86    * to dd.mm.yyyy hh:mm
  87    */
  88         public static String dateToReadableDate(String date) {
  89                 StringBuffer returnDate = new StringBuffer();
  90                 if (date!=null) {
  91
  92                         returnDate.append(date.substring(8,10)).append('.');
  93                         returnDate.append(date.substring(5,7)).append('.');
  94                         returnDate.append(date.substring(0,4)).append(' ');
  95                         returnDate.append(date.substring(11,16));
  96                 }
  97                 return returnDate.toString();
  98         }
  99
 100
 101         /**
 102          * schließt einen String in Anführungsszeichen ein, falls er Leerzeichen o.ä. enthält
 103          *
 104          * @return gequoteter String
 105          */
 106          public static String quoteIfNecessary(String s) {
 107                 for (int i = 0; i < s.length(); i++)
 108                         if (!(Character.isLetterOrDigit(s.charAt(i)) || s.charAt(i) == '.'))
 109                                 return quote(s, '"');
 110                 return s;
 111         }
 112
 113          /**
 114          * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
 115          * "gefährliche" Zeichen innerhalb des Strings
 116          * Quotes special SQL-characters in <code>s</code>
 117          *
 118          * @return geqoteter String
 119          */
 120         public static String quote(String s)
 121         {
 122     //String s2 = quote(s, '\'');
 123
 124     //Quickhack
 125     //Because of '?-Bug in Postgresql-JDBC-Driver
 126     StringBuffer temp = new StringBuffer();
 127     for(int i=0;i<s.length();i++){
 128       if(s.charAt(i)=='\''){
 129         temp.append("&acute;");
 130       } else {
 131         temp.append(s.charAt(i));
 132       }
 133     }
 134     String s2 = temp.toString();
 135     //Quickhack end
 136
 137     s2 = quote(s2, '\"');
 138                 return s2;
 139         }
 140
 141         /**
 142          * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
 143          * "gefährliche" Zeichen innerhalb des Strings
 144          *
 145          * @param s String, der gequoted werden soll
 146          * @param quoteChar zu quotendes Zeichen
 147          * @return gequoteter String
 148          */
 149         public static String quote(String s, char quoteChar)
 150         {
 151                 StringBuffer buf = new StringBuffer(s.length());
 152                 int pos = 0;
 153                 while (pos < s.length()) {
 154                         int i = s.indexOf(quoteChar, pos);
 155                         if (i < 0) i = s.length();
 156                         buf.append(s.substring(pos, i));
 157                         pos = i;
 158                         if (pos < s.length()) {
 159                                 buf.append('\\');
 160               buf.append(quoteChar);
 161         pos++;
 162                         }
 163                 }
 164                 return buf.toString();
 165         }
 166
 167         /**
 168          * ersetzt gefährliche zeichen in  <code>s</code>
 169          *
 170          */
 171
 172         public static String unquote(String s)
 173         {
 174                 char quoteChar='\'';
 175                 StringBuffer buf = new StringBuffer(s.length());
 176                 int pos = 0;
 177                 String searchString = "\\"+quoteChar;
 178                 while (pos < s.length()) {
 179                         int i = s.indexOf(searchString, pos);
 180                         if (i < 0) i = s.length();
 181                         buf.append(s.substring(pos, i));
 182                         pos = i+1;
 183                 }
 184                 return buf.toString();
 185         }
 186
 187         /**
 188          * Wandelet String in byte[] um.
 189          * @param s
 190          * @return byte[] des String
 191          */
 192
 193         public static byte[] stringToBytes(String s) {
 194                 String crlf = System.getProperty("line.separator");
 195                 if (!crlf.equals("\n"))
 196                         s = replace(s, "\n", crlf);
 197     // byte[] buf = new byte[s.length()];
 198     byte[] buf = s.getBytes();
 199                 return buf;
 200         }
 201
 202                 /**
 203          * Ersetzt in String <code>s</code> das <code>pattern</code> durch <code>substitute</code>
 204          * @param s
 205          * @param pattern
 206          * @param substitute
 207          * @return String mit den Ersetzungen
 208          */
 209         public static String replace(String s, String pattern, String substitute) {
 210                 int i = 0, pLen = pattern.length(), sLen = substitute.length();
 211                 StringBuffer buf = new StringBuffer(s.length());
 212                 while (true) {
 213                         int j = s.indexOf(pattern, i);
 214                         if (j < 0) {
 215                                 buf.append(s.substring(i));
 216                                 break;
 217                         } else {
 218                                 buf.append(s.substring(i, j));
 219                                 buf.append(substitute);
 220                                 i = j+pLen;
 221                         }
 222                 }
 223                 return buf.toString();
 224         }
 225
 226
 227         /**
 228          * Fügt einen Separator an den Pfad an
 229          * @param path
 230          * @return Pfad mit Separator am Ende
 231          */
 232         public static final String addSeparator (String path) {
 233                 return  path.length() == 0 || path.endsWith(File.separator) ? path : path
 234                                 + File.separatorChar;
 235         }
 236
 237         /**
 238          * Fügt ein <code>/</code> ans ende des Strings and
 239          * @param path
 240          * @return Pfad mit <code>/</code> am Ende
 241          */
 242         public static final String addSlash (String path) {
 243                 return  path.length() == 0 || path.endsWith("/") ? path : path + '/';
 244         }
 245
 246         /**
 247          * Löscht <code>/</code> am Ende des Strings, falls vorhanden
 248          * @param path
 249          * @return String ohne <code>/</code> am Ende
 250          */
 251         public static final String removeSlash (String path) {
 252                 return  path.length() > 1 && path.endsWith("/") ? path.substring(0, path.length()
 253                                 - 1) : path;
 254         }
 255
 256         /**
 257          * Löscht Slash am Anfang des Strings
 258          * @param path
 259          * @return
 260          */
 261         public static String removeFirstSlash (String path) {
 262                 return  path.startsWith("/") ? path.substring(1) : path;
 263         }
 264
 265         /**
 266          * formatiert eine Zahl (0-99) zweistellig (z.B. 5 -> 05)
 267          * @return zwistellige Zahl
 268          */
 269         public static String pad2 (int number) {
 270                 return  number < 10 ? "0" + number : String.valueOf(number);
 271         }
 272
 273         /**
 274          * formatiert eine Zahl (0-999) dreistellig (z.B. 7 -> 007)
 275          *
 276          * @return 3-stellige Zahl
 277          */
 278         public static String pad3 (int number) {
 279                 return  number < 10 ? "00" + number : number < 100 ? "0" + number : String.valueOf(number);
 280         }
 281
 282         /**
 283          * Konvertiert Unix-Linefeeds in Win-Linefeeds
 284          * @param s
 285          * @return Konvertierter String
 286          */
 287         public static String unixLineFeedsToWin(String s) {
 288                 int i = -1;
 289                 while (true) {
 290                         i = s.indexOf('\n', i+1);
 291                         if (i < 0) break;
 292                         if ((i == 0 || s.charAt(i-1) != '\r') &&
 293                                 (i == s.length()-1 || s.charAt(i+1) != '\r')) {
 294                                 s = s.substring(0, i)+'\r'+s.substring(i);
 295                                 i++;
 296                         }
 297                 }
 298                 return s;
 299         }
 300
 301
 302         /**
 303          * verwandelt einen String in eine gültige Url, konvertiert Sonderzeichen
 304          * und Spaces werden zu Underscores
 305          *
 306          * @return gültige Url
 307          */
 308         public static String convert2url(String s) {
 309                 s = toLowerCase(s);
 310                 StringBuffer buf = new StringBuffer();
 311                 for(int i = 0; i < s.length(); i++ ) {
 312                                 switch( s.charAt( i ) ) {
 313                                 case 'ö':
 314                         buf.append( "oe" ); break;
 315                                 case 'ä':
 316                         buf.append( "ae" ); break;
 317                                 case 'ü':
 318                         buf.append( "ue" ); break;
 319                                 case 'ã':
 320                         buf.append( "a" ); break;
 321                                 case '´':
 322                                 case '.':
 323                         buf.append( "_" ); break;
 324                                 case ' ':
 325                         if( buf.charAt( buf.length() - 1 ) != '_' ) {
 326                                         buf.append( "_" );
 327                         }
 328                         break;
 329                                 default:
 330                         buf.append( s.charAt( i ) );
 331                                 }
 332                 }
 333                 return buf.toString();
 334         }
 335
 336         /**
 337          * wandelt Sonderzeichen in Quotes um
 338          *
 339          * @return Kovertierter String
 340          */
 341         public static String encodeHtml(String s) {
 342                 StringBuffer buf = new StringBuffer();
 343                 for(int i=0;i < s.length(); i++ ) {
 344
 345                         /** @todo looks inefficient */
 346                         if (s.charAt(i)=='&') {
 347                                 // convert html to xml-parsable representation
 348                                 if( s.indexOf( "&ouml;", i ) == i ) {
 349                                         buf.append( "&#246;" ); i += 5;
 350                                         continue;
 351                                 }
 352                                 if( s.indexOf( "&auml;", i ) == i ) {
 353                                         buf.append( "&#228;" ); i += 5;
 354                                         continue;
 355                                 }
 356                                 if( s.indexOf( "&uuml;", i ) == i ) {
 357                                         buf.append( "&#252;" ); i += 5;
 358                                         continue;
 359                                 }
 360                                 if( s.indexOf( "&Ouml;", i ) == i ) {
 361                                         buf.append( "&#214;" ); i += 5;
 362                                         continue;
 363                                 }
 364                                 if( s.indexOf( "&Auml;", i ) == i ) {
 365                                         buf.append( "&#196;" ); i += 5;
 366                                         continue;
 367                                 }
 368                                 if( s.indexOf( "&Uuml;", i ) == i ) {
 369                                         buf.append( "&#220;" ); i += 5;
 370                                         continue;
 371                                 }
 372                                 if( s.indexOf( "&szlig;", i ) == i ) {
 373                                         buf.append( "&#223;" ); i += 6;
 374                                         continue;
 375                                 }
 376
 377                                 /** @todo should only escape outside of tags */
 378
 379                                 if( s.indexOf( "&quot;", i ) == i ) {
 380                                         buf.append( "&#223;" ); i += 5;
 381                                         continue;
 382         }
 383                                 if( s.indexOf( "&ndash;", i ) == i ) {
 384                                         buf.append( "&#8211;" ); i += 6;
 385                                         continue;
 386         }
 387         if( s.indexOf( "&mdash;", i ) == i ) {
 388                                         buf.append( "&#8212;" ); i += 6;
 389                                         continue;
 390         }
 391         if( s.indexOf( "&ldquo;", i ) == i ) {
 392                                         buf.append( "&#8220;" ); i += 6;
 393                                         continue;
 394         }
 395         if( s.indexOf( "&rdquo;", i ) == i ) {
 396                                         buf.append( "&#8221;" ); i += 6;
 397                                         continue;
 398         }
 399         if( s.indexOf( "&bdquo;", i ) == i ) {
 400                                         buf.append( "&#8222;" ); i += 6;
 401                                         continue;
 402         }
 403
 404         //looks pretty stupid
 405         if( s.indexOf( "&lt;", i ) == i ) {
 406                                         buf.append( "&lt;" ); i += 3;
 407                                         continue;
 408         }
 409         if( s.indexOf( "&gt;", i ) == i ) {
 410                                         buf.append( "&gt;" ); i += 3;
 411                                         continue;
 412         }
 413         if( s.indexOf( "&acute;", i ) == i ) {
 414                                         buf.append( "&acute;" ); i += 6;
 415                                         continue;
 416         }
 417         if( s.indexOf( "&nbsp;", i ) == i ) {
 418                                         buf.append( "&nbsp;" ); i += 5;
 419                                         continue;
 420         }
 421         //has to be the last
 422         if( s.indexOf( "&", i ) == i ) {
 423                                         buf.append( "&#38;" ); i += 0;
 424                                         continue;
 425         }
 426                         }
 427                         // convert umlauts an other special charakters
 428                         switch( s.charAt(i) ) {
 429                                 case 'ö': buf.append( "&#246;" ); break;
 430                                 case 'ä': buf.append( "&#228;" ); break;
 431                                 case 'ü': buf.append( "&#252;" ); break;
 432                                 case 'Ö': buf.append( "&#214;" ); break;
 433                                 case 'Ä': buf.append( "&#196;" ); break;
 434                                 case 'Ü': buf.append( "&#220;" ); break;
 435                                 case 'ß': buf.append( "&#223;" ); break;
 436                                 case 'é': buf.append( "&#233;" ); break;
 437                                 case 'è': buf.append( "&#232;" ); break;
 438                                 case 'á': buf.append( "&#225;" ); break;
 439                                 case 'à': buf.append( "&#224;" ); break;
 440                                 case 'â': buf.append( "&#226;" ); break;
 441                                 case 'ã': buf.append( "&#227;" ); break;
 442                                 case '¬': buf.append( "&#172;" ); break;
 443                                 case '¹': buf.append( "&#185;" ); break;
 444                                 case '²': buf.append( "&#178;" ); break;
 445                                 case '³': buf.append( "&#179;" ); break;
 446                                 case '¼': buf.append( "&#188;" ); break;
 447                                 case '½': buf.append( "&#189;" ); break;
 448                                 case '¾': buf.append( "&#190;" ); break;
 449                                 case '¶': buf.append( "&#182;" ); break;
 450                                 case 'æ': buf.append( "&#230;" ); break;
 451                                 case 'ð': buf.append( "&#240;" ); break;
 452                                 case '|': buf.append( "&#166;" ); break;
 453                                 case '·': buf.append( "&#183;" ); break;
 454                                 case '°': buf.append( "&#176;" ); break;
 455                                 case '§': buf.append( "&#167;" ); break;
 456                                 case 'ø': buf.append( "&#248;" ); break;
 457                                 case 'ç': buf.append( "&#231;" ); break;
 458                                 case '¤': buf.append( "&#164;" ); break;
 459                                 case 'ª': buf.append( "&#170;" ); break;
 460                                 case 'Ç': buf.append( "&#199;" ); break;
 461                                 case 'Ã': buf.append( "&#195;" ); break;
 462                                 case 'Â': buf.append( "&#194;" ); break;
 463                                 case 'Æ': buf.append( "&#198;" ); break;
 464                                 case '©': buf.append( "&#169;" ); break;
 465                                 case '®': buf.append( "&#174;" ); break;
 466                                 case '¥': buf.append( "&#165;" ); break;
 467                                 case 'Þ': buf.append( "&#254;" ); break;
 468                                 case '¯': buf.append( "&#175;" ); break;
 469                                 case 'Ð': buf.append( "&#208;" ); break;
 470                                 case 'º': buf.append( "&#186;" ); break;
 471                                 case '¡': buf.append( "&#161;" ); break;
 472                                 case '£': buf.append( "&#163;" ); break;
 473                                 case '±': buf.append( "&#177;" ); break;
 474                                 case '¿': buf.append( "&#191;" ); break;
 475                                 case 'Ø': buf.append( "&#216;" ); break;
 476                                 case 'Á': buf.append( "&#192;" ); break;
 477                                 case 'À': buf.append( "&#193;" ); break;
 478                                 case 'É': buf.append( "&#200;" ); break;
 479                                 case 'È': buf.append( "&#201;" ); break;
 480                                 case 'ù': buf.append( "&#250;" ); break;
 481                                 case 'ñ': buf.append( "&#241;" ); break;
 482                                 case 'Ñ': buf.append( "&#209;" ); break;
 483                                 case 'µ': buf.append( "&#181;" ); break;
 484                                 case 'Í': buf.append( "&#204;" ); break;
 485                                 case 'Ì': buf.append( "&#205;" ); break;
 486                                 case 'í': buf.append( "&#236;" ); break;
 487                                 case 'ì': buf.append( "&#237;" ); break;
 488                                 case 'î': buf.append( "&#238;" ); break;
 489                                 case 'Î': buf.append( "&#206;" ); break;
 490                                 case 'ó': buf.append( "&#243;" ); break;
 491                                 case 'Ó': buf.append( "&#210;" ); break;
 492                                 case 'ò': buf.append( "&#206;" ); break;
 493                                 case 'Ò': buf.append( "&#211;" ); break;
 494                                 case 'ô': buf.append( "&#244;" ); break;
 495                                 case 'Ô': buf.append( "&#212;" ); break;
 496                                 case 'õ': buf.append( "&#245;" ); break;
 497                                 case 'Õ': buf.append( "&#213;" ); break;
 498                                 case 'ý': buf.append( "&#253;" ); break;
 499                                 case 'Ý': buf.append( "&#221;" ); break;
 500                                 case 'û': buf.append( "&#251;" ); break;
 501                                 case 'Û': buf.append( "&#219;" ); break;
 502                                 case 'ú': buf.append( "&#249;" ); break;
 503                                 case 'Ú': buf.append( "&#217;" ); break;
 504                                 case 'Ù': buf.append( "&#218;" ); break;
 505                                 case 'Ê': buf.append( "&#202;" ); break;
 506                                 case 'ê': buf.append( "&#234;" ); break;
 507                                 case 'å': buf.append( "&#229;" ); break;
 508                                 case 'Å': buf.append( "&#197;" ); break;
 509                                 case 'ë': buf.append( "&#235;" ); break;
 510                                 case 'Ë': buf.append( "&#203;" ); break;
 511                                 case 'ÿ': buf.append( "&#255;" ); break;
 512                                 case 'ï': buf.append( "&#239;" ); break;
 513                                 case 'Ï': buf.append( "&#207;" ); break;
 514                                 case '«': buf.append( "&#171;" ); break;
 515         case '»': buf.append( "&#187;" ); break;
 516         case '\'': buf.append( "&acute;" ); break;
 517         case '\"': buf.append( "&quot;" ); break;
 518         //case '\u8211': buf.append( "&#8211;" ); break;
 519         //case '\u8212': buf.append( "&#8212;" ); break;
 520         //case '\u8220': buf.append( "&#8220;" ); break;
 521         //case '\u8221': buf.append( "&#8221;" ); break;
 522         //case '\u8222': buf.append( "&#8222;" ); break;
 523                                 //case '\"': buf.append( "&#34;" ); break;
 524                                 default: buf.append( s.charAt(i) );
 525                         }
 526
 527                 }
 528                 return buf.toString();
 529         }
 530
 531
 532   public static String decodeHTMLinTags(String s){
 533     StringBuffer buffer = new StringBuffer();
 534     boolean start = false;
 535     boolean stop = false;
 536     int startIndex = 0;
 537     int stopIndex = 0;
 538     int temp = 0;
 539
 540     for(int i=0;i<s.length();i++){
 541       if(s.charAt(i)=='<'){
 542         start = true;
 543         startIndex = i;
 544       } else if(s.charAt(i)=='>'){
 545         stop = true;
 546         stopIndex = i;
 547
 548         if(start && stop){
 549           buffer.append(s.substring(temp,startIndex));
 550           buffer.append(replaceQuot(s.substring(startIndex,stopIndex+1)));
 551           i= temp= stopIndex+1;
 552           start= stop= false;
 553         }
 554       }
 555     }
 556     buffer.append(s.substring(stopIndex+1));
 557     return buffer.toString();
 558   }
 559
 560   public static String replaceQuot(String s) {
 561     StringBuffer buffer = new StringBuffer();
 562     for(int j = 0; j < s.length();j++){
 563       if(s.charAt(j)=='&'){
 564         if(s.indexOf( "&quot;",j) == j) {
 565           buffer.append( "\"" );
 566           j += 5;
 567         }//if
 568       } else {
 569         buffer.append(s.charAt(j));
 570       }//else
 571     }//for
 572     return buffer.toString();
 573   }
 574
 575         /** wandelt Quotes in Sonderzeichen um
 576          */
 577         public static String decodeHtml(String s) {
 578                 StringBuffer buf = new StringBuffer();
 579                 for(int i=0;i < s.length(); i++ ) {
 580                         if( s.indexOf( "&ouml;", i ) == i ) {
 581                                 buf.append( "ö" ); i += 5;
 582                                 continue;
 583                         }
 584                         if( s.indexOf( "&auml;", i ) == i ) {
 585                                 buf.append( "ä" ); i += 5;
 586                                 continue;
 587                         }
 588                         if( s.indexOf( "&uuml;", i ) == i ) {
 589                                 buf.append( "ü" ); i += 5;
 590                                 continue;
 591                         }
 592                         if( s.indexOf( "&Ouml;", i ) == i ) {
 593                                 buf.append( "Ö" ); i += 5;
 594                                 continue;
 595                         }
 596                         if( s.indexOf( "&Auml;", i ) == i ) {
 597                                 buf.append( "Ä" ); i += 5;
 598                                 continue;
 599                         }
 600                         if( s.indexOf( "&Uuml;", i ) == i ) {
 601                                 buf.append( "Ü" ); i += 5;
 602                                 continue;
 603                         }
 604                         if( s.indexOf( "&szlig;", i ) == i ) {
 605                                 buf.append( "ß" ); i += 6;
 606                                 continue;
 607                         }
 608       if( s.indexOf( "&quot;", i ) == i ) {
 609                                 buf.append( "\"" ); i += 5;
 610                                 continue;
 611                         }
 612                         buf.append( s.charAt(i) );
 613                 }
 614                 return buf.toString();
 615         }
 616
 617
 618         /**
 619          * schnellere Variante der String.toLowerCase()-Routine
 620          *
 621          * @return String in Kleinbuchsten
 622          */
 623         public static String toLowerCase(String s) {
 624                 int l = s.length();
 625                 char[] a = new char[l];
 626                 for (int i = 0; i < l; i++)
 627                         a[i] = Character.toLowerCase(s.charAt(i));
 628                 return new String(a);
 629         }
 630
 631                 /**
 632          * Findet <code>element</code> im String-Array <code>array</code>
 633          * @param array
 634          * @param element
 635          * @return Fundstelle als int oder -1
 636          */
 637         public static int indexOf(String[] array, String element) {
 638                 if (array != null)
 639                         for (int i = 0; i < array.length; i++)
 640                                 if (array[i].equals(element))
 641                                         return i;
 642                 return -1;
 643         }
 644
 645         /**
 646          * Testet auf Vorkommen von <code>element</code> in <code>array</code>
 647          * @param array String-Array
 648          * @param element
 649          * @return true wenn <code>element</code> vorkommt, sonst false
 650          */
 651         public static boolean contains(String[] array, String element) {
 652                 return indexOf(array, element) >= 0;
 653         }
 654
 655                 /**
 656          * Ermittelt CRC-Prüfsumme von String <code>s</code>
 657          * @param s
 658          * @return CRC-Prüfsumme
 659          */
 660   public static int getCRC(String s) {
 661                 int h = 0;
 662                 char val[] = s.toCharArray();
 663                 int len = val.length;
 664
 665                 for (int i = 0 ; i < len; i++) {
 666                         h &= 0x7fffffff;
 667                         h = (((h >> 30) | (h << 1)) ^ (val[i]+i));
 668                 }
 669
 670                 return (h << 8) | (len & 0xff);
 671         }
 672
 673                 /**
 674          * Liefert Default-Wert def zurück, wenn String <code>s</code>
 675          * kein Integer ist.
 676          *
 677          * @param s
 678          * @param def
 679          * @return geparster int aus s oder def
 680          */
 681         public static int parseInt(String s, int def) {
 682                 if (s == null) return def;
 683                 try {
 684                         return Integer.parseInt(s);
 685                 } catch (NumberFormatException e) {
 686                         return def;
 687                 }
 688         }
 689
 690         /**
 691          * Liefert Defaultwert def zurück, wenn s nicht zu einem float geparsed werden kann.
 692          * @param s
 693          * @param def
 694          * @return geparster float oder def
 695          */
 696         public static float parseFloat(String s, float def) {
 697                 if (s == null) return def;
 698                 try {
 699                         return new Float(s).floatValue();
 700                 } catch (NumberFormatException e) {
 701                         return def;
 702                 }
 703         }
 704
 705                 /**
 706          * Findet Ende eines Satzes in String <code>text</code>
 707          * @param text
 708          * @param startIndex
 709          * @return index des Satzendes, oder -1
 710          */
 711         public static int findEndOfSentence(String text, int startIndex) {
 712      while (true) {
 713        int i = text.indexOf('.', startIndex);
 714        if (i < 0) return -1;
 715        if (i > 0 && !Character.isDigit(text.charAt(i-1)) &&
 716           (i+1 >= text.length()
 717           || text.charAt(i+1) == ' '
 718           || text.charAt(i+1) == '\n'
 719           || text.charAt(i+1) == '\t'))
 720           return i+1;
 721        startIndex = i+1;
 722      }
 723   }
 724
 725         /**
 726          * Findet Wortende in String <code>text</code> ab <code>startIndex</code>
 727          * @param text
 728          * @param startIndex
 729          * @return Index des Wortendes, oder -1
 730          */
 731         public static int findEndOfWord(String text, int startIndex) {
 732                 int i = text.indexOf(' ', startIndex),
 733                         j = text.indexOf('\n', startIndex);
 734                 if (i < 0) i = text.length();
 735                 if (j < 0) j = text.length();
 736                 return Math.min(i, j);
 737         }
 738
 739         /**
 740          * Diese Routine macht aus links in reinem text browsbare links
 741          * @param text
 742          * @return Konvertierter String
 743          */
 744         public static String makeLinks(String text) {
 745                 int i = 0;
 746                 StringBuffer buf = new StringBuffer(text.length());
 747                 while (true) {
 748                         int j = text.indexOf("http://", i);
 749                         if (j < 0) {
 750                                 buf.append(text.substring(i));
 751                                 break;
 752                         } else {
 753                                 buf.append(text.substring(i, j));
 754                                 int k = findEndOfWord(text,j+7);
 755                                 String url="";
 756                                 if (k<0)        url = text.substring(j);
 757                                 else            url = text.substring(j,k);
 758
 759                                 buf.append("<a href=\042"+url+"\042>"+url+"</a>");
 760                                 //System.out.println("url mark: " + url);
 761                                 i = j+url.length();
 762                         }
 763                 }
 764                 return buf.toString();
 765
 766         }
 767
 768
 769         /**
 770          *  convertNewline2P ist eine regex-routine zum umwandeln von 2 oder mehr newlines (\n)
 771          *  in den html-tag <p>
 772          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 773          */
 774         public static String convertNewline2P(String haystack) {
 775                 try {
 776                         RE regex = new RE("(<br>\r?\n<br>){1,}");
 777                         return regex.substituteAll(haystack,"\n</p><p>");
 778                 } catch(REException ex){
 779                         return null;
 780                 }
 781         }
 782
 783         /**
 784          *  convertNewline2Break ist eine regex-routine zum umwandeln von 1 newline (\n)
 785          *  in den html-tag <br>
 786          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 787          */
 788         public static String convertNewline2Break(String haystack) {
 789                 try {
 790                         RE regex = new RE("(\r?\n){1}");
 791                         return regex.substituteAll(haystack,"$0<br>");
 792                 } catch(REException ex){
 793                         return null;
 794                 }
 795         }
 796
 797         /**
 798          *  createMailLinks wandelt text im email-adressenformat
 799          *  in einen klickbaren link um
 800          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 801          */
 802         public static String createMailLinks(String haystack) {
 803                 try {
 804                         RE regex = new RE("([a-zA-Z0-9_.-]+)@([a-zA-Z0-9_-]+).([a-zA-Z0-9_.-]+)");
 805                         return regex.substituteAll(haystack,"<a href=\"mailto:$0\">$0</a>");
 806                 } catch(REException ex){
 807                         return null;
 808                 }
 809         }
 810
 811
 812         /**
 813          *  createMailLinks wandelt text im email-adressenformat
 814          *  in einen klickbaren link um
 815          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 816          */
 817         public static String createMailLinks(String haystack, String imageRoot, String mailImage) {
 818                 try {
 819                         RE regex = new RE("([a-zA-Z0-9_.-]+)@([a-zA-Z0-9_-]+).([a-zA-Z0-9_.-]+)");
 820                         return regex.substituteAll(haystack,"<img src=\""+imageRoot+"/"+mailImage+"\" border=\"0\"/>&#160;<a href=\"mailto:$0\">$0</a>");
 821                 } catch(REException ex){
 822                         return null;
 823                 }
 824         }
 825
 826
 827         /**
 828          *  createURLLinks wandelt text im url-format
 829          *  in einen klickbaren link um
 830          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 831          */
 832         public static String createURLLinks(String haystack) {
 833                 try {
 834                         //dieser Ausdruck brauch dringend fachliche Beratung
 835                         RE regex = new RE("((https://)|(http://)|(ftp://))+([a-zA-Z0-9_-]+).([a-zA-Z0-9_.:-]+)/([^ \t\r\n<>]+[^ \t\r\n.,<>])");
 836                         return regex.substituteAll(haystack,"<a href=\"$0\">$0</a>");
 837                 } catch(REException ex){
 838                         return null;
 839                 }
 840         }
 841
 842         /**
 843          *  createURLLinks wandelt text im url-format
 844          *  in einen klickbaren link um
 845          *  nur sinnvoll, wenn text nicht im html-format eingegeben
 846          */
 847         public static String createURLLinks(String haystack,String imageRoot,String extImage,String intImage) {
 848                 try {
 849                         //dieser Ausdruck brauch dringend fachliche Beratung
 850                         RE regex = new RE("((https://)|(http://)|(ftp://))+([a-zA-Z0-9_-]+).([a-zA-Z0-9_.:-]+)/?([^ \t\r\n<>]+[^ \t\r\n.,<>])");
 851                         return regex.substituteAll(haystack,"<img src=\""+imageRoot+"/"+extImage+"\" border=\"0\"/>&#160;<a href=\"$0\">$0</a>");
 852                 } catch(REException ex){
 853                         return null;
 854                 }
 855         }
 856
 857         /**
 858          *  deleteForbiddenTags
 859          *  this method deletes all <script>, <body> and <head>-tags
 860          */
 861         public static String deleteForbiddenTags(String haystack) {
 862                 try {
 863                         RE regex = new RE("<[ \t\r\n](.*?)script(.*?)/script(.*?)>",RE.REG_ICASE);
 864                         haystack = regex.substituteAll(haystack,"");
 865                         regex = new RE("<head>(.*?)</head>");
 866                         haystack = regex.substituteAll(haystack,"");
 867                         regex = new RE("<[ \t\r\n/]*body(.*?)>");
 868                         haystack = regex.substituteAll(haystack,"");
 869                         return haystack;
 870                 } catch(REException ex){
 871                         return null;
 872                 }
 873         }
 874
 875         /**
 876          *  createHTML ruft alle regex-methoden zum unwandeln eines nicht
 877          *  htmlcodierten string auf und returnt einen htmlcodierten String
 878          */
 879         public static String createHTML(String content){
 880                 content=convertNewline2Break(content);
 881                 content=convertNewline2P(content);
 882                 content=createMailLinks(content);
 883                 content=createURLLinks(content);
 884                 return content;
 885         }
 886
 887         /**
 888          *  createHTML ruft alle regex-methoden zum unwandeln eines nicht
 889          *  htmlcodierten string auf und returnt einen htmlcodierten String
 890          */
 891         public static String createHTML(String content,String producerDocRoot,String mailImage,String extImage,String intImage){
 892                 content=convertNewline2Break(content);
 893                 content=convertNewline2P(content);
 894                 content=createMailLinks(content,producerDocRoot,mailImage);
 895                 content=createURLLinks(content,producerDocRoot,extImage,intImage);
 896                 return content;
 897         }
 898
 899 }