Refactory
[phpeclipse.git] / net.sourceforge.phpeclipse.externaltools / src / net / sourceforge / phpdt / externaltools / model / StringMatcher.java
index e4c530b..797be51 100644 (file)
@@ -1,74 +1,90 @@
 package net.sourceforge.phpdt.externaltools.model;
+
 /**********************************************************************
-Copyright (c) 2000, 2002 IBM Corp.  All rights reserved.
-This file is made available under the terms of the Common Public License v1.0
-which accompanies this distribution, and is available at
-http://www.eclipse.org/legal/cpl-v10.html
-**********************************************************************/
+ Copyright (c) 2000, 2002 IBM Corp.  All rights reserved.
+ This file is made available under the terms of the Common Public License v1.0
+ which accompanies this distribution, and is available at
+ http://www.eclipse.org/legal/cpl-v10.html
+ **********************************************************************/
 
 import java.util.Vector;
 
 /**
  * Copied from net.sourceforge.phpdt.internal.ui.util.StringMatcher
  * 
- *  A string pattern matcher, suppporting * and ? wildcards.
+ * A string pattern matcher, suppporting * and ? wildcards.
  */
 public class StringMatcher {
        protected String fPattern;
+
        protected int fLength; // pattern length
+
        protected boolean fIgnoreWildCards;
+
        protected boolean fIgnoreCase;
+
        protected boolean fHasLeadingStar;
+
        protected boolean fHasTrailingStar;
-       protected String fSegments[]; //the given pattern is split into * separated segments
 
-       /* boundary value beyond which we don't need to search in the text */
-       protected int fBound= 0;
+       protected String fSegments[]; // the given pattern is split into *
+                                                                       // separated segments
 
+       /* boundary value beyond which we don't need to search in the text */
+       protected int fBound = 0;
 
-       protected static final char fSingleWildCard= '\u0000';
+       protected static final char fSingleWildCard = '\u0000';
 
        public static class Position {
-               int start; //inclusive
-               int end; //exclusive
+               int start; // inclusive
+
+               int end; // exclusive
+
                public Position(int start, int end) {
-                       this.start= start;
-                       this.end= end;
+                       this.start = start;
+                       this.end = end;
                }
+
                public int getStart() {
                        return start;
                }
+
                public int getEnd() {
                        return end;
                }
        }
+
        /**
         * StringMatcher constructor takes in a String object that is a simple
-        * pattern which may contain �*� for 0 and many characters and
-        * �?� for exactly one character.
-        *
-        * Literal '*' and '?' characters must be escaped in the pattern
-        * e.g., "\*" means literal "*", etc.
-        *
+        * pattern which may contain �*� for 0 and many characters and �?� for
+        * exactly one character.
+        * 
+        * Literal '*' and '?' characters must be escaped in the pattern e.g., "\*"
+        * means literal "*", etc.
+        * 
         * Escaping any other character (including the escape character itself),
-        * just results in that character in the pattern.
-        * e.g., "\a" means "a" and "\\" means "\"
-        *
+        * just results in that character in the pattern. e.g., "\a" means "a" and
+        * "\\" means "\"
+        * 
         * If invoking the StringMatcher with string literals in Java, don't forget
         * escape characters are represented by "\\".
-        *
-        * @param pattern the pattern to match text against
-        * @param ignoreCase if true, case is ignored
-        * @param ignoreWildCards if true, wild cards and their escape sequences are ignored
-        *                (everything is taken literally).
+        * 
+        * @param pattern
+        *            the pattern to match text against
+        * @param ignoreCase
+        *            if true, case is ignored
+        * @param ignoreWildCards
+        *            if true, wild cards and their escape sequences are ignored
+        *            (everything is taken literally).
         */
-       public StringMatcher(String pattern, boolean ignoreCase, boolean ignoreWildCards) {
+       public StringMatcher(String pattern, boolean ignoreCase,
+                       boolean ignoreWildCards) {
                if (pattern == null)
                        throw new IllegalArgumentException();
-               fIgnoreCase= ignoreCase;
-               fIgnoreWildCards= ignoreWildCards;
-               fPattern= pattern;
-               fLength= pattern.length();
+               fIgnoreCase = ignoreCase;
+               fIgnoreWildCards = ignoreWildCards;
+               fPattern = pattern;
+               fLength = pattern.length();
 
                if (fIgnoreWildCards) {
                        parseNoWildCards();
@@ -76,8 +92,10 @@ public class StringMatcher {
                        parseWildCards();
                }
        }
+
        /**
-        * Find the first occurrence of the pattern between <code>start</code)(inclusive)
+        * Find the first occurrence of the pattern between
+        * <code>start</code)(inclusive)
         * and <code>end</code>(exclusive).
         * @param <code>text</code>, the String object to search in
         * @param <code>start</code>, the starting index of the search range, inclusive
@@ -93,56 +111,64 @@ public class StringMatcher {
                if (text == null)
                        throw new IllegalArgumentException();
 
-               int tlen= text.length();
+               int tlen = text.length();
                if (start < 0)
-                       start= 0;
+                       start = 0;
                if (end > tlen)
-                       end= tlen;
-               if (end < 0 ||start >= end )
+                       end = tlen;
+               if (end < 0 || start >= end)
                        return null;
                if (fLength == 0)
                        return new Position(start, start);
                if (fIgnoreWildCards) {
-                       int x= posIn(text, start, end);
+                       int x = posIn(text, start, end);
                        if (x < 0)
                                return null;
-                       return new Position(x, x+fLength);
+                       return new Position(x, x + fLength);
                }
 
-               int segCount= fSegments.length;
-               if (segCount == 0)//pattern contains only '*'(s)
-                       return new Position (start, end);
+               int segCount = fSegments.length;
+               if (segCount == 0)// pattern contains only '*'(s)
+                       return new Position(start, end);
 
-               int curPos= start;
-               int matchStart= -1;
+               int curPos = start;
+               int matchStart = -1;
                int i;
-               for (i= 0; i < segCount && curPos < end; ++i) {
-                       String current= fSegments[i];
-                       int nextMatch= regExpPosIn(text, curPos, end, current);
-                       if (nextMatch < 0 )
+               for (i = 0; i < segCount && curPos < end; ++i) {
+                       String current = fSegments[i];
+                       int nextMatch = regExpPosIn(text, curPos, end, current);
+                       if (nextMatch < 0)
                                return null;
-                       if(i == 0)
-                               matchStart= nextMatch;
-                       curPos= nextMatch + current.length();
+                       if (i == 0)
+                               matchStart = nextMatch;
+                       curPos = nextMatch + current.length();
                }
                if (i < segCount)
                        return null;
                return new Position(matchStart, curPos);
        }
+
        /**
         * match the given <code>text</code> with the pattern
+        * 
         * @return true if matched eitherwise false
         * @param <code>text</code>, a String object
         */
        public boolean match(String text) {
                return match(text, 0, text.length());
        }
+
        /**
-        * Given the starting (inclusive) and the ending (exclusive) positions in the
-        * <code>text</code>, determine if the given substring matches with aPattern
+        * Given the starting (inclusive) and the ending (exclusive) positions in
+        * the <code>text</code>, determine if the given substring matches with
+        * aPattern
+        * 
         * @return true if the specified portion of the text matches the pattern
-        * @param String <code>text</code>, a String object that contains the substring to match
-        * @param int <code>start<code> marks the starting position (inclusive) of the substring
+        * @param String
+        *            <code>text</code>, a String object that contains the
+        *            substring to match
+        * @param int
+        *            <code>start<code> marks the starting position (inclusive) of the substring
         * @param int <code>end<code> marks the ending index (exclusive) of the substring
         */
        public boolean match(String text, int start, int end) {
@@ -153,123 +179,135 @@ public class StringMatcher {
                        return false;
 
                if (fIgnoreWildCards)
-                       return (end - start == fLength) && fPattern.regionMatches(fIgnoreCase, 0, text, start, fLength);
-               int segCount= fSegments.length;
-               if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar))  // pattern contains only '*'(s)
+                       return (end - start == fLength)
+                                       && fPattern.regionMatches(fIgnoreCase, 0, text, start,
+                                                       fLength);
+               int segCount = fSegments.length;
+               if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar)) // pattern
+                                                                                                                                       // contains
+                                                                                                                                       // only
+                                                                                                                                       // '*'(s)
                        return true;
                if (start == end)
                        return fLength == 0;
                if (fLength == 0)
                        return start == end;
 
-               int tlen= text.length();
+               int tlen = text.length();
                if (start < 0)
-                       start= 0;
+                       start = 0;
                if (end > tlen)
-                       end= tlen;
+                       end = tlen;
 
-               int tCurPos= start;
-               int bound= end - fBound;
-               if ( bound < 0)
+               int tCurPos = start;
+               int bound = end - fBound;
+               if (bound < 0)
                        return false;
-               int i=0;
-               String current= fSegments[i];
-               int segLength= current.length();
+               int i = 0;
+               String current = fSegments[i];
+               int segLength = current.length();
 
                /* process first segment */
-               if (!fHasLeadingStar){
-                       if(!regExpRegionMatches(text, start, current, 0, segLength)) {
+               if (!fHasLeadingStar) {
+                       if (!regExpRegionMatches(text, start, current, 0, segLength)) {
                                return false;
                        } else {
                                ++i;
-                               tCurPos= tCurPos + segLength;
+                               tCurPos = tCurPos + segLength;
                        }
                }
 
                /* process middle segments */
                while (i < segCount) {
-                       current= fSegments[i];
+                       current = fSegments[i];
                        int currentMatch;
-                       int k= current.indexOf(fSingleWildCard);
+                       int k = current.indexOf(fSingleWildCard);
                        if (k < 0) {
-                               currentMatch= textPosIn(text, tCurPos, end, current);
+                               currentMatch = textPosIn(text, tCurPos, end, current);
                                if (currentMatch < 0)
                                        return false;
                        } else {
-                               currentMatch= regExpPosIn(text, tCurPos, end, current);
+                               currentMatch = regExpPosIn(text, tCurPos, end, current);
                                if (currentMatch < 0)
                                        return false;
                        }
-                       tCurPos= currentMatch + current.length();
+                       tCurPos = currentMatch + current.length();
                        i++;
                }
 
                /* process final segment */
                if (!fHasTrailingStar && tCurPos != end) {
-                       int clen= current.length();
+                       int clen = current.length();
                        return regExpRegionMatches(text, end - clen, current, 0, clen);
                }
-               return i == segCount ;
+               return i == segCount;
        }
+
        /**
-        * This method parses the given pattern into segments seperated by wildcard '*' characters.
-        * Since wildcards are not being used in this case, the pattern consists of a single segment.
+        * This method parses the given pattern into segments seperated by wildcard
+        * '*' characters. Since wildcards are not being used in this case, the
+        * pattern consists of a single segment.
         */
        private void parseNoWildCards() {
-               fSegments= new String[1];
-               fSegments[0]= fPattern;
-               fBound= fLength;
+               fSegments = new String[1];
+               fSegments[0] = fPattern;
+               fBound = fLength;
        }
+
        /**
-        * Parses the given pattern into segments seperated by wildcard '*' characters.
-        * @param p, a String object that is a simple regular expression with �*� and/or �?�
+        * Parses the given pattern into segments seperated by wildcard '*'
+        * characters.
+        * 
+        * @param p,
+        *            a String object that is a simple regular expression with �*�
+        *            and/or �?�
         */
        private void parseWildCards() {
-               if(fPattern.startsWith("*"))//$NON-NLS-1$
-                       fHasLeadingStar= true;
-               if(fPattern.endsWith("*")) {//$NON-NLS-1$
+               if (fPattern.startsWith("*"))//$NON-NLS-1$
+                       fHasLeadingStar = true;
+               if (fPattern.endsWith("*")) {//$NON-NLS-1$
                        /* make sure it's not an escaped wildcard */
                        if (fLength > 1 && fPattern.charAt(fLength - 2) != '\\') {
-                               fHasTrailingStar= true;
+                               fHasTrailingStar = true;
                        }
                }
 
-               Vector temp= new Vector();
+               Vector temp = new Vector();
 
-               int pos= 0;
-               StringBuffer buf= new StringBuffer();
+               int pos = 0;
+               StringBuffer buf = new StringBuffer();
                while (pos < fLength) {
-                       char c= fPattern.charAt(pos++);
+                       char c = fPattern.charAt(pos++);
                        switch (c) {
-                               case '\\':
-                                       if (pos >= fLength) {
-                                               buf.append(c);
+                       case '\\':
+                               if (pos >= fLength) {
+                                       buf.append(c);
+                               } else {
+                                       char next = fPattern.charAt(pos++);
+                                       /* if it's an escape sequence */
+                                       if (next == '*' || next == '?' || next == '\\') {
+                                               buf.append(next);
                                        } else {
-                                               char next= fPattern.charAt(pos++);
-                                               /* if it's an escape sequence */
-                                               if (next == '*' || next == '?' || next == '\\') {
-                                                       buf.append(next);
-                                               } else {
-                                                       /* not an escape sequence, just insert literally */
-                                                       buf.append(c);
-                                                       buf.append(next);
-                                               }
+                                               /* not an escape sequence, just insert literally */
+                                               buf.append(c);
+                                               buf.append(next);
                                        }
+                               }
                                break;
-                               case '*':
-                                       if (buf.length() > 0) {
-                                               /* new segment */
-                                               temp.addElement(buf.toString());
-                                               fBound += buf.length();
-                                               buf.setLength(0);
-                                       }
+                       case '*':
+                               if (buf.length() > 0) {
+                                       /* new segment */
+                                       temp.addElement(buf.toString());
+                                       fBound += buf.length();
+                                       buf.setLength(0);
+                               }
                                break;
-                               case '?':
-                                       /* append special character representing single match wildcard */
-                                       buf.append(fSingleWildCard);
+                       case '?':
+                               /* append special character representing single match wildcard */
+                               buf.append(fSingleWildCard);
                                break;
-                               default:
-                                       buf.append(c);
+                       default:
+                               buf.append(c);
                        }
                }
 
@@ -279,63 +317,77 @@ public class StringMatcher {
                        fBound += buf.length();
                }
 
-               fSegments= new String[temp.size()];
+               fSegments = new String[temp.size()];
                temp.copyInto(fSegments);
        }
+
        /**
         * @param <code>text</code>, a string which contains no wildcard
-        * @param <code>start</code>, the starting index in the text for search, inclusive
+        * @param <code>start</code>, the starting index in the text for search,
+        *            inclusive
         * @param <code>end</code>, the stopping point of search, exclusive
-        * @return the starting index in the text of the pattern , or -1 if not found
+        * @return the starting index in the text of the pattern , or -1 if not
+        *         found
         */
-       protected int posIn(String text, int start, int end) {//no wild card in pattern
-               int max= end - fLength;
+       protected int posIn(String text, int start, int end) {// no wild card in
+                                                                                                                       // pattern
+               int max = end - fLength;
 
                if (!fIgnoreCase) {
-                       int i= text.indexOf(fPattern, start);
+                       int i = text.indexOf(fPattern, start);
                        if (i == -1 || i > max)
                                return -1;
                        return i;
                }
 
-               for (int i= start; i <= max; ++i) {
+               for (int i = start; i <= max; ++i) {
                        if (text.regionMatches(true, i, fPattern, 0, fLength))
                                return i;
                }
 
                return -1;
        }
+
        /**
-        * @param <code>text</code>, a simple regular expression that may only contain '?'(s)
-        * @param <code>start</code>, the starting index in the text for search, inclusive
+        * @param <code>text</code>, a simple regular expression that may only
+        *            contain '?'(s)
+        * @param <code>start</code>, the starting index in the text for search,
+        *            inclusive
         * @param <code>end</code>, the stopping point of search, exclusive
         * @param <code>p</code>, a simple regular expression that may contains '?'
         * @param <code>caseIgnored</code>, wether the pattern is not casesensitive
-        * @return the starting index in the text of the pattern , or -1 if not found
+        * @return the starting index in the text of the pattern , or -1 if not
+        *         found
         */
        protected int regExpPosIn(String text, int start, int end, String p) {
-               int plen= p.length();
+               int plen = p.length();
 
-               int max= end - plen;
-               for (int i= start; i <= max; ++i) {
+               int max = end - plen;
+               for (int i = start; i <= max; ++i) {
                        if (regExpRegionMatches(text, i, p, 0, plen))
                                return i;
                }
                return -1;
        }
+
        /**
-        *
+        * 
         * @return boolean
         * @param <code>text</code>, a String to match
-        * @param <code>start</code>, int that indicates the starting index of match, inclusive
-        * @param <code>end</code> int that indicates the ending index of match, exclusive
-        * @param <code>p</code>, String,  String, a simple regular expression that may contain '?'
-        * @param <code>ignoreCase</code>, boolean indicating wether code>p</code> is case sensitive
+        * @param <code>start</code>, int that indicates the starting index of
+        *            match, inclusive
+        * @param <code>end</code> int that indicates the ending index of match,
+        *            exclusive
+        * @param <code>p</code>, String, String, a simple regular expression that
+        *            may contain '?'
+        * @param <code>ignoreCase</code>, boolean indicating wether code>p</code>
+        *            is case sensitive
         */
-       protected boolean regExpRegionMatches(String text, int tStart, String p, int pStart, int plen) {
+       protected boolean regExpRegionMatches(String text, int tStart, String p,
+                       int pStart, int plen) {
                while (plen-- > 0) {
-                       char tchar= text.charAt(tStart++);
-                       char pchar= p.charAt(pStart++);
+                       char tchar = text.charAt(tStart++);
+                       char pchar = p.charAt(pStart++);
 
                        /* process wild cards */
                        if (!fIgnoreWildCards) {
@@ -347,38 +399,47 @@ public class StringMatcher {
                        if (pchar == tchar)
                                continue;
                        if (fIgnoreCase) {
-                               if (Character.toUpperCase(tchar) == Character.toUpperCase(pchar))
+                               if (Character.toUpperCase(tchar) == Character
+                                               .toUpperCase(pchar))
                                        continue;
-                               // comparing after converting to upper case doesn't handle all cases;
+                               // comparing after converting to upper case doesn't handle all
+                               // cases;
                                // also compare after converting to lower case
-                               if (Character.toLowerCase(tchar) == Character.toLowerCase(pchar))
+                               if (Character.toLowerCase(tchar) == Character
+                                               .toLowerCase(pchar))
                                        continue;
                        }
                        return false;
                }
                return true;
        }
+
        /**
         * @param <code>text</code>, the string to match
-        * @param <code>start</code>, the starting index in the text for search, inclusive
+        * @param <code>start</code>, the starting index in the text for search,
+        *            inclusive
         * @param <code>end</code>, the stopping point of search, exclusive
-        * @param code>p</code>, a string that has no wildcard
-        * @param <code>ignoreCase</code>, boolean indicating wether code>p</code> is case sensitive
-        * @return the starting index in the text of the pattern , or -1 if not found
+        * @param code>p
+        *            </code>, a string that has no wildcard
+        * @param <code>
+        *            ignoreCase</code>, boolean indicating wether code>p</code>
+        *            is case sensitive
+        * @return the starting index in the text of the pattern , or -1 if not
+        *         found
         */
        protected int textPosIn(String text, int start, int end, String p) {
 
-               int plen= p.length();
-               int max= end - plen;
+               int plen = p.length();
+               int max = end - plen;
 
                if (!fIgnoreCase) {
-                       int i= text.indexOf(p, start);
+                       int i = text.indexOf(p, start);
                        if (i == -1 || i > max)
                                return -1;
                        return i;
                }
 
-               for (int i= start; i <= max; ++i) {
+               for (int i = start; i <= max; ++i) {
                        if (text.regionMatches(true, i, p, 0, plen))
                                return i;
                }