How to use jodd.inex

/**
 * Returns <code>true</code> if some entry name has to be accepted.
 * @see #prepareEntryName(String, boolean)
 * @see #scanEntry(ClassPathEntry)
 */
protected boolean acceptEntry(final String entryName) {
  return rulesEntries.match(entryName);
}

/**
 * Specify excluded jars.
 */
public ClassScanner excludeJars(final String... excludedJars) {
  for (final String excludedJar : excludedJars) {
    rulesJars.exclude(excludedJar);
  }
  return this;
}

/**
 * Sets white/black list mode for entries.
 */
public ClassScanner includeAllEntries(final boolean blacklist) {
  if (blacklist) {
    rulesEntries.blacklist();
  } else {
    rulesEntries.whitelist();
  }
  return this;
}
/**

public TypeData(final List<String> includes, final List<String> excludes, final boolean strict, final String[] jsonNames, final String[] realNames) {
  rules = new InExRules<>();
  for (String include : includes) {
    rules.include(include);
  }
  for (String exclude : excludes) {
    rules.exclude(exclude);
  }
  this.strict = strict;
  this.jsonNames = jsonNames;
  this.realNames = realNames;
}

/**
 * Specify included jars.
 */
public ClassScanner includeJars(final String... includedJars) {
  for (final String includedJar : includedJars) {
    rulesJars.include(includedJar);
  }
  return this;
}

/**
 * Reset the search so it can be run again with very
 * same parameters (and sorting options).
 */
public void reset() {
  pathList = pathListOriginal;
  pathListOriginal = null;
  todoFiles = null;
  lastFile = null;
  rules.reset();
}

/**
 * Creates rule engine.
 */
protected InExRules<String, String, ?> createRulesEngine() {
  return new InExRules<>();
}

/**
 * Matched current path to queries. If match is found, provided include
 * value may be changed.
 */
public boolean matchPathToQueries(final boolean include) {
  return jsonSerializer.rules.apply(path, include);
}

/**
 * Enables whitelist mode.
 */
public FindFile excludeAll() {
  rules.whitelist();
  return this;
}

/**
 * Enables blacklist mode.
 */
public FindFile includeAll() {
  rules.blacklist();
  return this;
}

/**
 * Adds include rule.
 */
public void include(final D rule) {
  addRule(rule, true);
}

/**
 * Defines exclude patterns.
 */
public FindFile exclude(final String... patterns) {
  for (String pattern : patterns) {
    rules.exclude(pattern);
  }
  return this;
}

/**
 * Sets white/black list mode for entries.
 */
public ClassScanner excludeAllEntries(final boolean whitelist) {
  if (whitelist) {
    rulesEntries.whitelist();
  } else {
    rulesEntries.blacklist();
  }
  return this;
}

/**
 * Matches value against the set of rules using current white/black list mode.
 */
public boolean match(final V value) {
  return match(value, blacklist);
}
/**

/**
 * Defines include patterns.
 */
public FindFile include(final String... patterns) {
  for (String pattern : patterns) {
    rules.include(pattern);
  }
  return this;
}

/**
 * Applies rules on given flag using current black/white list mode.
 * @see #apply(Object, boolean, boolean)
 */
public boolean apply(final V value, final boolean flag) {
  return apply(value, blacklist, flag);
}

/**
 * Defines exclude pattern.
 */
public FindFile exclude(final String pattern) {
  rules.exclude(pattern);
  return this;
}

/**
 * Sets white/black list mode for jars.
 */
public ClassScanner includeAllJars(final boolean blacklist) {
  if (blacklist) {
    rulesJars.blacklist();
  } else {
    rulesJars.whitelist();
  }
  return this;
}

/**
 * Sets excluded names that narrows included set of packages.
 * @see InExRules
 */
public ClassScanner excludeEntries(final String... excludedEntries) {
  for (final String excludedEntry : excludedEntries) {
    rulesEntries.exclude(excludedEntry);
  }
  return this;
}

/**
 * Sets white/black list mode for jars.
 */
public ClassScanner excludeAllJars(final boolean whitelist) {
  if (whitelist) {
    rulesJars.whitelist();
  } else {
    rulesJars.blacklist();
  }
  return this;
}