/** * Filter a single object.. * @param unfiltered The object to filter. * @return True if the object is accepted by the filter or the filter is null. * False otherwise. */ private boolean filterOk(Object unfiltered) { if (filter == null) return true; return filter.ok(unfiltered); }
/** * Filter a single object.. * @param unfiltered The object to filter. * @return True if the object is accepted by the filter or the filter is null. * False otherwise. */ private boolean filterOk(Object unfiltered) { if (filter == null) return true; return filter.ok(unfiltered); }
/** * INTERNAL: Filter a single object. * @param unfiltered The object to filter. * @return True if the object is accepted by the filter or the filter is null. * False otherwise. */ protected boolean filterOk(Object unfiltered) { if (filter == null) return true; return filter.ok(unfiltered); }
@Override public boolean ok(T object) { return !decider.ok(object); }
@Override public boolean ok(NavigatorPageIF contextTag, Object obj) { return decider.ok(obj); }
/** * Accepts or rejects a VariantNameIF * @param variantName to be accepted/rejected. * @return true iff variantName is accepted by the filter and its scope is * also accepted by the filter. */ public boolean ok(VariantNameIF variantName) { return filter.ok(variantName) && filter.ok(variantName.getScope()); }
protected void findNext() { // Loop over the remaining elements to find next applicable element. while (iterator.hasNext()) { T element = iterator.next(); // Check to see if element is acceptable. if (decider.ok(element)) { next = element; return; } } // There are no more elements and we're done. done = true; }
@Override public boolean ok(T object) { Iterator<DeciderIF<T>> iter = deciders.iterator(); while (iter.hasNext()) { DeciderIF<T> decider = iter.next(); if (!decider.ok(object)) return false; } return true; }
@Override public boolean ok(Object object) { Iterator iter = deciders.iterator(); while (iter.hasNext()) { DeciderIF decider = (DeciderIF)iter.next(); if (decider.ok(object)) return true; } return false; }
@Override public boolean ok(T object) { if (object == null) return false; if (cache.containsKey(object)) return cache.get(object).booleanValue(); boolean decision = decider.ok(object); if (decision == true) cache.put(object, Boolean.TRUE); else cache.put(object, Boolean.FALSE); return decision; }
@Override public Collection<T> filter(Iterator<T> objects) { // Initialize result List<T> result = new ArrayList<T>(); // Loop over the objects while (objects.hasNext()) { T object = objects.next(); // Add object to result if accepted by decider if (decider.ok(object)) result.add(object); } return result; }
/** * Return true iff the given topic, all of it's types and all types of the * types (etc. recursively) are accepted by the filter that was given in the * constructor. * @param topic The topic to test for acceptance. * @param checked Topics that have already been checked (passed). * @return true iff the topic is accepted. */ private boolean ok(TopicIF topic, Collection<TopicIF> checked) { // Only check each topic once. if (checked.contains(topic)) return true; if (topic == null) return true; if (filter.ok(topic)) checked.add(topic); else return false; return true; } }
@Override public boolean ok(ScopedIF scoped) { return scoped.getScope().isEmpty() || subdecider.ok(scoped); }
/** * Filter a whole collection of objects. * @param unfiltered The objects to filter. * @return A new collection containing all objects accepted by the filter, or * if this.filter is null, returns the original collection. */ private Collection filterCollection(Collection unfiltered) { if (filter == null) return unfiltered; Collection retVal = new ArrayList(); Iterator unfilteredIt = unfiltered.iterator(); while (unfilteredIt.hasNext()) { Object current = unfilteredIt.next(); if (filter.ok(current)) retVal.add(current); } return retVal; }
/** * Filter a whole collection of objects. * @param unfiltered The objects to filter. * @return A new collection containing all objects accepted by the filter, or * if this.filter is null, returns the original collection. */ protected Collection filterCollection(Collection unfiltered) { if (filter == null) return unfiltered; Collection retVal = new ArrayList(); Iterator unfilteredIt = unfiltered.iterator(); while (unfilteredIt.hasNext()) { Object current = unfilteredIt.next(); if (filter.ok(current)) retVal.add(current); } return retVal; }
@Override public boolean ok(T object) { return decider.ok(stringifier.toString(object)); }
/** * Filter a whole collection of objects. * @param unfiltered The objects to filter. * @return A new collection containing all objects accepted by the filter, or * if this.filter is null, returns the original collection. */ private <E> Collection<E> filterCollection(Collection<E> unfiltered) { if (filter == null) return unfiltered; Collection<E> retVal = new ArrayList<E>(); Iterator<E> unfilteredIt = unfiltered.iterator(); while (unfilteredIt.hasNext()) { E current = unfilteredIt.next(); if (filter.ok(current)) retVal.add(current); } return retVal; }
@Override public boolean ok(T object) { return decider.ok(grabber.grab(object)); }
/** * Refreshes the collection by looping over the nested collection * and regrabbing its items. Any changes done to the previous * collection will be lost. */ @Override public void refresh() { grabbed_coll = new ArrayList<G>(); Iterator<O> iter = coll.iterator(); while (iter.hasNext()) { G grabbed = grabber.grab(iter.next()); // Add grabbed to the grabbed collection if accepted by the decider if (decider == null || decider.ok(grabbed)) grabbed_coll.add(grabbed); } grabbed = true; }