stringpattern.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   StringPattern.java

package org.pf.text;

import java.io.Serializable;

// Referenced classes of package org.pf.text:
//			StringExaminer, StringUtil

public class StringPattern
	implements Serializable
{

	protected static final String MULTI_WILDCARD = "*";
	protected static final char MULTICHAR_WILDCARD = 42;
	protected static final char SINGLECHAR_WILDCARD = 63;
	private boolean ignoreCase;
	private String pattern;
	private Character digitWildcard;

	public boolean getIgnoreCase()
	{
		return ignoreCase;
	}

	public void setIgnoreCase(boolean newValue)
	{
		ignoreCase = newValue;
	}

	public String getPattern()
	{
		return pattern;
	}

	public void setPattern(String newValue)
	{
		pattern = newValue;
	}

	protected Character digitWildcard()
	{
		return digitWildcard;
	}

	protected void digitWildcard(Character newValue)
	{
		digitWildcard = newValue;
	}

	public static boolean match(String probe, String pattern)
	{
		StringPattern stringPattern = new StringPattern(pattern, false);
		return stringPattern.matches(probe);
	}

	public static boolean matchIgnoreCase(String probe, String pattern)
	{
		StringPattern stringPattern = new StringPattern(pattern, true);
		return stringPattern.matches(probe);
	}

	public StringPattern(String pattern, boolean ignoreCase)
	{
		this.ignoreCase = false;
		this.pattern = null;
		digitWildcard = null;
		setPattern(pattern);
		setIgnoreCase(ignoreCase);
	}

	public StringPattern(String pattern)
	{
		this(pattern, false);
	}

	public StringPattern(String pattern, char digitWildcard)
	{
		this(pattern, false, digitWildcard);
	}

	public StringPattern(String pattern, boolean ignoreCase, char digitWildcard)
	{
		this.ignoreCase = false;
		this.pattern = null;
		this.digitWildcard = null;
		setPattern(pattern);
		setIgnoreCase(ignoreCase);
		setDigitWildcardChar(digitWildcard);
	}

	public boolean matches(String probe)
	{
		char patternCh;
		char probeCh;
label0:
		{
			StringExaminer patternIterator = null;
			StringExaminer probeIterator = null;
			patternCh = '-';
			probeCh = '-';
			String newPattern = null;
			String subPattern = null;
			int charIndex = 0;
			if (probe == null)
				return false;
			if (probe.length() == 0)
				return false;
			patternIterator = newExaminer(getPattern());
			probeIterator = newExaminer(probe);
			probeCh = probeIterator.nextChar();
label1:
			do
			{
				for (patternCh = getPatternChar(patternIterator, probeCh); endNotReached(patternCh) && endNotReached(probeCh);)
				{
					if (patternCh == '*')
					{
						patternCh = skipWildcards(patternIterator);
						if (endReached(patternCh))
							return true;
						patternIterator.skip(-1);
						newPattern = upToEnd(patternIterator);
						charIndex = newPattern.indexOf('*');
						if (charIndex >= 0)
						{
							subPattern = newPattern.substring(0, charIndex);
							if (skipAfter(probeIterator, subPattern))
							{
								patternIterator = newExaminer(newPattern.substring(charIndex));
								patternCh = probeCh;
							} else
							{
								return false;
							}
						} else
						{
							probeIterator.skip(-1);
							return matchReverse(newPattern, probeIterator);
						}
					}
					if (!charsAreEqual(probeCh, patternCh))
						continue label1;
					if (endNotReached(patternCh))
					{
						probeCh = probeIterator.nextChar();
						patternCh = getPatternChar(patternIterator, probeCh);
					}
				}

				break label0;
			} while (patternCh == '*');
			return false;
		}
		return endReached(patternCh) && endReached(probeCh);
	}

	public String toString()
	{
		if (getPattern() == null)
			return super.toString();
		else
			return getPattern();
	}

	public boolean hasWildcard()
	{
		if (getPattern() == null)
			return false;
		if (hasDigitWildcard() && getPattern().indexOf(digitWildcardChar()) >= 0)
			return true;
		else
			return getPattern().indexOf("*") >= 0 || getPattern().indexOf('?') >= 0;
	}

	public void setDigitWildcardChar(char digitWildcard)
	{
		if (digitWildcard <= 0)
			digitWildcard(null);
		else
			digitWildcard(new Character(digitWildcard));
	}

	protected boolean hasDigitWildcard()
	{
		return digitWildcard() != null;
	}

	protected char digitWildcardChar()
	{
		if (hasDigitWildcard())
			return digitWildcard().charValue();
		else
			return '\0';
	}

	protected char skipWildcards(StringExaminer iterator)
	{
		char result = '-';
		do
			result = iterator.nextChar();
		while (result == '*' || result == '?');
		return result;
	}

	protected boolean skipAfter(StringExaminer examiner, String matchString)
	{
		char ch = '-';
		char matchChar = ' ';
		boolean found = false;
		int index = 0;
		if (matchString == null || matchString.length() == 0)
			return false;
		for (ch = examiner.nextChar(); examiner.endNotReached(ch) && !found;)
		{
			matchChar = matchString.charAt(index);
			if (charsAreEqual(ch, matchChar))
			{
				if (++index >= matchString.length())
					found = true;
				else
					ch = examiner.nextChar();
			} else
			if (index == 0)
				ch = examiner.nextChar();
			else
				index = 0;
		}

		return found;
	}

	protected String upToEnd(StringExaminer iterator)
	{
		return iterator.upToEnd();
	}

	protected boolean matchReverse(String pattern, StringExaminer probeIterator)
	{
		String newPattern = (new StringBuilder()).append("*").append(pattern).toString();
		String newProbe = upToEnd(probeIterator);
		newPattern = strUtil().reverse(newPattern);
		newProbe = strUtil().reverse(newProbe);
		StringPattern newMatcher = new StringPattern(newPattern, getIgnoreCase());
		if (hasDigitWildcard())
			newMatcher.setDigitWildcardChar(digitWildcardChar());
		return newMatcher.matches(newProbe);
	}

	protected boolean charsAreEqual(char probeChar, char patternChar)
	{
		if (hasDigitWildcard() && patternChar == digitWildcardChar())
			return Character.isDigit(probeChar);
		if (getIgnoreCase())
			return Character.toUpperCase(probeChar) == Character.toUpperCase(patternChar);
		else
			return probeChar == patternChar;
	}

	protected boolean endReached(char character)
	{
		return character == '\uFFFF';
	}

	protected boolean endNotReached(char character)
	{
		return !endReached(character);
	}

	protected char getPatternChar(StringExaminer patternIterator, char probeCh)
	{
		char patternCh = patternIterator.nextChar();
		return patternCh != '?' ? patternCh : probeCh;
	}

	protected StringExaminer newExaminer(String str)
	{
		return new StringExaminer(str, getIgnoreCase());
	}

	protected StringUtil strUtil()
	{
		return StringUtil.current();
	}
}