Splits the filter from its disjunctive normal form. Or'ng the filters
together produces the full disjunctive normal form.

@return unmodifiable list of sub filters which don't perform any 'or'
operations
@since 1.1.1
967855
public List<Filter<S>> disjunctiveNormalFormSplit() {
        final List<Filter<S>> list = new ArrayList<Filter<S>>();

        disjunctiveNormalForm().accept(new Visitor<S, Object, Object>() {
            @Override
            public Object visit(AndFilter<S> filter, Object param) {
                list.add(filter);
                return null;
            }

            @Override
            public Object visit(PropertyFilter<S> filter, Object param) {
                list.add(filter);
                return null;
            }

            @Override
            public Object visit(ExistsFilter<S> filter, Object param) {
                list.add(filter);
                return null;
            }
        }, null);

        return Collections.unmodifiableList(list);
    }
152324
public List<Split<Flow<T>>> getAllSplit()
   {
      List<Split<Flow<T>>> list = new ArrayList<Split<Flow<T>>>();
      List<Node> nodeList = childNode.get("split");
      for(Node node: nodeList)
      {
         Split<Flow<T>>  type = new SplitImpl<Flow<T>>(this, "split", childNode, node);
         list.add(type);
      }
      return list;
   }
956329
private static Filter flatten(Filter root)
  {
    if (root instanceof BooleanFilter) {
      List<Filter> children = new ArrayList<>();
      children.addAll(((BooleanFilter) root).getFilters());
      // iterate through the index, so that if we add more children,
      // they don't get re-visited
      for (int i = 0; i < children.size(); ++i) {
        Filter child = flatten(children.get(i));
        // do we need to flatten?
        if (child.getClass() == root.getClass() && !(child instanceof NotFilter)) {
          boolean first = true;
          List<Filter> grandKids = ((BooleanFilter) child).getFilters();
          for (Filter grandkid : grandKids) {
            // for the first grandkid replace the original parent
            if (first) {
              first = false;
              children.set(i, grandkid);
            } else {
              children.add(++i, grandkid);
            }
          }
        } else {
          children.set(i, child);
        }
      }
      // if we have a singleton AND or OR, just return the child
      if (children.size() == 1 && (root instanceof AndFilter || root instanceof OrFilter)) {
        return children.get(0);
      }

      if (root instanceof AndFilter) {
        return new AndFilter(children);
      } else if (root instanceof OrFilter) {
        return new OrFilter(children);
      }
    }
    return root;
  }
695323
protected List<Integer> cancelAllActiveOperations() {
        final List<Integer> operations = new ArrayList<Integer>();
        for(final ActiveOperationImpl<?, ?> activeOperation : activeRequests.values()) {
            activeOperation.asyncCancel(false);
            operations.add(activeOperation.getOperationId());
        }
        return operations;
    }
903282
public AbstractExpression getSimpleFilterExpression()
    {
        if (m_whereExpr != null) {
            if (m_joinExpr != null) {
                return ExpressionUtil.combine(m_whereExpr, m_joinExpr);
            }
            return m_whereExpr;
        }
        return m_joinExpr;
    }
683103
public List<ElementSubSet<E>> getPartitions() {
        final List<ElementSubSet<E>> partitions = new ArrayList<>();
        forEachPartition((idx, key, from, to) -> {
            partitions.add(new ElementSubSet<>(SplittableElementSet.this, key, from, to));
            return true;
        });
        return partitions;
    }
676918
public FilterSpec normalize() {
		FilterSpec copy = new FilterSpec();
		copy.attributePath = attributePath;
		copy.operator = operator;
		copy.value = value;
		if (expressions != null) {
			copy.expressions = cloneExpressions(expressions, true);
		}
		return copy;
	}
93293
public Set<String> getUnconditionalClasses() {
		Set<String> filtered = new HashSet<>(this.unconditionalClasses);
		filtered.removeAll(this.exclusions);
		return Collections.unmodifiableSet(filtered);
	}
232980
public static <T> List<T> filter(final Iterable<T> unfiltered, final Predicate<T> filter) {
        return newArrayList(Iterables.filter(unfiltered, filter));
    }
