Al aan gedacht om aan te sluiten bij FunctionalJ (http://functionalj.sourceforge.net)? Misschien handig voor het maken van functie objecten.

Als ik het goed zie: is er dan ook een manier waarop je predicaten kunt “verzamelen” en dan uiteindelijk in 1 loop tegelijk toepassen? Dat zou namelijk meteen een performance-increase geven en ook de nay-sayers overtuigen…

Ik was bezig aan een refactor slag waar bij je meerdere predikaten kunt combineren tot een enkel filter; maar door wat vervelende eigenschappen van generics (kun je eigenlijk niet gebruiken in var-args) was ik nog niet tot een mooie oplossing gekomen.

Overigens moet je dit ook zien als een voorbeeld voor het bouwen van fluent interfaces, niet per definitie als _de_ oplossing voor alle collectie ‘problemen’.

Het voordeel van deze (of iedere aanpak die zorgt dat code DRY wordt) aanpak is trouwen dat dergelijke performance tweaks maar op één enkele plek plaats hoeven te vinden.

Bij het aanroepen van één van de resultaat functies (list, unique, scroll) wordt de uiteindelijk query opgebouwd en uitgevoerd

Nu snap ik waarom je zat te klagen over var-args en type safety etc. Het is inderdaad curieus dat je type safety warnings krijgt bij het maken van een getypede var-args parameter.
Maar in het kader van de Fluent-heid, kan je de BooleanPredicates toch ook chainen?

new BooleanPredicate().and(new BooleanPredicate()).or(new BooleanPredicate())?

Een final evaluate() methode zou dan zorg dragen voor de uiteindelijke return waarde.

Zelf zat ik ondertussen te denken een Filter klasse te introduceren die meerdere predikaten combineert:

public class Filter extends BooleanPredicate {
public List> predicates = new ArrayList>();
@Override
public boolean eval(T t) {
for(BooleanPredicate predicate : predicates){
if(predicate.eval(t) == false){
return false;
}
}
return true;
}

public static Filter with(BooleanPredicate firstPredicate){
Filter filter = new Filter();
return filter.and(firstPredicate);
}

public Filter and(BooleanPredicate predicate){
predicates.add(predicate);
return this;
}
}

Dit zou je dan als volgt kunnen gebruiken:

public class FilterTest extends TestCase {
public final List testData = Arrays.asList(”appel”, “aardappel”, “peer”, “sinaasappel”);

public void testFilterWithTwoPredicates(){
Collection result = from(testData).all(with(contains(”appel”)).and(doesNotContain(”sinaas”))).result();
assertEquals(2, result.size());
}

private BooleanPredicate contains(final String word){
return new BooleanPredicate() {
@Override
public boolean eval(final String t) {
return t.indexOf(word) > -1;
}
};
}

private BooleanPredicate doesNotContain(final String word){
return new BooleanPredicate() {
@Override
public boolean eval(final String t) {
return t.indexOf(word) == -1;
}
};
}
}

Maar ik moet zeggen dat ik nog niet helemaal gelukkig ben met het enorme hoeveelheid haakjes in de aanroep.

  public final BooleanPredicate<T> and(final BooleanPredicate<T> other) {
    if (other == null) {
      throw new IllegalArgumentException(\"other BooleanPredicate may not be null!\");
    }

    return new BooleanPredicate<T>() {
      @Override
      public boolean eval(T t) {
        return BooleanPredicate.this.eval(t) && other.eval(t);
      };
    };
  }

  public final BooleanPredicate<T> or(final BooleanPredicate<T> other) {
    if (other == null) {
      throw new IllegalArgumentException(\"other BooleanPredicate may not be null!\");
    }

    return new BooleanPredicate<T>() {
      @Override
      public boolean eval(T t) {
        return BooleanPredicate.this.eval(t) || other.eval(t);
      };
    };
  }

  public final BooleanPredicate<T> not() {
    return new BooleanPredicate<T>() {
      @Override
      public boolean eval(T t) {
        return !BooleanPredicate.this.eval(t);
      };
    };
  }

  /**
   * This method needs to be implemented.
   *
   * @param t
   *          The object to evaluate
   * @return true or false, depending on your needs
   */
  public abstract boolean eval(T t);
}

public void testFilterWithTwoPredicates() {
    Collection<String> result = from(testData).all(contains(\"appel\").and(doesNotContain(\"sinaas\"))).result();
    assertEquals(2, result.size());
  }

  public void testFilterWithThreePredicate() {
    Collection<String> result = from(testData).all((contains(\"appel\").and(doesNotContain(\"sinaas\"))).or(contains(\"peer\"))).result();
    assertEquals(3, result.size());
  }

  public void testTautologyPredicate() {
    BooleanPredicate<String> a = contains(\"appel\");
    BooleanPredicate<String> b = doesNotContain(\"peer\");

    BooleanPredicate<String> tautology = (a.and(b)).or(a.not()).or(b.not());

    Collection<String> result = from(testData).all(tautology).result();

    assertEquals(4, result.size());
  }

Toch zou ik er persoonlijk denk ik voor kiezen om een specifiek predicate (’MyFruitMatchingRule’) te schrijven voor de logica die nodig is in de all methode… zodat je gewoon zoiets kan doen:

from(testData).all(new MyFruitMatchingRule()).result();

Maar goed, we hadden het over voorbeelden natuurlijk