Heiner Kücker

Codegenerator für hierarchische Datenstrukturen

Home

Java-Seite

   ASM Improved

   heterogene
   Map, HMap

   Constraint
   Code Generator

   JSP WorkFlow
   PageFlow FlowControl
   Page Flow Engine
   Web Flow Engine
   Control_and_Command

   JSP_Spreadsheet

   Code-Generator
   für Option-Either-Stil
   in Java

   verbesserter
   Comparator

   Fluent-Interface
   Code-Generator
   auf Basis
   einer Grammatik

   Visitor mit Multidispatch

   for-Schleife mit
   yield-return

   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

   WebCam_Demo

   Weiterentwicklung_Java

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.javaJava-Quellcode
Haus.strudefStrukturdefinition
/output/*.javaerzeugte 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.