Heiner Kücker

Codegenerator für hierarchische Datenstrukturen

Home

Java-Seite

. Weiterentwicklung_Java

. WebCam_Demo

. JSP WorkFlow
. PageFlow FlowControl
. Page Flow Engine
. Web Flow Engine
. Control_and_Command

. JSP_Spreadsheet

. Kognitions-Maschine
. semantisches Netz

. Domain Parser

. Codegenerator_für
. hierarchische
. Datenstrukturen

. Expression_Engine
. Formula_Parser

. Thread Preprocessor

. State Transition Engine

. AspectJ

. Java_Explorer

. DBF_Library

. Kalender_Applet

. SetGetGen

. BeanSetGet

. CheckPackage

. LineNumbers

. GradDms

. Excel-Export

. StringTokenizer

. JspDoc

. JspCheck

. JSP-Schulung
. Java Server Pages
. Struts

. Ascii-Tabellen-
. Layouter

. Ascii-Baum-
. Layouter

. Ascii-Art-Fluss-
. Diagramm-
. Parser

. AsciiArt
. AssignmentMatrix
. Layouter

. StringSerial

. Silbentrennung

. JDBC_Schlüssel-
. Generierung

. bidirektional/
. unidirektional
. gelinkte Liste

. Java_Sitemap
. Generator

. XmlBuilder

. RangeMap

. StringFormatter

. VersionSafe
. XCopy

. JTextField

. CommandLine-
. ParamReader

. Bitmap-Grafik

. MultiMarkable-
. Buffered-
. InputStream

. JavaCache

. JdomUtil

. CollectionUtil

. XML Really
. Pull Parser

. Log-Filter

. Remote-Protokoll

. Sudoku-Generator

. Delegation statt
. Mehrfachvererbung

. Disjunct
. Interval Set

. Constraint Class

. Code Generator

Alaska-XBase++-Seite

Projekte

Philosophien
Techniken

Konzepte

Sudoku

Kontakt /
Impressum

Links

SiteMap

Letzte Aktualisierung:
19.02.2005

Codegenerator für hierarchische Datenstrukturen

Code generation for hierarchic data structures

Dieser kleine Codegenerator ist ein Beispiel für die Anwendung des Domain Parser's (Parser für fachspezifische Sprachen,domain specific languages).

Der Codegenerator erzeugt für hierarchische Datenstrukturen, die in einer Definitionsdatei beschrieben werden, alle notwendigen Klassen und ein Code-Artefakt zum Erzeugen sowie ein Code-Artefakt zum Durchlaufen (Abarbeiten) der generierten Struktur.

Insofern ist er eine Anwendungs-Form der Model Driven Architecture (MDA).

Die zu erzeugenden Strukturen werden baumförmig beschrieben, der Codegenerator wandelt diese baumförmige Struktur in eine flache Java-Klassen-Struktur um.

Ich kenne solche Strukturen als Wiederspiegelung fachlicher Sachverhalte.

Die entsprechenden Java-Klassen sind oft schwierig manuell zu erstellen.

Dazu kommt das Problem, dass sich der Kern der Struktur von fachlicher Seite nicht erfassen lässt (Die Auftraggeber machen es schon jahrelang, können es aber nicht klar erklären, wollen aber ein fertiges Programm).

Wenn die erstellte Struktur dann noch mit Code vermischt ist und in einem iterativen Lernprozess von fachlicher und technischer Seite überarbeitet werden muss, ist die Not gross.

Mit meinem Codegenerator kann man die Definiton der Struktur leicht überblicken, ändern und den notwendigen Code jederzeit neu erzeugen.

Die Notation ist Java-ähnlich gehalten und hoffentlich leicht zu verstehen.

Der Generator erzeugt Java-Klassen, bietet also im Gegensatz zu XML-DOM oder irgendwelchen ungetypten List- oder Map-Strukturen komplette Compilerprüfung.

Es gibt vier mögliche Arten der zu generierenden Strukturen (Klassen):

simple Strukturen (terminal), keine Liste: Klassenname Variablenname;
simple Strukturen (terminal), Liste: Klassenname[] Variablenname;
komplexe Strukturen (nicht terminal), keine Liste: Klassenname Variablenname { Unterstruktur }
komplexe Strukturen (nicht terminal), Liste: Klassenname[] Variablenname { Unterstruktur }

Für simple Strukturen (enden in der Definition mit einem Semikolon) werden keine Klassen generiert.