784554
private static DimFilter doSimplify(final List<DimFilter> children, boolean disjunction)
  {
    // Copy children list
    final List<DimFilter> newChildren = Lists.newArrayList(children);

    // Group Bound filters by dimension, extractionFn, and comparator and compute a RangeSet for each one.
    final Map<BoundRefKey, List<BoundDimFilter>> bounds = new HashMap<>();

    final Iterator<DimFilter> iterator = newChildren.iterator();
    while (iterator.hasNext()) {
      final DimFilter child = iterator.next();

      if (child.equals(Filtration.matchNothing())) {
        // Child matches nothing, equivalent to FALSE
        // OR with FALSE => ignore
        // AND with FALSE => always false, short circuit
        if (disjunction) {
          iterator.remove();
        } else {
          return Filtration.matchNothing();
        }
      } else if (child.equals(Filtration.matchEverything())) {
        // Child matches everything, equivalent to TRUE
        // OR with TRUE => always true, short circuit
        // AND with TRUE => ignore
        if (disjunction) {
          return Filtration.matchEverything();
        } else {
          iterator.remove();
        }
      } else if (child instanceof BoundDimFilter) {
        final BoundDimFilter bound = (BoundDimFilter) child;
        final BoundRefKey boundRefKey = BoundRefKey.from(bound);
        List<BoundDimFilter> filterList = bounds.get(boundRefKey);
        if (filterList == null) {
          filterList = new ArrayList<>();
          bounds.put(boundRefKey, filterList);
        }
        filterList.add(bound);
      }
    }

    // Try to simplify filters within each group.
    for (Map.Entry<BoundRefKey, List<BoundDimFilter>> entry : bounds.entrySet()) {
      final BoundRefKey boundRefKey = entry.getKey();
      final List<BoundDimFilter> filterList = entry.getValue();

      // Create a RangeSet for this group.
      final RangeSet<BoundValue> rangeSet = disjunction
                                            ? RangeSets.unionRanges(Bounds.toRanges(filterList))
                                            : RangeSets.intersectRanges(Bounds.toRanges(filterList));

      if (rangeSet.asRanges().size() < filterList.size()) {
        // We found a simplification. Remove the old filters and add new ones.
        for (final BoundDimFilter bound : filterList) {
          if (!newChildren.remove(bound)) {
            throw new ISE("WTF?! Tried to remove bound but couldn't?");
          }
        }

        if (rangeSet.asRanges().isEmpty()) {
          // range set matches nothing, equivalent to FALSE
          // OR with FALSE => ignore
          // AND with FALSE => always false, short circuit
          if (disjunction) {
            newChildren.add(Filtration.matchNothing());
          } else {
            return Filtration.matchNothing();
          }
        }

        for (final Range<BoundValue> range : rangeSet.asRanges()) {
          if (!range.hasLowerBound() && !range.hasUpperBound()) {
            // range matches all, equivalent to TRUE
            // AND with TRUE => ignore
            // OR with TRUE => always true; short circuit
            if (disjunction) {
              return Filtration.matchEverything();
            } else {
              newChildren.add(Filtration.matchEverything());
            }
          } else {
            newChildren.add(Bounds.toFilter(boundRefKey, range));
          }
        }
      }
    }

    Preconditions.checkState(newChildren.size() > 0, "newChildren.size > 0");
    if (newChildren.size() == 1) {
      return newChildren.get(0);
    } else {
      return disjunction ? new OrDimFilter(newChildren) : new AndDimFilter(newChildren);
    }
  }
565269
def without(*conditions, &block)
      @filters ||= []

      @filters << {:negate => true, :filter => block} if block
      conditions.each do |condition|
        @filters << {:negate => true, :filter => condition}
      end
    end
686548
@Override
    public List<FILTERTYPE> getAllFilter() {

        final List<FILTERTYPE> list = new ArrayList<FILTERTYPE>();
        final List<Node> nodeList = model.get("filter");
        for (final Node node : nodeList) {
            final FILTERTYPE filter = this.createNewFilterViewForModel(node);
            list.add(filter);
        }

        return list;
    }
733933
public List<String> list(NfsFilenameFilter filter) throws IOException {
        List<String> children = list();
        if ((children == null) || (children.size() == 0) || (filter == null)) {
            return children;
        }
        List<String> filteredChildren = new ArrayList<String>();
        for (String child : children) {
            if (filter.accept(this, child)) {
                filteredChildren.add(child);
            }
        }
        return filteredChildren;
    }
865023
public List<DistinctQueryResult> divide() {
        return Lists.newArrayList(Iterators.transform(resultData, new Function<QueryRow, DistinctQueryResult>() {
            
            @Override
            public DistinctQueryResult apply(final QueryRow row) {
                Set<QueryRow> resultData = new LinkedHashSet<>();
                resultData.add(row);
                return new DistinctQueryResult(columnLabelAndIndexMap, resultData.iterator());
            }
        }));
    }
999660
public FilterSpec normalize() {
        List<FilterSpec> clonedExpressions = expressions != null ? cloneExpressions(expressions, true) : null;

        FilterSpec copy = new FilterSpec(path, operator, value, clonedExpressions);
        return copy;
    }
846390
public List<Split<JobXMLDescriptor>> getAllSplit()
   {
      List<Split<JobXMLDescriptor>> list = new ArrayList<Split<JobXMLDescriptor>>();
      List<Node> nodeList = model.get("split");
      for(Node node: nodeList)
      {
         Split<JobXMLDescriptor>  type = new SplitImpl<JobXMLDescriptor>(this, "split", model, node);
         list.add(type);
      }
      return list;
   }
12762
private List<Filter<S>> findCoveringMatches() {
        List<Filter<S>> coveringFilters = null;

        boolean check = !mRemainderFilters.isEmpty()
            && (mIdentityFilters.size() > 0
                || mRangeStartFilters.size() > 0 
                || mRangeEndFilters.size() > 0);

        if (check) {
            // Any remainder property which is provided by the index is a covering match.
            for (Filter<S> subFilter : mRemainderFilters) {
                if (isProvidedByIndex(subFilter)) {
                    if (coveringFilters == null) {
                        coveringFilters = new ArrayList<Filter<S>>();
                    }
                    coveringFilters.add(subFilter);
                }
            }
        }

        return prepareList(coveringFilters);
    }