archiva-scanner-performance/src/main/java/org/apache/archiva/SelectorUtils.java - archiva-sandbox - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package org.apache.archiva;

 import java.io.File;

 /**
  * <p>This is a utility class used by selectors and DirectoryScanner. The
  * functionality more properly belongs just to selectors, but unfortunately
  * DirectoryScanner exposed these as protected methods. Thus we have to
  * support any subclasses of DirectoryScanner that may access these methods.
  * </p>
  * <p>This is a Singleton.</p>
  *
  * From Ant 1.8.0
  */
 public final class SelectorUtils {

     /**
      * The pattern that matches an arbitrary number of directories.
      * @since Ant 1.8.0
      */
     public static final String DEEP_TREE_MATCH = "**";

     private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();

     /**
      * Private Constructor
      */
     private SelectorUtils() {
     }


     /**
      * Tests whether or not a given path matches a given pattern.
      *
      * If you need to call this method multiple times with the same
      * pattern you should rather use TokenizedPath
      *
      * @param pattern The pattern to match against. Must not be
      *                <code>null</code>.
      * @param str     The path to match, as a String. Must not be
      *                <code>null</code>.
      *
      * @return <code>true</code> if the pattern matches against the string,
      *         or <code>false</code> otherwise.
      */
     public static boolean matchPath(String pattern, String str)
     {
         String[] patDirs = tokenizePathAsArray(pattern);
         return matchPath(patDirs, tokenizePathAsArray(str), true);
     }

     /**
      * Tests whether or not a given path matches a given pattern.
      *
      * If you need to call this method multiple times with the same
      * pattern you should rather use TokenizedPattern
      *
      * @see TokenizedPattern
      *
      * @param pattern The pattern to match against. Must not be
      *                <code>null</code>.
      * @param str     The path to match, as a String. Must not be
      *                <code>null</code>.
      * @param isCaseSensitive Whether or not matching should be performed
      *                        case sensitively.
      *
      * @return <code>true</code> if the pattern matches against the string,
      *         or <code>false</code> otherwise.
      */
     public static boolean matchPath(String pattern, String str,
                                     boolean isCaseSensitive)
     {
         String[] patDirs = tokenizePathAsArray(pattern);
         return matchPath(patDirs, tokenizePathAsArray(str), isCaseSensitive);
     }

     /**
      * Core implementation of matchPath.  It is isolated so that it
      * can be called from TokenizedPattern.
      */
     static boolean matchPath(String[] tokenizedPattern, String[] strDirs,
                              boolean isCaseSensitive) {
         int patIdxStart = 0;
         int patIdxEnd = tokenizedPattern.length - 1;
         int strIdxStart = 0;
         int strIdxEnd = strDirs.length - 1;

         // up to first '**'
         while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
             String patDir = tokenizedPattern[patIdxStart];
             if (patDir.equals(DEEP_TREE_MATCH)) {
                 break;
             }
             if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) {
                 return false;
             }
             patIdxStart++;
             strIdxStart++;
         }
         if (strIdxStart > strIdxEnd) {
             // String is exhausted
             for (int i = patIdxStart; i <= patIdxEnd; i++) {
                 if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
                     return false;
                 }
             }
             return true;
         } else {
             if (patIdxStart > patIdxEnd) {
                 // String not exhausted, but pattern is. Failure.
                 return false;
             }
         }

         // up to last '**'
         while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
             String patDir = tokenizedPattern[patIdxEnd];
             if (patDir.equals(DEEP_TREE_MATCH)) {
                 break;
             }
             if (!match(patDir, strDirs[strIdxEnd], isCaseSensitive)) {
                 return false;
             }
             patIdxEnd--;
             strIdxEnd--;
         }
         if (strIdxStart > strIdxEnd) {
             // String is exhausted
             for (int i = patIdxStart; i <= patIdxEnd; i++) {
                 if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
                     return false;
                 }
             }
             return true;
         }

         while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
             int patIdxTmp = -1;
             for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
                 if (tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
                     patIdxTmp = i;
                     break;
                 }
             }
             if (patIdxTmp == patIdxStart + 1) {
                 // '**/**' situation, so skip one
                 patIdxStart++;
                 continue;
             }
             // Find the pattern between padIdxStart & padIdxTmp in str between
             // strIdxStart & strIdxEnd
             int patLength = (patIdxTmp - patIdxStart - 1);
             int strLength = (strIdxEnd - strIdxStart + 1);
             int foundIdx = -1;
             strLoop:
                         for (int i = 0; i <= strLength - patLength; i++) {
                             for (int j = 0; j < patLength; j++) {
                                 String subPat = tokenizedPattern[patIdxStart + j + 1];
                                 String subStr = strDirs[strIdxStart + i + j];
                                 if (!match(subPat, subStr, isCaseSensitive)) {
                                     continue strLoop;
                                 }
                             }

                             foundIdx = strIdxStart + i;
                             break;
                         }

             if (foundIdx == -1) {
                 return false;
             }

             patIdxStart = patIdxTmp;
             strIdxStart = foundIdx + patLength;
         }

         for (int i = patIdxStart; i <= patIdxEnd; i++) {
             if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
                 return false;
             }
         }

         return true;
     }

     /**
      * Tests whether or not a string matches against a pattern.
      * The pattern may contain two special characters:<br>
      * '*' means zero or more characters<br>
      * '?' means one and only one character
      *
      * @param pattern The pattern to match against.
      *                Must not be <code>null</code>.
      * @param str     The string which must be matched against the pattern.
      *                Must not be <code>null</code>.
      * @param caseSensitive Whether or not matching should be performed
      *                        case sensitively.
      *
      *
      * @return <code>true</code> if the string matches against the pattern,
      *         or <code>false</code> otherwise.
      */
     public static boolean match(String pattern, String str,
                                 boolean caseSensitive) {
         char[] patArr = pattern.toCharArray();
         char[] strArr = str.toCharArray();
         int patIdxStart = 0;
         int patIdxEnd = patArr.length - 1;
         int strIdxStart = 0;
         int strIdxEnd = strArr.length - 1;
         char ch;

         boolean containsStar = false;
         for (int i = 0; i < patArr.length; i++) {
             if (patArr[i] == '*') {
                 containsStar = true;
                 break;
             }
         }

         if (!containsStar) {
             // No '*'s, so we make a shortcut
             if (patIdxEnd != strIdxEnd) {
                 return false; // Pattern and string do not have the same size
             }
             for (int i = 0; i <= patIdxEnd; i++) {
                 ch = patArr[i];
                 if (ch != '?') {
                     if (different(caseSensitive, ch, strArr[i])) {
                         return false; // Character mismatch
                     }
                 }
             }
             return true; // String matches against pattern
         }

         if (patIdxEnd == 0) {
             return true; // Pattern contains only '*', which matches anything
         }

         // Process characters before first star
         while (true) {
             ch = patArr[patIdxStart];
             if (ch == '*' || strIdxStart > strIdxEnd) {
                 break;
             }
             if (ch != '?') {
                 if (different(caseSensitive, ch, strArr[strIdxStart])) {
                     return false; // Character mismatch
                 }
             }
             patIdxStart++;
             strIdxStart++;
         }
         if (strIdxStart > strIdxEnd) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
             return allStars(patArr, patIdxStart, patIdxEnd);
         }

         // Process characters after last star
         while (true) {
             ch = patArr[patIdxEnd];
             if (ch == '*' || strIdxStart > strIdxEnd) {
                 break;
             }
             if (ch != '?') {
                 if (different(caseSensitive, ch, strArr[strIdxEnd])) {
                     return false; // Character mismatch
                 }
             }
             patIdxEnd--;
             strIdxEnd--;
         }
         if (strIdxStart > strIdxEnd) {
             // All characters in the string are used. Check if only '*'s are
             // left in the pattern. If so, we succeeded. Otherwise failure.
             return allStars(patArr, patIdxStart, patIdxEnd);
         }

         // process pattern between stars. padIdxStart and patIdxEnd point
         // always to a '*'.
         while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
             int patIdxTmp = -1;
             for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
                 if (patArr[i] == '*') {
                     patIdxTmp = i;
                     break;
                 }
             }
             if (patIdxTmp == patIdxStart + 1) {
                 // Two stars next to each other, skip the first one.
                 patIdxStart++;
                 continue;
             }
             // Find the pattern between padIdxStart & padIdxTmp in str between
             // strIdxStart & strIdxEnd
             int patLength = (patIdxTmp - patIdxStart - 1);
             int strLength = (strIdxEnd - strIdxStart + 1);
             int foundIdx = -1;
             strLoop:
             for (int i = 0; i <= strLength - patLength; i++) {
                 for (int j = 0; j < patLength; j++) {
                     ch = patArr[patIdxStart + j + 1];
                     if (ch != '?') {
                         if (different(caseSensitive, ch,
                                       strArr[strIdxStart + i + j])) {
                             continue strLoop;
                         }
                     }
                 }

                 foundIdx = strIdxStart + i;
                 break;
             }

             if (foundIdx == -1) {
                 return false;
             }

             patIdxStart = patIdxTmp;
             strIdxStart = foundIdx + patLength;
         }

         // All characters in the string are used. Check if only '*'s are left
         // in the pattern. If so, we succeeded. Otherwise failure.
         return allStars(patArr, patIdxStart, patIdxEnd);
     }

     private static boolean allStars(char[] chars, int start, int end) {
         for (int i = start; i <= end; ++i) {
             if (chars[i] != '*') {
                 return false;
             }
         }
         return true;
     }

     private static boolean different(
         boolean caseSensitive, char ch, char other) {
         return caseSensitive
             ? ch != other
             : Character.toUpperCase(ch) != Character.toUpperCase(other);
     }

     /*package*/ static String[] tokenizePathAsArray(String path)
     {
         String root = null;
         if (FileUtils.isAbsolutePath(path)) {
             String[] s = FILE_UTILS.dissect(path);
             root = s[0];
             path = s[1];
         }
         char sep = File.separatorChar;
         int start = 0;
         int len = path.length();
         int count = 0;
         for (int pos = 0; pos < len; pos++) {
             if (path.charAt(pos) == sep) {
                 if (pos != start) {
                     count++;
                 }
                 start = pos + 1;
             }
         }
         if (len != start) {
             count++;
         }
         String[] l = new String[count + ((root == null) ? 0 : 1)];

         if (root != null) {
             l[0] = root;
             count = 1;
         } else {
             count = 0;
         }
         start = 0;
         for (int pos = 0; pos < len; pos++) {
             if (path.charAt(pos) == sep) {
                 if (pos != start) {
                     String tok = path.substring(start, pos);
                     l[count++] = tok;
                 }
                 start = pos + 1;
             }
         }
         if (len != start) {
             String tok = path.substring(start);
             l[count/*++*/] = tok;
         }
         return l;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package org.apache.archiva;

	import java.io.File;

	/**
	* <p>This is a utility class used by selectors and DirectoryScanner. The
	* functionality more properly belongs just to selectors, but unfortunately
	* DirectoryScanner exposed these as protected methods. Thus we have to
	* support any subclasses of DirectoryScanner that may access these methods.
	* </p>
	* <p>This is a Singleton.</p>
	*
	* From Ant 1.8.0
	*/
	public final class SelectorUtils {

	/**
	* The pattern that matches an arbitrary number of directories.
	* @since Ant 1.8.0
	*/
	public static final String DEEP_TREE_MATCH = "**";

	private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();

	/**
	* Private Constructor
	*/
	private SelectorUtils() {
	}


	/**
	* Tests whether or not a given path matches a given pattern.
	*
	* If you need to call this method multiple times with the same
	* pattern you should rather use TokenizedPath
	*
	* @param pattern The pattern to match against. Must not be
	* <code>null</code>.
	* @param str The path to match, as a String. Must not be
	* <code>null</code>.
	*
	* @return <code>true</code> if the pattern matches against the string,
	* or <code>false</code> otherwise.
	*/
	public static boolean matchPath(String pattern, String str)
	{
	String[] patDirs = tokenizePathAsArray(pattern);
	return matchPath(patDirs, tokenizePathAsArray(str), true);
	}

	/**
	* Tests whether or not a given path matches a given pattern.
	*
	* If you need to call this method multiple times with the same
	* pattern you should rather use TokenizedPattern
	*
	* @see TokenizedPattern
	*
	* @param pattern The pattern to match against. Must not be
	* <code>null</code>.
	* @param str The path to match, as a String. Must not be
	* <code>null</code>.
	* @param isCaseSensitive Whether or not matching should be performed
	* case sensitively.
	*
	* @return <code>true</code> if the pattern matches against the string,
	* or <code>false</code> otherwise.
	*/
	public static boolean matchPath(String pattern, String str,
	boolean isCaseSensitive)
	{
	String[] patDirs = tokenizePathAsArray(pattern);
	return matchPath(patDirs, tokenizePathAsArray(str), isCaseSensitive);
	}

	/**
	* Core implementation of matchPath. It is isolated so that it
	* can be called from TokenizedPattern.
	*/
	static boolean matchPath(String[] tokenizedPattern, String[] strDirs,
	boolean isCaseSensitive) {
	int patIdxStart = 0;
	int patIdxEnd = tokenizedPattern.length - 1;
	int strIdxStart = 0;
	int strIdxEnd = strDirs.length - 1;

	// up to first '**'
	while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
	String patDir = tokenizedPattern[patIdxStart];
	if (patDir.equals(DEEP_TREE_MATCH)) {
	break;
	}
	if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) {
	return false;
	}
	patIdxStart++;
	strIdxStart++;
	}
	if (strIdxStart > strIdxEnd) {
	// String is exhausted
	for (int i = patIdxStart; i <= patIdxEnd; i++) {
	if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
	return false;
	}
	}
	return true;
	} else {
	if (patIdxStart > patIdxEnd) {
	// String not exhausted, but pattern is. Failure.
	return false;
	}
	}

	// up to last '**'
	while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
	String patDir = tokenizedPattern[patIdxEnd];
	if (patDir.equals(DEEP_TREE_MATCH)) {
	break;
	}
	if (!match(patDir, strDirs[strIdxEnd], isCaseSensitive)) {
	return false;
	}
	patIdxEnd--;
	strIdxEnd--;
	}
	if (strIdxStart > strIdxEnd) {
	// String is exhausted
	for (int i = patIdxStart; i <= patIdxEnd; i++) {
	if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
	return false;
	}
	}
	return true;
	}

	while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
	int patIdxTmp = -1;
	for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
	if (tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
	patIdxTmp = i;
	break;
	}
	}
	if (patIdxTmp == patIdxStart + 1) {
	// '/' situation, so skip one
	patIdxStart++;
	continue;
	}
	// Find the pattern between padIdxStart & padIdxTmp in str between
	// strIdxStart & strIdxEnd
	int patLength = (patIdxTmp - patIdxStart - 1);
	int strLength = (strIdxEnd - strIdxStart + 1);
	int foundIdx = -1;
	strLoop:
	for (int i = 0; i <= strLength - patLength; i++) {
	for (int j = 0; j < patLength; j++) {
	String subPat = tokenizedPattern[patIdxStart + j + 1];
	String subStr = strDirs[strIdxStart + i + j];
	if (!match(subPat, subStr, isCaseSensitive)) {
	continue strLoop;
	}
	}

	foundIdx = strIdxStart + i;
	break;
	}

	if (foundIdx == -1) {
	return false;
	}

	patIdxStart = patIdxTmp;
	strIdxStart = foundIdx + patLength;
	}

	for (int i = patIdxStart; i <= patIdxEnd; i++) {
	if (!tokenizedPattern[i].equals(DEEP_TREE_MATCH)) {
	return false;
	}
	}

	return true;
	}

	/**
	* Tests whether or not a string matches against a pattern.
	* The pattern may contain two special characters:<br>
	* '*' means zero or more characters<br>
	* '?' means one and only one character
	*
	* @param pattern The pattern to match against.
	* Must not be <code>null</code>.
	* @param str The string which must be matched against the pattern.
	* Must not be <code>null</code>.
	* @param caseSensitive Whether or not matching should be performed
	* case sensitively.
	*
	*
	* @return <code>true</code> if the string matches against the pattern,
	* or <code>false</code> otherwise.
	*/
	public static boolean match(String pattern, String str,
	boolean caseSensitive) {
	char[] patArr = pattern.toCharArray();
	char[] strArr = str.toCharArray();
	int patIdxStart = 0;
	int patIdxEnd = patArr.length - 1;
	int strIdxStart = 0;
	int strIdxEnd = strArr.length - 1;
	char ch;

	boolean containsStar = false;
	for (int i = 0; i < patArr.length; i++) {
	if (patArr[i] == '*') {
	containsStar = true;
	break;
	}
	}

	if (!containsStar) {
	// No '*'s, so we make a shortcut
	if (patIdxEnd != strIdxEnd) {
	return false; // Pattern and string do not have the same size
	}
	for (int i = 0; i <= patIdxEnd; i++) {
	ch = patArr[i];
	if (ch != '?') {
	if (different(caseSensitive, ch, strArr[i])) {
	return false; // Character mismatch
	}
	}
	}
	return true; // String matches against pattern
	}

	if (patIdxEnd == 0) {
	return true; // Pattern contains only '*', which matches anything
	}

	// Process characters before first star
	while (true) {
	ch = patArr[patIdxStart];
	if (ch == '*' \|\| strIdxStart > strIdxEnd) {
	break;
	}
	if (ch != '?') {
	if (different(caseSensitive, ch, strArr[strIdxStart])) {
	return false; // Character mismatch
	}
	}
	patIdxStart++;
	strIdxStart++;
	}
	if (strIdxStart > strIdxEnd) {
	// All characters in the string are used. Check if only '*'s are
	// left in the pattern. If so, we succeeded. Otherwise failure.
	return allStars(patArr, patIdxStart, patIdxEnd);
	}

	// Process characters after last star
	while (true) {
	ch = patArr[patIdxEnd];
	if (ch == '*' \|\| strIdxStart > strIdxEnd) {
	break;
	}
	if (ch != '?') {
	if (different(caseSensitive, ch, strArr[strIdxEnd])) {
	return false; // Character mismatch
	}
	}
	patIdxEnd--;
	strIdxEnd--;
	}
	if (strIdxStart > strIdxEnd) {
	// All characters in the string are used. Check if only '*'s are
	// left in the pattern. If so, we succeeded. Otherwise failure.
	return allStars(patArr, patIdxStart, patIdxEnd);
	}

	// process pattern between stars. padIdxStart and patIdxEnd point
	// always to a '*'.
	while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
	int patIdxTmp = -1;
	for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
	if (patArr[i] == '*') {
	patIdxTmp = i;
	break;
	}
	}
	if (patIdxTmp == patIdxStart + 1) {
	// Two stars next to each other, skip the first one.
	patIdxStart++;
	continue;
	}
	// Find the pattern between padIdxStart & padIdxTmp in str between
	// strIdxStart & strIdxEnd
	int patLength = (patIdxTmp - patIdxStart - 1);
	int strLength = (strIdxEnd - strIdxStart + 1);
	int foundIdx = -1;
	strLoop:
	for (int i = 0; i <= strLength - patLength; i++) {
	for (int j = 0; j < patLength; j++) {
	ch = patArr[patIdxStart + j + 1];
	if (ch != '?') {
	if (different(caseSensitive, ch,
	strArr[strIdxStart + i + j])) {
	continue strLoop;
	}
	}
	}

	foundIdx = strIdxStart + i;
	break;
	}

	if (foundIdx == -1) {
	return false;
	}

	patIdxStart = patIdxTmp;
	strIdxStart = foundIdx + patLength;
	}

	// All characters in the string are used. Check if only '*'s are left
	// in the pattern. If so, we succeeded. Otherwise failure.
	return allStars(patArr, patIdxStart, patIdxEnd);
	}

	private static boolean allStars(char[] chars, int start, int end) {
	for (int i = start; i <= end; ++i) {
	if (chars[i] != '*') {
	return false;
	}
	}
	return true;
	}

	private static boolean different(
	boolean caseSensitive, char ch, char other) {
	return caseSensitive
	? ch != other
	: Character.toUpperCase(ch) != Character.toUpperCase(other);
	}

	/package/ static String[] tokenizePathAsArray(String path)
	{
	String root = null;
	if (FileUtils.isAbsolutePath(path)) {
	String[] s = FILE_UTILS.dissect(path);
	root = s[0];
	path = s[1];
	}
	char sep = File.separatorChar;
	int start = 0;
	int len = path.length();
	int count = 0;
	for (int pos = 0; pos < len; pos++) {
	if (path.charAt(pos) == sep) {
	if (pos != start) {
	count++;
	}
	start = pos + 1;
	}
	}
	if (len != start) {
	count++;
	}
	String[] l = new String[count + ((root == null) ? 0 : 1)];

	if (root != null) {
	l[0] = root;
	count = 1;
	} else {
	count = 0;
	}
	start = 0;
	for (int pos = 0; pos < len; pos++) {
	if (path.charAt(pos) == sep) {
	if (pos != start) {
	String tok = path.substring(start, pos);
	l[count++] = tok;
	}
	start = pos + 1;
	}
	}
	if (len != start) {
	String tok = path.substring(start);
	l[count/++/] = tok;
	}
	return l;
	}
	}