Question

I’m a bit stuck on a project..
Basically, I get a directory to scan for files that passes certain filters.

The command files contains lines with filtering (given filters name are stored in an enum file) instructions. like this for example:
suffix%txt
exec%YES

if that’s all, it will return all the files ending with txt (extension) and are executable..
so far no problem.

the problem starts with line like this:
suffix%txt exec%YES (on the same line) in this case, it should return all the files that ends with txt OR executable..

I’m splitting the line using String.split(“%”) and getting it into a map with a key and value, than iterate over each key and checks what filter in the enum it is, and perform the desire checking.

I’m kinda stuck on how to identify that when i have more than 1 filter per line.
I tried doing a HashMap with the 1st filter as the key, and the value is a list that contains all the other (using split(” “) for breaking up the filters..
I can’t rely on the keys being on the even or odd indexes, because a filter may have another %NOT at the end of it (suffix%txt%NOT) which will return all the files that doesn’t end with txt…

Any help would be appreciated!
Thanks!

Answer 1

How about this: create a Filter interface, and write a function that parses a file into a single filter based on the contents of the file. You’d have something like:

interface Filter {
  boolean passesFilter(File file);
}

class SuffixFilter implements Filter {
  SuffixFilter(String suffix) { ... }
  public boolean passesFilter(File file) {
    // return true if file has the appropriate suffix
  }
}

class ExecutableFilter implements Filter {
  ...  // filter that returns true if the file is executable
}

// now for the interesting part ...
class NegationFilter implements Filter {
  private final Filter subfilter;
  NegationFilter(Filter subfilter) {
    this.subfilter = subfilter;
  }

  public boolean passesFilter(File file) {
    return !subfilter.passesFilter(file);
  }
}

class AndFilter implements Filter {
  private final Collection<Filter> subfilters;
  AndFilter(Collection<Filter> subfilters) {
    this.subfilters = subfilters;
  }

  public boolean passesFilter(File file) {
    for (Filter subfilter : subfilters) {
      if (!subfilter.passesFilter(file)) {
        return false;
      }
    }
    return true;
  }
}

class OrFilter implements Filter {
  private final Collection<Filter> subfilters;
  OrFilter(Collection<Filter> subfilters) {
    this.subfilters = subfilters;
  }

  public boolean passesFilter(File file) {
    for (Filter subfilter : subfilters) {
      if (subfilter.passesFilter(file)) {
        return true;
      }
    }
    return false;
  }
}

With this in place, you just need to build up all the basic filters, and then adjacent elements on the same line get OrFiltered together while filters on separate lines (or-filtered or not) get AndFiltered together. Here’s a sketch:

Filter readAndFilter(Iterable<String> fileLines) {
  List<Filter> subfilters = new ArrayList<Filter>();
  for (String line : fileLines) {
    subfilters.add(readOrFilter(line));
  }
  return new AndFilter(subfilters);
}

Filter readOrFilter(String fileLine) {
  List<Filter> subfilters = new ArrayList<Filter>();
  for (String oneFilter : fileLine.split(" ")) {
    Filter filter = buildOneFilter(oneFilter);
    subfilters.add(filter);
  }
  return new OrFilter(subfilters);
}

Filter buildOneFilter(String oneFilterClause) {
  // parse as you were doing before
}

You’d call readAndFilter on lines read out from your file, and what you get back is always a single Filter that you can pass files to and it’ll tell you whether they pass the filter. (Note: if you wanted to, you could special-case my readAndFilter and readOrFilter methods to check if the list they’re going to return is of length 1, and if so just return that one filter rather than an And or Or of one element. It doesn’t affect correctness, but it might make debugging output a little easier to read.)