net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/corext/util/Strings.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.corext.util;
  12
  13 import org.eclipse.jface.text.BadLocationException;
  14 import org.eclipse.jface.text.DefaultLineTracker;
  15 import org.eclipse.jface.text.ILineTracker;
  16 import org.eclipse.jface.text.IRegion;
  17
  18 /**
  19  * Helper class to provide String manipulation functions not available in
  20  * standard JDK.
  21  */
  22 public class Strings {
  23
  24         /**
  25          * Indent char is a space char but not a line delimiters.
  26          * <code>== Character.isWhitespace(ch) && ch != '\n' && ch != '\r'</code>
  27          */
  28         public static boolean isIndentChar(char ch) {
  29                 return Character.isWhitespace(ch) && !isLineDelimiterChar(ch);
  30         }
  31
  32         /**
  33          * tests if a char is lower case. Fix for 26529
  34          */
  35         public static boolean isLowerCase(char ch) {
  36                 return Character.toLowerCase(ch) == ch;
  37         }
  38
  39         /**
  40          * Line delimiter chars are '\n' and '\r'.
  41          */
  42         public static boolean isLineDelimiterChar(char ch) {
  43                 return ch == '\n' || ch == '\r';
  44         }
  45
  46         public static String removeNewLine(String message) {
  47                 StringBuffer result = new StringBuffer();
  48                 int current = 0;
  49                 int index = message.indexOf('\n', 0);
  50                 while (index != -1) {
  51                         result.append(message.substring(current, index));
  52                         if (current < index && index != 0)
  53                                 result.append(' ');
  54                         current = index + 1;
  55                         index = message.indexOf('\n', current);
  56                 }
  57                 result.append(message.substring(current));
  58                 return result.toString();
  59         }
  60
  61         /**
  62          * Converts the given string into an array of lines. The lines don't contain
  63          * any line delimiter characters.
  64          *
  65          * @return the string converted into an array of strings. Returns <code>
  66          *      null</code>
  67          *         if the input string can't be converted in an array of lines.
  68          */
  69         public static String[] convertIntoLines(String input) {
  70                 try {
  71                         ILineTracker tracker = new DefaultLineTracker();
  72                         tracker.set(input);
  73                         int size = tracker.getNumberOfLines();
  74                         String result[] = new String[size];
  75                         for (int i = 0; i < size; i++) {
  76                                 IRegion region = tracker.getLineInformation(i);
  77                                 int offset = region.getOffset();
  78                                 result[i] = input
  79                                                 .substring(offset, offset + region.getLength());
  80                         }
  81                         return result;
  82                 } catch (BadLocationException e) {
  83                         return null;
  84                 }
  85         }
  86
  87         /**
  88          * Returns <code>true</code> if the given string only consists of white
  89          * spaces according to Java. If the string is empty, <code>true
  90          * </code> is
  91          * returned.
  92          *
  93          * @return <code>true</code> if the string only consists of white spaces;
  94          *         otherwise <code>false</code> is returned
  95          *
  96          * @see java.lang.Character#isWhitespace(char)
  97          */
  98         public static boolean containsOnlyWhitespaces(String s) {
  99                 int size = s.length();
 100                 for (int i = 0; i < size; i++) {
 101                         if (!Character.isWhitespace(s.charAt(i)))
 102                                 return false;
 103                 }
 104                 return true;
 105         }
 106
 107         /**
 108          * Removes leading tabs and spaces from the given string. If the string
 109          * doesn't contain any leading tabs or spaces then the string itself is
 110          * returned.
 111          */
 112         public static String trimLeadingTabsAndSpaces(String line) {
 113                 int size = line.length();
 114                 int start = size;
 115                 for (int i = 0; i < size; i++) {
 116                         char c = line.charAt(i);
 117                         if (!isIndentChar(c)) {
 118                                 start = i;
 119                                 break;
 120                         }
 121                 }
 122                 if (start == 0)
 123                         return line;
 124                 else if (start == size)
 125                         return ""; //$NON-NLS-1$
 126                 else
 127                         return line.substring(start);
 128         }
 129
 130         public static String trimTrailingTabsAndSpaces(String line) {
 131                 int size = line.length();
 132                 int end = size;
 133                 for (int i = size - 1; i >= 0; i--) {
 134                         char c = line.charAt(i);
 135                         if (isIndentChar(c)) {
 136                                 end = i;
 137                         } else {
 138                                 break;
 139                         }
 140                 }
 141                 if (end == size)
 142                         return line;
 143                 else if (end == 0)
 144                         return ""; //$NON-NLS-1$
 145                 else
 146                         return line.substring(0, end);
 147         }
 148
 149         /**
 150          * Returns the indent of the given string.
 151          *
 152          * @param line
 153          *            the text line
 154          * @param tabWidth
 155          *            the width of the '\t' character.
 156          */
 157         public static int computeIndent(String line, int tabWidth) {
 158                 int result = 0;
 159                 int blanks = 0;
 160                 int size = line.length();
 161                 for (int i = 0; i < size; i++) {
 162                         char c = line.charAt(i);
 163                         if (c == '\t') {
 164                                 result++;
 165                                 blanks = 0;
 166                         } else if (isIndentChar(c)) {
 167                                 blanks++;
 168                                 if (blanks == tabWidth) {
 169                                         result++;
 170                                         blanks = 0;
 171                                 }
 172                         } else {
 173                                 return result;
 174                         }
 175                 }
 176                 return result;
 177         }
 178
 179         /**
 180          * Removes the given number of idents from the line. Asserts that the given
 181          * line has the requested number of indents. If
 182          * <code>indentsToRemove <= 0</code> the line is returned.
 183          */
 184         public static String trimIndent(String line, int indentsToRemove,
 185                         int tabWidth) {
 186                 if (line == null || indentsToRemove <= 0)
 187                         return line;
 188
 189                 int start = 0;
 190                 int indents = 0;
 191                 int blanks = 0;
 192                 int size = line.length();
 193                 for (int i = 0; i < size; i++) {
 194                         char c = line.charAt(i);
 195                         if (c == '\t') {
 196                                 indents++;
 197                                 blanks = 0;
 198                         } else if (isIndentChar(c)) {
 199                                 blanks++;
 200                                 if (blanks == tabWidth) {
 201                                         indents++;
 202                                         blanks = 0;
 203                                 }
 204                         } else {
 205                                 // Assert.isTrue(false, "Line does not have requested number of
 206                                 // indents"); //$NON-NLS-1$
 207                                 start = i + 1;
 208                                 break;
 209                         }
 210                         if (indents == indentsToRemove) {
 211                                 start = i + 1;
 212                                 break;
 213                         }
 214                 }
 215                 if (start == size)
 216                         return ""; //$NON-NLS-1$
 217                 else
 218                         return line.substring(start);
 219         }
 220
 221         /**
 222          * Removes all leading indents from the given line. If the line doesn't
 223          * contain any indents the line itself is returned.
 224          */
 225         public static String trimIndents(String s, int tabWidth) {
 226                 int indent = computeIndent(s, tabWidth);
 227                 if (indent == 0)
 228                         return s;
 229                 return trimIndent(s, indent, tabWidth);
 230         }
 231
 232         /**
 233          * Removes the common number of indents from all lines. If a line only
 234          * consists out of white space it is ignored.
 235          */
 236         public static void trimIndentation(String[] lines, int tabWidth) {
 237                 trimIndentation(lines, tabWidth, true);
 238         }
 239
 240         /**
 241          * Removes the common number of indents from all lines. If a line only
 242          * consists out of white space it is ignored. If <code>
 243          * considerFirstLine</code>
 244          * is false the first line will be ignored.
 245          */
 246         public static void trimIndentation(String[] lines, int tabWidth,
 247                         boolean considerFirstLine) {
 248                 String[] toDo = new String[lines.length];
 249                 // find indentation common to all lines
 250                 int minIndent = Integer.MAX_VALUE; // very large
 251                 for (int i = considerFirstLine ? 0 : 1; i < lines.length; i++) {
 252                         String line = lines[i];
 253                         if (containsOnlyWhitespaces(line))
 254                                 continue;
 255                         toDo[i] = line;
 256                         int indent = computeIndent(line, tabWidth);
 257                         if (indent < minIndent) {
 258                                 minIndent = indent;
 259                         }
 260                 }
 261
 262                 if (minIndent > 0) {
 263                         // remove this indent from all lines
 264                         for (int i = considerFirstLine ? 0 : 1; i < toDo.length; i++) {
 265                                 String s = toDo[i];
 266                                 if (s != null)
 267                                         lines[i] = trimIndent(s, minIndent, tabWidth);
 268                                 else {
 269                                         String line = lines[i];
 270                                         int indent = computeIndent(line, tabWidth);
 271                                         if (indent > minIndent)
 272                                                 lines[i] = trimIndent(line, minIndent, tabWidth);
 273                                         else
 274                                                 lines[i] = trimLeadingTabsAndSpaces(line);
 275                                 }
 276                         }
 277                 }
 278         }
 279
 280         public static String getIndentString(String line, int tabWidth) {
 281                 int size = line.length();
 282                 int end = 0;
 283                 int blanks = 0;
 284                 for (int i = 0; i < size; i++) {
 285                         char c = line.charAt(i);
 286                         if (c == '\t') {
 287                                 end = i + 1;
 288                                 blanks = 0;
 289                         } else if (isIndentChar(c)) {
 290                                 blanks++;
 291                                 if (blanks == tabWidth) {
 292                                         end = i + 1;
 293                                         blanks = 0;
 294                                 }
 295                         } else {
 296                                 break;
 297                         }
 298                 }
 299                 if (end == 0)
 300                         return ""; //$NON-NLS-1$
 301                 else if (end == size)
 302                         return line;
 303                 else
 304                         return line.substring(0, end);
 305         }
 306
 307         public static String[] removeTrailingEmptyLines(String[] sourceLines) {
 308                 int lastNonEmpty = findLastNonEmptyLineIndex(sourceLines);
 309                 String[] result = new String[lastNonEmpty + 1];
 310                 for (int i = 0; i < result.length; i++) {
 311                         result[i] = sourceLines[i];
 312                 }
 313                 return result;
 314         }
 315
 316         private static int findLastNonEmptyLineIndex(String[] sourceLines) {
 317                 for (int i = sourceLines.length - 1; i >= 0; i--) {
 318                         if (!sourceLines[i].trim().equals(""))//$NON-NLS-1$
 319                                 return i;
 320                 }
 321                 return -1;
 322         }
 323
 324         /**
 325          * Change the indent of, possible muti-line, code range. The current indent
 326          * is removed, a new indent added. The first line of the code will not be
 327          * changed. (It is considered to have no indent as it might start in the
 328          * middle of a line)
 329          */
 330         public static String changeIndent(String code, int codeIndentLevel,
 331                         int tabWidth, String newIndent, String lineDelim) {
 332                 try {
 333                         ILineTracker tracker = new DefaultLineTracker();
 334                         tracker.set(code);
 335                         int nLines = tracker.getNumberOfLines();
 336                         if (nLines == 1) {
 337                                 return code;
 338                         }
 339
 340                         StringBuffer buf = new StringBuffer();
 341
 342                         for (int i = 0; i < nLines; i++) {
 343                                 IRegion region = tracker.getLineInformation(i);
 344                                 int start = region.getOffset();
 345                                 int end = start + region.getLength();
 346                                 String line = code.substring(start, end);
 347
 348                                 if (i == 0) { // no indent for first line (contained in the
 349                                                                 // formatted string)
 350                                         buf.append(line);
 351                                 } else { // no new line after last line
 352                                         buf.append(lineDelim);
 353                                         buf.append(newIndent);
 354                                         buf.append(trimIndent(line, codeIndentLevel, tabWidth));
 355                                 }
 356                         }
 357                         return buf.toString();
 358                 } catch (BadLocationException e) {
 359                         // can not happen
 360                         return code;
 361                 }
 362         }
 363
 364         /**
 365          * Concatenate the given strings into one strings using the passed line
 366          * delimiter as a delimiter. No delimiter is added to the last line.
 367          */
 368         public static String concatenate(String[] lines, String delimiter) {
 369                 StringBuffer buffer = new StringBuffer();
 370                 for (int i = 0; i < lines.length; i++) {
 371                         if (i > 0)
 372                                 buffer.append(delimiter);
 373                         buffer.append(lines[i]);
 374                 }
 375                 return buffer.toString();
 376         }
 377
 378         public static boolean equals(String s, char[] c) {
 379                 if (s.length() != c.length)
 380                         return false;
 381
 382                 for (int i = c.length; --i >= 0;)
 383                         if (s.charAt(i) != c[i])
 384                                 return false;
 385                 return true;
 386         }
 387 }