/** {@inheritDoc} */ @Override public String toString() { return isStar() ? "*" : "?"; //$NON-NLS-1$ //$NON-NLS-2$ } }
/** {@inheritDoc} */ @Override protected final boolean matches(char c) { for (CharacterPattern pattern : characterClasses) { if (pattern.matches(c)) { return !inverse; } } return inverse; }
/** {@inheritDoc} */ @Override public List<Head> getNextHeads(char c) { if (matches(c)) return newHeads; else return FileNameMatcher.EMPTY_HEAD_LIST; }
private static boolean patternMatchesHost(String pattern, String name) { if (pattern.indexOf('*') >= 0 || pattern.indexOf('?') >= 0) { final FileNameMatcher fn; try { fn = new FileNameMatcher(pattern, null); } catch (InvalidPatternException e) { return false; } fn.append(name); return fn.isMatch(); } else { // Not a pattern but a full host name return pattern.equals(name); } }
private static List<AbstractHead> parseHeads(final String pattern, final Character invalidWildgetCharacter) throws InvalidPatternException { int currentIndex = 0; List<AbstractHead> heads = new ArrayList<>(); while (currentIndex < pattern.length()) { final int groupStart = indexOfUnescaped(pattern, '[', currentIndex); if (groupStart == -1) { final String patternPart = pattern.substring(currentIndex); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); currentIndex = pattern.length(); } else { final String patternPart = pattern.substring(currentIndex, groupStart); heads.addAll(createSimpleHeads(patternPart, invalidWildgetCharacter)); final int groupEnd = findGroupEnd(groupStart, pattern); final String groupPart = pattern.substring(groupStart + 1, groupEnd); heads.add(new GroupHead(groupPart, pattern)); currentIndex = groupEnd + 1; } } return heads; }
private static List<Head> createHeadsStartValues( final String patternString, final Character invalidWildgetCharacter) throws InvalidPatternException { final List<AbstractHead> allHeads = parseHeads(patternString, invalidWildgetCharacter); List<Head> nextHeadsSuggestion = new ArrayList<>(2); nextHeadsSuggestion.add(LastHead.INSTANCE); for (int i = allHeads.size() - 1; i >= 0; i--) { final AbstractHead head = allHeads.get(i); // explanation: // a and * of the pattern "a*b" // need *b as newHeads // that's why * extends the list for it self and it's left neighbor. if (head.isStar()) { nextHeadsSuggestion.add(head); head.setNewHeads(nextHeadsSuggestion); } else { head.setNewHeads(nextHeadsSuggestion); nextHeadsSuggestion = new ArrayList<>(2); nextHeadsSuggestion.add(head); } } return nextHeadsSuggestion; }
private static AbstractHead createWildCardHead( final Character invalidWildgetCharacter, final boolean star) { if (invalidWildgetCharacter != null) return new RestrictedWildCardHead(invalidWildgetCharacter .charValue(), star); else return new WildCardHead(star); }
/** * Create a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current state of * this matcher as reset and start point * * @return a {@link org.eclipse.jgit.fnmatch.FileNameMatcher} instance which * uses the same pattern like this matcher, but has the current * state of this matcher as reset and start point. */ public FileNameMatcher createMatcherForSuffix() { final List<Head> copyOfHeads = new ArrayList<>(heads.size()); copyOfHeads.addAll(heads); return new FileNameMatcher(copyOfHeads); }
final char c = patternPart.charAt(i); if (escaped) { final CharacterHead head = new CharacterHead(c); heads.add(head); escaped = false; switch (c) { case '*': { final AbstractHead head = createWildCardHead( invalidWildgetCharacter, true); heads.add(head); final AbstractHead head = createWildCardHead( invalidWildgetCharacter, false); heads.add(head); break; default: final CharacterHead head = new CharacterHead(c); heads.add(head);
final char start = characterClass.charAt(0); final char end = characterClass.charAt(2); characterClasses.add(new CharacterRange(start, end)); } else if (characterClass.equals("[:alnum:]")) { //$NON-NLS-1$ characterClasses.add(LetterPattern.INSTANCE); characterClasses.add(LetterPattern.INSTANCE); } else if (characterClass.equals("[:blank:]")) { //$NON-NLS-1$ characterClasses.add(new OneCharacterPattern(' ')); characterClasses.add(new OneCharacterPattern('\t')); } else if (characterClass.equals("[:cntrl:]")) { //$NON-NLS-1$ characterClasses.add(new CharacterRange('\u0000', '\u001F')); characterClasses.add(new OneCharacterPattern('\u007F')); } else if (characterClass.equals("[:digit:]")) { //$NON-NLS-1$ characterClasses.add(DigitPattern.INSTANCE); } else if (characterClass.equals("[:graph:]")) { //$NON-NLS-1$ characterClasses.add(new CharacterRange('\u0021', '\u007E')); characterClasses.add(LetterPattern.INSTANCE); characterClasses.add(DigitPattern.INSTANCE); characterClasses.add(LowerPattern.INSTANCE); } else if (characterClass.equals("[:print:]")) { //$NON-NLS-1$ characterClasses.add(new CharacterRange('\u0020', '\u007E')); characterClasses.add(LetterPattern.INSTANCE); characterClasses.add(DigitPattern.INSTANCE); characterClasses.add(UpperPattern.INSTANCE); } else if (characterClass.equals("[:xdigit:]")) { //$NON-NLS-1$ characterClasses.add(new CharacterRange('0', '9'));
/** * Constructor for FileNameMatcher * * @param patternString * must contain a pattern which fnmatch would accept. * @param invalidWildgetCharacter * if this parameter isn't null then this character will not * match at wildcards(* and ? are wildcards). * @throws org.eclipse.jgit.errors.InvalidPatternException * if the patternString contains a invalid fnmatch pattern. */ public FileNameMatcher(final String patternString, final Character invalidWildgetCharacter) throws InvalidPatternException { this(createHeadsStartValues(patternString, invalidWildgetCharacter)); }
/** * Append to the string which is matched against the patterns of this class * * @param stringToMatch * extends the string which is matched against the patterns of * this class. */ public void append(String stringToMatch) { for (int i = 0; i < stringToMatch.length(); i++) { final char c = stringToMatch.charAt(i); if (!extendStringToMatchByOneCharacter(c)) break; } }
/** * @param c new character to append * @return true to continue, false if the matcher can stop appending */ private boolean extendStringToMatchByOneCharacter(char c) { final List<Head> newHeads = listForLocalUseage; newHeads.clear(); List<Head> lastAddedHeads = null; for (int i = 0; i < heads.size(); i++) { final Head head = heads.get(i); final List<Head> headsToAdd = head.getNextHeads(c); // Why the next performance optimization isn't wrong: // Some times two heads return the very same list. // We save future effort if we don't add these heads again. // This is the case with the heads "a" and "*" of "a*b" which // both can return the list ["*","b"] if (headsToAdd != lastAddedHeads) { if (!headsToAdd.isEmpty()) newHeads.addAll(headsToAdd); lastAddedHeads = headsToAdd; } } listForLocalUseage = heads; heads = newHeads; return !newHeads.isEmpty(); }
while (groupEnd == -1) { final int possibleGroupEnd = indexOfUnescaped(pattern, ']', firstValidEndBracketIndex); if (possibleGroupEnd == -1)
private static AbstractHead createWildCardHead( final Character invalidWildgetCharacter, final boolean star) { if (invalidWildgetCharacter != null) return new RestrictedWildCardHead(invalidWildgetCharacter .charValue(), star); else return new WildCardHead(star); }
@Override public String toString() { return isStar() ? "*" : "?"; //$NON-NLS-1$ //$NON-NLS-2$ } }
@Override protected final boolean matches(final char c) { for (CharacterPattern pattern : characterClasses) { if (pattern.matches(c)) { return !inverse; } } return inverse; }
public List<Head> getNextHeads(char c) { if (matches(c)) return newHeads; else return FileNameMatcher.EMPTY_HEAD_LIST; }
private static AbstractHead createWildCardHead( final Character invalidWildgetCharacter, final boolean star) { if (invalidWildgetCharacter != null) return new RestrictedWildCardHead(invalidWildgetCharacter .charValue(), star); else return new WildCardHead(star); }
/** {@inheritDoc} */ @Override public String toString() { return isStar() ? "*" : "?"; //$NON-NLS-1$ //$NON-NLS-2$ } }