View Javadoc

    1   /***************************************************************************************
    2    * Copyright (c) Jonas BonŽr, Alexandre Vasseur. All rights reserved.                 *
    3    * http://aspectwerkz.codehaus.org                                                    *
    4    * ---------------------------------------------------------------------------------- *
    5    * The software in this package is published under the terms of the LGPL license      *
    6    * a copy of which has been included with this distribution in the license.txt file.  *
    7    **************************************************************************************/
    8   package org.codehaus.aspectwerkz.util;
    9
    10  import java.util.List;
    11  import java.util.ArrayList;
    12
    13  /***
    14   * Utility methods for strings.
    15   *
    16   * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr </a>
    17   */
    18  public class Strings {
    19      /***
    20       * Private constructor to prevent instantiability.
    21       */
    22      private Strings() {
    23      }
    24
    25      /***
    26       * Removes newline, carriage return and tab characters from a string.
    27       *
    28       * @param toBeEscaped string to escape
    29       * @return the escaped string
    30       */
    31      public static String removeFormattingCharacters(final String toBeEscaped) {
    32          StringBuffer escapedBuffer = new StringBuffer();
    33          for (int i = 0; i < toBeEscaped.length(); i++) {
    34              if ((toBeEscaped.charAt(i) != '\n') && (toBeEscaped.charAt(i) != '\r') && (toBeEscaped.charAt(i) != '\t')) {
    35                  escapedBuffer.append(toBeEscaped.charAt(i));
    36              }
    37          }
    38          String s = escapedBuffer.toString();
    39          return s;//
    40          // Strings.replaceSubString(s, "\"", "")
    41      }
    42
    43      /***
    44       * Replaces all occurences of a substring inside a string.
    45       *
    46       * @param str      the string to search and replace in
    47       * @param oldToken the string to search for
    48       * @param newToken the string to replace newToken
    49       * @return the new string
    50       */
    51      public static String replaceSubString(final String str, final String oldToken, final String newToken) {
    52          return replaceSubString(str, oldToken, newToken, -1);
    53      }
    54
    55      /***
    56       * Replaces all occurences of a substring inside a string.
    57       *
    58       * @param str      the string to search and replace in
    59       * @param oldToken the string to search for
    60       * @param newToken the string to replace newToken
    61       * @param max      maximum number of values to replace (-1 => no maximum)
    62       * @return the new string
    63       */
    64      public static String replaceSubString(final String str, final String oldToken, final String newToken, int max) {
    65          if ((str == null) || (oldToken == null) || (newToken == null) || (oldToken.length() == 0)) {
    66              return str;
    67          }
    68          StringBuffer buf = new StringBuffer(str.length());
    69          int start = 0;
    70          int end = 0;
    71          while ((end = str.indexOf(oldToken, start)) != -1) {
    72              buf.append(str.substring(start, end)).append(newToken);
    73              start = end + oldToken.length();
    74              if (--max == 0) {
    75                  break;
    76              }
    77          }
    78          buf.append(str.substring(start));
    79          return buf.toString();
    80      }
    81
    82      /***
    83       * String split on multicharacter delimiter. <p/>Written by Tim Quinn (tim.quinn@honeywell.com)
    84       *
    85       * @param stringToSplit
    86       * @param delimiter
    87       * @return
    88       */
    89      public static final String[] splitString(String stringToSplit, String delimiter) {
    90          String[] aRet;
    91          int iLast;
    92          int iFrom;
    93          int iFound;
    94          int iRecords;
    95
    96          // return Blank Array if stringToSplit == "")
    97          if (stringToSplit.equals("")) {
    98              return new String[0];
    99          }
    100
    101         // count Field Entries
    102         iFrom = 0;
    103         iRecords = 0;
    104         while (true) {
    105             iFound = stringToSplit.indexOf(delimiter, iFrom);
    106             if (iFound == -1) {
    107                 break;
    108             }
    109             iRecords++;
    110             iFrom = iFound + delimiter.length();
    111         }
    112         iRecords = iRecords + 1;
    113
    114         // populate aRet[]
    115         aRet = new String[iRecords];
    116         if (iRecords == 1) {
    117             aRet[0] = stringToSplit;
    118         } else {
    119             iLast = 0;
    120             iFrom = 0;
    121             iFound = 0;
    122             for (int i = 0; i < iRecords; i++) {
    123                 iFound = stringToSplit.indexOf(delimiter, iFrom);
    124                 if (iFound == -1) { // at End
    125                     aRet[i] = stringToSplit.substring(iLast + delimiter.length(), stringToSplit.length());
    126                 } else if (iFound == 0) { // at Beginning
    127                     aRet[i] = "";
    128                 } else { // somewhere in middle
    129                     aRet[i] = stringToSplit.substring(iFrom, iFound);
    130                 }
    131                 iLast = iFound;
    132                 iFrom = iFound + delimiter.length();
    133             }
    134         }
    135         return aRet;
    136     }
    137
    138     /***
    139      * Parse a method signature or method call signature.
    140      * <br/>Given a call signature like "method(Type t)", extract the method name
    141      * and param type and parameter name: [method, Type, t]
    142      * <br/>Given a signature like "method(X x, Y)", extract the method name
    143      * and param name / param type - but leaving empty String if
    144      * the information is not available: [method, X, x, Y, ""]
    145      *
    146      * @param methodCallSignature
    147      * @return each element (2xp+1 sized) (see doc)
    148      */
    149     public static String[] extractMethodSignature(String methodCallSignature) {
    150         List extracted = new ArrayList();
    151         String methodName = methodCallSignature;
    152         String methodCallDesc = null;
    153         if (methodCallSignature.indexOf("(") > 0) {
    154             methodName = methodName.substring(0, methodCallSignature.indexOf("("));
    155             methodCallDesc =
    156             methodCallSignature.substring(methodCallSignature.indexOf("(") + 1, methodCallSignature.lastIndexOf(")"));
    157         }
    158         extracted.add(methodName);
    159         if (methodCallDesc != null) {
    160             String[] parameters = Strings.splitString(methodCallDesc, ",");
    161             for (int i = 0; i < parameters.length; i++) {
    162                 String[] parameterInfo = Strings.splitString(
    163                         Strings.replaceSubString(
    164                                 parameters[i].trim(),
    165                                 "  ",
    166                                 " "
    167                         ), " "
    168                 );
    169                 extracted.add(parameterInfo[0]);
    170                 extracted.add((parameterInfo.length > 1) ? parameterInfo[1] : "");
    171             }
    172         }
    173         return (String[]) extracted.toArray(new String[]{});
    174     }
    175
    176     public static boolean isNullOrEmpty(String s) {
    177         return (s == null) ? true : (s.length() <= 0);
    178     }
    179 }