Enum für Bedingung B01

enums b01 01

Ausgangslage

Für die Bedingung B01 werden standardmäßig 2 Methoden für die ersten beiden Bedingungswerte generiert:

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * <b>B01/01: &lt; 20,00 - gering</b>
 */
boolean isBestellwert_Kleiner2000();

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * <b>B01/02: 20,00 - 75,00 - normal</b>
 */
boolean isBestellwert_20007500();

Jetzt soll für diese Bedingung nur noch eine Methode generiert und die Werte als Enum übergeben werden.

Erweiterung der Konfiguration

Da diese Konfigurationserweiterungen gezielt nur für die Entscheidungstabelle gedacht sind, werden sie in einer neuen Konfigurationsdatei für die Entscheidungstabelle definiert. Sie hat denselben Namen wie die Entscheidungstabelle, allerdings ergänzt um die Dateiendung ".yaml":

config et 01

Die Entscheidungstabellen-Konfiguration resources/lfet/demo/Rechnungsbetrag.lfet.yaml erhält die folgenden Einträge:

lfet:                          # 1)

  ide:
    java:

      interface.enum:          # 2)
        1:
          symbol: Intervall
          include.tags.title: Bestellwert
          exclude.tags.title: Rabatt

Die Einträge im Detail

1) lfet:: Der Basis-Eintrag in allen YAML-Konfigurationsdateien für LF‑ET.

2) ide.java.interface.enum:

1:: Die Enum-Definitionen werden nummeriert, hier beginnt die Enum-Definition Nr. 1

symbol: Intervall: Das Enum soll das Symbol des Wertes enthalten, zusätzlich soll jeweils aus dem Symbol ein Intervall abgeleitet werden (Unter- und Obergrenze), inkl. passender Zugriffs‑ und Auswertungsmethoden.

include.tags.title: Bestellwert: Eine Liste von Schlüsselworten, von denen mindestens eines im Titel der Bedingung oder Aktion vorkommen muss, damit diese Enum-Definition bei der Generierung verwendet wird.

Zu Bestellwert passen B01 und B04:
exclude.tags.title: Rabatt: Eine Liste von Schlüsselworten, von denen keines im Titel der Bedingung oder Aktion vorkommen darf, damit diese Enum-Definition bei der Generierung verwendet wird.

Mit Rabatt wird B04 ausgeschlossen.

Geschmackssache:

Da in diesem Beispiel die Parameterlisten (Interval, Bestellwert, Rabatt) jeweils nur ein Element enthalten, wurden die Werte hier nicht als Liste, sondern als einfaches Argument angegeben
Bei Listen in YAML hat man mit LF-ET die Wahl, ob man die Elemente der Liste
- entweder als YAML-Aufzählung, d.h. jeweils mit vorangestelltem Minus-Zeichen in einer eigenen Zeile,
- oder durch Komma getrennt, als Argument in einer Zeile angibt

Ergebnisse für B01

Nur noch eine Methode

Nicht mehr für jeden Bedingungs-Wert eine Methode
Sondern nur noch eine Methode für die Bedingung
Die Werte werden jeweils als Enum übergeben

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * The enum generation has been triggered in project.ini by:<br>
 * - <b>ide.java.interface.enum.1</b>: symbol=Intervall; include.tags.title=Bestellwert; exclude.tags.title=Rabatt
 */
boolean isEnum(Rechnungsbetrag_iFace.Bestellwert arg0);

Ein Enum

Für jeden Bedingungswert ein Enum-Wert
Bei Bedingungen nicht für den letzten Wert (hier >75), da für diesen immer ein ELSE-Zweig generiert wird
Werden in der Anwendung alle Werte der Bedingung benötigt, so kann dies über den Schlüssel interface.enum.options: allValues festgelegt werden
Zusätzlich werden in diesem Beispiel bei der Generierung fachliche Informationen aus der Entscheidungstabelle übernommen:
- Das Symbol des Wertes als String
- Unter- und Obergrenzen der Intervalle, die Anzahl der gewünschten Nachkommastellen wird dabei automatisch ermittelt
- Inklusive dazugehöriger GETTER- und Auswertungsmethoden
Fachliche Daten werden so automatisch maschinenverarbeitbar

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * The enum generation has been triggered in project.ini by:<br>
 * - <b>ide.java.interface.enum.1</b>: symbol=Intervall; include.tags.title=Bestellwert; exclude.tags.title=Rabatt
 */
