+ * Allows multiple {@link Filter}s to be chained. + * Logical operations such as NOT and XOR + * are applied between filters. One operation can be used + * for all filters, or a specific operation can be declared + * for each filter. + *
+ *+ * Order in which filters are called depends on + * the position of the filter in the chain. It's probably + * more efficient to place the most restrictive filters + * /least computationally-intensive filters first. + *
+ * + * @author Kelvin Tan + */ +public class ChainedFilter extends Filter +{ + /** + * {@link BitSet#or}. + */ + public static final int OR = 0; + + /** + * {@link BitSet#and}. + */ + public static final int AND = 1; + + /** + * {@link BitSet#andNot}. + */ + public static final int ANDNOT = 2; + + /** + * {@link BitSet#xor}. + */ + public static final int XOR = 3; + + /** + * Logical operation when none is declared. Defaults to + * {@link BitSet#or}. + */ + public static int DEFAULT = OR; + + /** The filter chain */ + private Filter[] chain = null; + + private int[] logicArray; + + private int logic = -1; + + /** + * Ctor. + * @param chain The chain of filters + */ + public ChainedFilter(Filter[] chain) + { + this.chain = chain; + } + + /** + * Ctor. + * @param chain The chain of filters + * @param logicArray Logical operations to apply between filters + */ + public ChainedFilter(Filter[] chain, int[] logicArray) + { + this.chain = chain; + this.logicArray = logicArray; + } + + /** + * Ctor. + * @param chain The chain of filters + * @param logic Logicial operation to apply to ALL filters + */ + public ChainedFilter(Filter[] chain, int logic) + { + this.chain = chain; + this.logic = logic; + } + + /** + * {@link Filter#bits}. + */ + public BitSet bits(IndexReader reader) throws IOException + { + if (logic != -1) + return bits(reader, logic); + else if (logicArray != null) + return bits(reader, logicArray); + else + return bits(reader, DEFAULT); + } + + /** + * Delegates to each filter in the chain. + * @param reader IndexReader + * @param logic Logical operation + * @return BitSet + */ + private BitSet bits(IndexReader reader, int logic) throws IOException + { + BitSet result; + int i = 0; + + /** + * First AND operation takes place against a completely false + * bitset and will always return zero results. Thanks to + * Daniel Armbrust for pointing this out and suggesting workaround. + */ + if (logic == AND) + { + result = chain[i].bits(reader); + ++i; + } + else + { + result = new BitSet(reader.maxDoc()); + } + + for (; i < chain.length; i++) + { + doChain(result, reader, logic, chain[i]); + } + return result; + } + + /** + * Delegates to each filter in the chain. + * @param reader IndexReader + * @param logic Logical operation + * @return BitSet + */ + private BitSet bits(IndexReader reader, int[] logic) throws IOException + { + if (logic.length != chain.length) + throw new IllegalArgumentException("Invalid number of elements in logic array"); + BitSet result; + int i = 0; + + /** + * First AND operation takes place against a completely false + * bitset and will always return zero results. Thanks to + * Daniel Armbrust for pointing this out and suggesting workaround. + */ + if (logic[0] == AND) + { + result = chain[i].bits(reader); + ++i; + } + else + { + result = new BitSet(reader.maxDoc()); + } + + for (; i < chain.length; i++) + { + doChain(result, reader, logic[i], chain[i]); + } + return result; + } + + public String toString() + { + StringBuffer sb = new StringBuffer(); + sb.append("ChainedFilter: ["); + for (int i = 0; i < chain.length; i++) + { + sb.append(chain[i]); + sb.append(' '); + } + sb.append(']'); + return sb.toString(); + } + + private void doChain(BitSet result, IndexReader reader, + int logic, Filter filter) throws IOException + { + switch (logic) + { + case OR: + result.or(filter.bits(reader)); + case AND: + result.and(filter.bits(reader)); + case ANDNOT: + result.andNot(filter.bits(reader)); + case XOR: + result.xor(filter.bits(reader)); + default: + doChain(result, reader, DEFAULT, filter); + } + } +}