/** * Adds exclude rule. */ public void exclude(R rule) { addRule(rule, false); }
/** * Applies rules on given flag using current black/white list mode. * @see #apply(Object, boolean, boolean) */ public boolean apply(T value, boolean flag) { return apply(value, blacklist, flag); }
/** * Matches value against the set of rules using provided white/black list mode. */ public boolean match(T value, boolean blacklist) { if (rules == null) { return blacklist; } boolean include = blacklist; if (include) { include = processExcludes(value, true); include = processIncludes(value, include); } else { include = processIncludes(value, false); include = processExcludes(value, include); } return include; }
/** * Matches value against the set of rules using current white/black list mode. */ public boolean match(T value) { return match(value, blacklist); } /**
/** * Enables blacklist mode. */ public T includeAll() { rules.blacklist(); return (T) this; }
/** * Enables whitelist mode. */ public T excludeAll() { rules.whitelist(); return (T) this; }
/** * Specify included jars. */ public void setIncludedJars(String... includedJars) { for (String includedJar : includedJars) { rulesJars.include(includedJar); } }
/** * Sets excluded names that narrows included set of packages. * @see jodd.util.InExRules */ public void setExcludedEntries(String... excludedEntries) { for (String excludedEntry : excludedEntries) { rulesEntries.exclude(excludedEntry); } }
/** * Creates rule engine. */ protected InExRules createRulesEngine() { return new InExRules<>(); }
/** * Applies rules on given flag. Flag is only changed if at least one rule * matched. Otherwise, the same value is returned. This way you can * chain several rules and have the rule engine change the flag * only when a rule is matched. */ public boolean apply(T value, final boolean blacklist, boolean flag) { if (rules == null) { return flag; } if (blacklist) { flag = processExcludes(value, flag); flag = processIncludes(value, flag); } else { flag = processIncludes(value, flag); flag = processExcludes(value, flag); } return flag; }
/** * Returns <code>true</code> if some entry name has to be accepted. * @see #prepareEntryName(String, boolean) * @see #scanEntry(EntryData) */ protected boolean acceptEntry(String entryName) { return rulesEntries.match(entryName); }
/** * Include a property. */ public T include(String include) { rules.include(include); return (T) this; }
/** * Defines excluded property names. */ public T exclude(String... excludes) { for (String ex : excludes) { rules.exclude(ex); } return (T) this; }
@Override protected InExRules createRulesEngine() { return new InExRules<>(InExRuleMatcher.WILDCARD_PATH_RULE_MATCHER); }
/** * Matches value against the set of rules using provided white/black list mode. */ public boolean match(T value, boolean blacklist) { if (rules == null) { return blacklist; } boolean include = blacklist; if (include) { include = processExcludes(value, true); include = processIncludes(value, include); } else { include = processIncludes(value, false); include = processExcludes(value, include); } return include; }
/** * Determine if file is accepted, based on include and exclude * rules. Called on each file entry (file or directory) and * returns <code>true</code> if file passes search criteria. * File is matched using {@link #getMatchingFilePath(java.io.File) matching file path}. * @see jodd.util.InExRules */ protected boolean acceptFile(File file) { String matchingFilePath = getMatchingFilePath(file); return rules.match(matchingFilePath); }
/** * Adds include rule. */ public void include(R rule) { addRule(rule, true); }