enum Bestellwert
{
    /**
     * <b>B01: Bestellwert</b><br>
     * <br>
     * <b>B01/01: &lt; 20,00 - gering</b>
     */
    $001("< 20,00", Double.NEGATIVE_INFINITY, 19.99),

    /**
     * <b>B01: Bestellwert</b><br>
     * <br>
     * <b>B01/02: 20,00 - 75,00 - normal</b>
     */
    $002("20,00 - 75,00", 20.0, 75.0);

    private final String symbol;
    private final double symbolMin;
    private final double symbolMax;

    Bestellwert(String symbol, double symbolMin, double symbolMax)
    {
        this.symbol = symbol;
        this.symbolMin = symbolMin;
        this.symbolMax = symbolMax;
    }

    public String getSymbol()
    {
        return symbol;
    }

    public double getSymbolMin()
    {
        return symbolMin;
    }

    public double getSymbolMax()
    {
        return symbolMax;
    }

    public boolean isInSymbolInterval(double d)
    {
        return d >= symbolMin && d <= symbolMax;
    }

    public boolean isInSymbolInterval(int i)
    {
        return i >= symbolMin && i <= symbolMax;
    }
}

Anpassung der Implementierung

Dies ist die einzige manuelle Anpassung, alles andere wird automatisch generiert.

Vorher: 2 Methoden für B01

In der ursprünglichen Version mussten für die Bedingung B01 noch 2 Methoden implementiert werden:

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * <b>B01/01: &lt; 20,00 - gering</b>
 */
@Override
public boolean isBestellwert_Kleiner2000() {
    return model.getBestellwert().compareTo(bigDecimal(20.00)) < 0;
}

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * <b>B01/02: 20,00 - 75,00 - normal</b>
 */
@Override
public boolean isBestellwert_20007500() {
    return model.getBestellwert().compareTo(bigDecimal(20.00)) >= 0 &&
            model.getBestellwert().compareTo(bigDecimal(75.00)) <= 0;
}

vertical space 05px

Jetzt: Nur noch eine Methode

Durch die Enum-Generierung ist jetzt nur noch eine Methode notwendig:

/**
 * <b>B01: Bestellwert</b><br>
 * <br>
 * <b>B01/01: &lt; 20,00 - gering</b>
 */
@Override
public boolean isEnum(Rechnungsbetrag_iFace.Bestellwert arg0) {
    return model.getBestellwert().compareTo(bigDecimal(arg0.getSymbolMin())) >= 0 &&
           model.getBestellwert().compareTo(bigDecimal(arg0.getSymbolMax())) <= 0;
}

vertical space 05px

Automatisch angepasste Methoden-Aufrufe im Regelmodul

So sehen die neu generierten Methodenaufrufe im Regelmodul jetzt aus:

if (iface.isEnum(Rechnungsbetrag_iFace.Bestellwert.$001) /* < 20,00 - gering */)
{
    // Rule R01 ---->

    iface.doTrace("Rechnungsbetrag", "20260224.141242", 7, 1);

    iface.doPortoBerechnen();
    iface.doRechnungsbetrag_Akt();

    // Rule R01 <----
}
else if (iface.isEnum(Rechnungsbetrag_iFace.Bestellwert.$002) /* 20,00 - 75,00 - normal */)
{

Vorteile

Mit Enums kann die Implementierung und Pflege der Methoden für Bedingungen und Aktionen deutlich effizienter und sicherer erfolgen:
- anstatt einer Implementierung pro Wert
- jetzt nur noch eine Implementierung pro Bedingung oder Aktion
In vielen Fällen können fachliche Änderungen an den Werten in der Entscheidungstabelle rein über die Enums und das Regelmodul abgebildet werden, so dass die Implementierungen der Methoden davon nicht betroffen sind
- Änderung von Zahlenwerten oder anderen Inhalten
- Neue oder gelöschte Werte
- etc.
fachliche Daten können bei der Generierung leistungsstark und sicher in die Anwendung übernommen werden, wie z.B. Zahlen, Zahlenreihen, Intervalle, Texte, etc.

Enum für Bedin­gung B01