List of usage examples for org.eclipse.jdt.internal.compiler.parser ScannerHelper toLowerCase
public static char toLowerCase(char c)
From source file:com.codenvy.ide.ext.java.server.internal.core.search.StringOperation.java
License:Open Source License
/** * Answers all the regions in a given name matching a given <i>pattern</i> * pattern (e.g. "H*M??").//from w w w.j a va2 s . co m * </p><p> * Each of these regions is made of its starting index and its length in the given * name. They are all concatenated in a single array of <code>int</code> * which therefore always has an even length. * </p><p> * Note that each region is disjointed from the following one.<br> * E.g. if the regions are <code>{ start1, length1, start2, length2 }</code>, * then <code>start1+length1</code> will always be smaller than * <code>start2</code>. * </p><p> * <pre> * Examples: * <ol> * <li> pattern = "N???Po*Ex?eption" * name = NullPointerException * result: { 0, 1, 4, 2, 11, 2, 14, 6 }</li> * <li> pattern = "Ha*M*ent*" * name = "HashMapEntry" * result: { 0, 2, 4, 1, 7, 3 }</li> * </ol></pre> *</p> * @see org.eclipse.jdt.core.compiler.CharOperation#match(char[], char[], boolean) for more details on the * pattern match behavior * * @param pattern the given pattern * @param patternStart the given pattern start * @param patternEnd the given pattern end * @param name the given name * @param nameStart the given name start * @param nameEnd the given name end * @param isCaseSensitive flag to know if the matching should be case sensitive * @return an array of <code>int</code> having two slots per returned * regions (first one is the starting index of the region and the second * one the length of the region).<br> * Note that it may be <code>null</code> if the given name does not match * the pattern * @since 3.5 */ public static final int[] getPatternMatchingRegions(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean isCaseSensitive) { /* !!!!!!!!!! WARNING !!!!!!!!!! * The algorithm used in this method has been fully inspired from * CharOperation#match(char[], int, int, char[], int, int, boolean). * * So, if any change needs to be applied in the algorithm, do NOT forget * to backport it in the CharOperation method! */ if (name == null) return null; // null name cannot match if (pattern == null) { // null pattern cannot match any region // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=264816 return EMPTY_REGIONS; } int iPattern = patternStart; int iName = nameStart; // init segments parts if (patternEnd < 0) patternEnd = pattern.length(); if (nameEnd < 0) nameEnd = name.length(); int questions = 0; int parts = 0; char previous = 0; for (int i = patternStart; i < patternEnd; i++) { char ch = pattern.charAt(i); switch (ch) { case '?': questions++; break; case '*': break; default: switch (previous) { case 0: case '?': case '*': parts++; break; } } previous = ch; } if (parts == 0) { if (questions <= (nameEnd - nameStart)) return EMPTY_REGIONS; return null; } int[] segments = new int[parts * 2]; /* check first segment */ int count = 0; int start = iName; char patternChar = 0; previous = 0; while ((iPattern < patternEnd) && (patternChar = pattern.charAt(iPattern)) != '*') { if (iName == nameEnd) return null; if (patternChar == '?') { switch (previous) { case 0: case '?': break; default: segments[count++] = start; segments[count++] = iPattern - start; break; } } else { if (isCaseSensitive) { if (patternChar != name.charAt(iName)) { return null; } } else if (ScannerHelper.toLowerCase(patternChar) != ScannerHelper .toLowerCase(name.charAt(iName))) { return null; } switch (previous) { case 0: case '?': start = iPattern; break; } } iName++; iPattern++; previous = patternChar; } /* check sequence of star+segment */ int segmentStart; if (patternChar == '*') { if (iPattern > 0 && previous != '?') { segments[count++] = start; segments[count++] = iName - start; start = iName; } segmentStart = ++iPattern; // skip star } else { if (iName == nameEnd) { if (count == (parts * 2)) return segments; int end = patternEnd; if (previous == '?') { // last char was a '?' => purge all trailing '?' while (pattern.charAt(--end - 1) == '?') { if (end == start) { return new int[] { patternStart, patternEnd - patternStart }; } } } return new int[] { start, end - start }; } return null; } int prefixStart = iName; int previousCount = count; previous = patternChar; char previousSegment = patternChar; checkSegment: while (iName < nameEnd) { if (iPattern == patternEnd) { iPattern = segmentStart; // mismatch - restart current segment iName = ++prefixStart; previous = previousSegment; continue checkSegment; } /* segment is ending */ if ((patternChar = pattern.charAt(iPattern)) == '*') { segmentStart = ++iPattern; // skip star if (segmentStart == patternEnd) { if (count < (parts * 2)) { segments[count++] = start; segments[count++] = iName - start; } return segments; } switch (previous) { case '*': case '?': break; default: segments[count++] = start; segments[count++] = iName - start; break; } prefixStart = iName; start = prefixStart; previous = patternChar; previousSegment = patternChar; continue checkSegment; } /* check current name character */ previousCount = count; if (patternChar == '?') { switch (previous) { case '*': case '?': break; default: segments[count++] = start; segments[count++] = iName - start; break; } } else { boolean mismatch; if (isCaseSensitive) { mismatch = name.charAt(iName) != patternChar; } else { mismatch = ScannerHelper.toLowerCase(name.charAt(iName)) != ScannerHelper .toLowerCase(patternChar); } if (mismatch) { iPattern = segmentStart; // mismatch - restart current segment iName = ++prefixStart; start = prefixStart; count = previousCount; previous = previousSegment; continue checkSegment; } switch (previous) { case '?': start = iName; break; } } iName++; iPattern++; previous = patternChar; } if ((segmentStart == patternEnd) || (iName == nameEnd && iPattern == patternEnd) || (iPattern == patternEnd - 1 && pattern.charAt(iPattern) == '*')) { if (count < (parts * 2)) { segments[count++] = start; segments[count++] = iName - start; } return segments; } return null; }
From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java
License:Open Source License
/** Returns true iff str.toLowerCase().endsWith(end.toLowerCase()) implementation is not creating extra strings. */ public final static boolean endsWithIgnoreCase(String str, String end) { int strLength = str == null ? 0 : str.length(); int endLength = end == null ? 0 : end.length(); // return false if the string is smaller than the end. if (endLength > strLength) return false; // return false if any character of the end are // not the same in lower case. for (int i = 1; i <= endLength; i++) { if (ScannerHelper.toLowerCase(end.charAt(endLength - i)) != ScannerHelper .toLowerCase(str.charAt(strLength - i))) return false; }/*from w ww.ja va 2 s. c o m*/ return true; }