Für komplexe Strukturen (definieren eine in geschwungene Klammern eingeschlossene Unterstruktur) werden Klassen generiert.

Nicht als Liste definierte Strukturen werden als Variablen mit set- und get-Methoden in den generierten Klassen hinterlegt.

Listen (gekennzeichnet durch paaarweise eckige Klammern [] hinter dem Klassen-Namen) werden als ArrayList mit add-, getXxxCount- und getXxx(index)-Methoden in den generierten Klassen hinterlegt.

Die hierarchische Datenstruktur wird in folgender Notation in einer Definitionsdatei Haus.strudef hinterlegt. Dabei ist das Beispiel Haus nur eine angenommene hierarchische Datenstruktur:

/** Haus dient hier nur als Beispiel einer hierarchischen Datenstruktur */
Haus haus // Wurzel der Strukturdefinition, nicht terminaler Typ
{
    /** Bezeichnung */
    String bezeichnung; // terminaler Typ

    /** Etage */
    Etage[] etagen // nicht terminaler Typ, Liste
    {
        /** Level der Etage beginnend bei 0 */
        int level; // terminaler Typ

        /** Wohnung */
        Wohnung[] wohnungen // nicht terminaler Typ, Liste
        {
            /** Bezeichnung */
            String bezeichnung; // terminaler Typ

            /** Einwohner */
            Person[] einwohner; // terminaler Typ, Liste

            /** Raum */
            Raum[] raueme // nicht terminaler Typ, Liste
            {
                String bezeichnung; // terminaler Typ
                double breite; // terminaler Typ
                double laenge; // terminaler Typ
            }
        }
    }
    /** Keller */
    Keller keller // nicht terminaler Typ, keine Liste
    {
        /** KellerRaum */
        KellerRaum[] kellerRaueme // nicht terminaler Typ, Liste
        {
            String bezeichnung; // terminaler Typ
            Wohnung gehoertZuWohnung;
            double breite; // terminaler Typ
            double laenge; // terminaler Typ
        }
    }
}
/** Person */
Person person // Wurzel der Strukturdefinition, nicht terminaler Typ
{
    String nachName;
    String vorName;
    boolean isWeiblich;
    boolean isKind;
}

Haus.strudef

In obigem Beispiel erzeugt der Codegenarator die Klassen Haus, Etage, Wohnung, Raum, Keller, KellerRaum und Person.

Im Zip-File Hierarchy.zip mit dem Quellcode sind die generierten Java-Klassen für das Haus-Beispiel enthalten.

Die erzeugten Klassen bilden eine Komposition, eine Sonderform der Aggregation (Composite-Pattern).

In der jetzigen Version bietet der Codegenerator noch reichlich Raum für Verbesserungen.

So könnte man für die Erzeugung des Codes eine Template-Engine verwenden.

Durch eigene Schlüsselwörter wäre es möglich die Code-Erzeugung besser zu steuern.

Denkbar sind zum Beispiel immutable Klassen (alle Werte werden im Konstruktor gesetzt und stehen danach nur noch lesend (get-Methoden) zur Verfügung).

Sicher wird der zu erzeugende Code je nach Projektumfeld variieren.

Für diesen Zweck kann sich der geschätzte Benutzer meinen Code relativ leicht anpassen.

Download der Quelldateien und des Haus-Beispiels Hierarchy.zip

Mitgelieferte Dateien:

HierarchicDataGenerator.java	Java-Quellcode
Haus.strudef	Strukturdefinition
/output/*.java	erzeugte Java-Klassen

Zum Kompilieren und Starten des Codegenerators müssen noch die Sourcen des DomainParser's eingebunden werden.

Achtung: Erweiterungen und Fixes stelle ich ohne Historie und ohne Ankündigung hier bereit.
Deshalb am besten immer die letzte Version runterladen.

Lizenzbedingungen:

Die Programme, Quelltexte und Dokumentationen können ohne irgendwelche Bedingungen kostenlos verwendet werden.
Sie sind Freeware und Open Source. Für Fehler und Folgen wird keinerlei Haftung übernommen.

Hinweise zur Fehlerbeseitigung und Verbesserung sind mir willkommen.

Ich freue mich auch über Feedback bezüglich der erfolgreichen Verwendung meiner Sourcen.

Bei Fragen helfe ich gern mit Hinweisen oder zusätzlicher Dokumentation, falls ich dafür Zeit habe.