Bedingungen abstrahieren

Man hat eine Bedingung, deren Einhaltung man prüfen muss und damit verbunden hat man immer das gleiche Muster:
Java:
int x = userInput();
if( x <= 5 ) {
    String msg = "x muss größer als 5 sein, ist aber '" + x + "'";
    log.warn(msg)
    throw new IllegalStateException(msg);
} else {
    return x + 9;
}
Was mich stört ist die Bedingung sowohl im if als auch in der Nachricht (wahlweise als Exception, Anzweige auf der View oder Logging). Warum nicht in etwas wie dieses Konstrukt verpacken, wobei sich die Condition intern um das Logging kümmert (Bedingung und eigentlicher Wert).

Java:
int x = userInput();
Condition c = Condition.greaterThanOrEqual(5, "%d muss größer als $1 sein");
return c.testOrThrow(x).andThen(() -> return x + 9);
Conditions sollten so gestaltet sein, dass man Ausdrücke bilden kann. Ich kenne das bereits von JavaFX Bindings.
Java:
int x = userInput();
Condition c = Condition.and(
                Condition.greaterThanOrEqual(5, "%d muss größer als $1 sein")
                otherCondition);
return c.testOrThrow(x).andThen(() -> return x + 9);
Vor allem, wenn man Prädikate einsetzt geht die Information verloren, warum ein Element gefiltert wurde. Das erschwert das Debugging meiner Meinung nach.
Java:
Predicate<Integer> greaterThanOrEqual = i -> i >= 5;
List<Integer> ints = IntStream.iterate(0, i -> i+1)
                              .limit(10)
                              .boxed()
                              .collect(toList());
Schöner wäre so ein Konstrukt. Wo auch das Logging intern wieder erfolgt und test()-Aufrufe eines Prädikats, die false zurückliefern, loggt mit Bedingung und eigentlichem Wert.
Java:
Condition c = Condition.greaterThanOrEqual(5, "%d muss größer als $1 sein");
List<Integer> filteres = ints.stream()
                                 .filter(c)
                                 .collect(toList());
return c.testOrThrow(x).andThen(() -> return x + 9);
Kennt jemand einen bestehenden Ansatz/Lib dafür? Ich lande bei Recherchen immer bei Constraint Programming, was jedoch die falsche Richtung ist.
 
Ist die Idee zu bescheuert oder war die Erklärung nicht nachvollziehbar? Im vorletzten Beispiel fehlt natürlich der filter(greaterThanOrEqual)-Aufruf, habe ich bemerkt.
 
Das Problem an der Sache sind IMO Verknüpfungen, die den Sinn der Meldung verändern können wie z. B. negate() und or(). Ansonsten dürfte das relativ einfach umzusetzen sein.
 
Ich hatte tatsächlich schon angefangen was eigenes zu stricken, aber schnell gemerkt, wie umfangreich es wird. Ich kann es mir auf jeden Fall nicht aus dem Ärmel schütteln sondern müsste noch viel dazulernen, bevor ich es hinbekomme. Problem ist vor allem es generisch für alle möglichen Datentypen zu machen. Außerdem sehe ich Parallelen zu libs wie AssertJ.
 
Ich finde das Problem interessant, verstehe es aber nicht so richtig.

Das, was du beschreibst, würde ich ganz naiv so erschlagen (aber darauf wäre doch sicher jeder selbst gekommen?):
Java:
abstract class ConditionProcessor{
    public boolean process();
}

public class UserinputProcessor extends ConditionProcessor{
    final boolean userinputLessThanFive;
    
    public UserinputProcessor(String input){
        userinputLessThanFive = input.toDouble < 5; //Hab auf die Schnelle vergessen wie man einen String zu int konvertiert
    }
    
    @Override
    public boolean process(){return userinputLessThanFive;}
}
Wahlweise könnte man noch die process()-Methode mit einem Parameter ausstatten, um mehrere Bedingungen auszuwerten.

Außerdem sehe ich Parallelen zu libs wie AssertJ.
Ich weiß nicht was AssertJ macht, aber ich würde eine Bibliothek nicht für Zwecke mißbrauchen, für die sie nicht geschaffen ist. Auch wenn es logisch gehen würde, ist der Quellcode dann gar gräßlich zu lesen. Und wehe, man muß da irgendwann mal wieder ran.
 
Das, was du beschreibst, würde ich ganz naiv so erschlagen (aber darauf wäre doch sicher jeder selbst gekommen?):
Ja, das deckt den einfachsten Fall ab, die Evaluation einer einfachen Bedingung zu abstrahieren. Jedoch ist das Problem:
Problem ist vor allem es generisch für alle möglichen Datentypen zu machen.
Ich weiß nicht was AssertJ macht, aber ich würde eine Bibliothek nicht für Zwecke mißbrauchen
Ich habe nur gesagt, dass ich parallelen zu AssertJ sehe, da diese Library im Grunde eben (sinnvolle) Assertions für alle möglichen Datentypen anbietet. Der Aufbau wird sehr ähnlich sein.
 
Ja, das deckt den einfachsten Fall ab, die Evaluation einer einfachen Bedingung zu abstrahieren. Jedoch ist das Problem:
Problem ist vor allem es generisch für alle möglichen Datentypen zu machen.
Müsste man einfach mal versuchen, grundsätzlich sieht das schon machbar aus. Für ein MVP kann man es ja erstmal auf einen konkreten Typen beschränken, zB Integer. Dann sieht man schon mal die ersten Schwierigkeiten, die es gibt und kann nachher immer noch abstrahieren.

Ich habe nur gesagt, dass ich parallelen zu AssertJ sehe, da diese Library im Grunde eben (sinnvolle) Assertions für alle möglichen Datentypen anbietet. Der Aufbau wird sehr ähnlich sein.
Jein, der Aufbau dort kennt keinerlei Verknüpfungen, jede Assertion steht für sich, das funktioniert schon grundsätzlich anders.
 
Müsste man einfach mal versuchen, grundsätzlich sieht das schon machbar aus.
Ich habe es versucht, kam aber nicht weiter und hatte bisher keine Zeit weiter zu probieren. Ich hoffe, dass ich bald weiterkomme und konkrete Fragen/Probleme dazu formulieren kann.

Jein, der Aufbau dort kennt keinerlei Verknüpfungen, jede Assertion steht für sich, das funktioniert schon grundsätzlich anders.
Ich meinte, dass der Aufbau der Lib, für alle möglichen Datentypen passende Assertions bereitzustellen dort ebenfalls angegangen wurde. Ebenso werden die Assertions in hilfreiche Ausgaben Umgewandelt. In der Hinsicht kann man sich da vermutlich etwas abschauen. Ja, Verknüpfungen sind dort nicht vorhanden.
 
Zuletzt bearbeitet:
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben