Contents

Einführung

Ziel der Vorlesung

Chapter 1
Erweiterungen in Java 1.5

1.1  Einführung

• Beim Entwurf und der Entwicklung von Java waren die Entwickler bei Sun unter Zeitdruck.
• Die Sprache Java wurde in ihren programmiersprachlichen Konstrukten sehr konservativ entworfen. Die Syntax wurde von C übernommen. Die Sprache sollte möglichst wenige aber mächtige Eigenschaften haben und kein Sammelsurium verschiedenster Techniken sein.

1.2  Generische Typen

1.2.1  Generische Klassen

class OldBox {
  Object contents;
  OldBox(Object contents){this.contents=contents;}
}

class UseOldBox{
  public static void main(String [] _){
    OldBox b = new OldBox("hello");
    String s = (String)b.contents;
    System.out.println(s.toUpperCase());
    System.out.println(((String) s).toUpperCase());
  }
}

class UseOldBoxError{
  public static void main(String [] _){
    OldBox b = new OldBox(new Integer(42));
    String s = (String)b.contents;
    System.out.println(s.toUpperCase());
  }
}

sep@linux:~/fh/java1.5/examples/src> javac UseOldBoxError.java
sep@linux:~/fh/java1.5/examples/src> java UseOldBoxError
Exception in thread "main" java.lang.ClassCastException
        at UseOldBoxError.main(UseOldBoxError.java:4)
sep@linux:~/fh/java1.5/examples/src>

class Box<elementType> {
  elementType contents;
  Box(elementType contents){this.contents=contents;}
}

class UseBox{
  public static void main(String [] _){
    Box<String> b1 = new Box<String>("hello");
    String s = b1.contents;
    System.out.println(s.toUpperCase());
    System.out.println(b1.contents.toUpperCase());

    Box<Integer> b2 = new Box<Integer>(new Integer(42));

    System.out.println(b2.contents.intValue());
  }
}

class UseBoxError{
  public static void main(String [] _){
    Box<String> b = new Box<String>(new Integer(42));
    String s = b.contents;
    System.out.println(s.toUpperCase());
  }
}

sep@linux:~/fh/java1.5/examples/src> javac UseBoxError.java
UseBoxError.java:3: cannot find symbol
symbol  : constructor Box(java.lang.Integer)
location: class Box<java.lang.String>
    Box<String> b = new Box<String>(new Integer(42));
                    ^
1 error
sep@linux:~/fh/java1.5/examples/src>

Vererbung

class Pair<at,bt> extends Box<at>{
  Pair(at x,bt y){
    super(x);
    snd = y; 
  }

  bt snd;

  public String toString(){
    return "("+contents+","+snd+")";
  }
}

class UsePair{
  public static void main(String [] _){
    Pair<String,Integer> p
     = new Pair<String,Integer>("hallo",new  Integer(40));
    
    System.out.println(p);
    System.out.println(p.contents.toUpperCase());
    System.out.println(p.snd.intValue()+2);
  }
}

sep@linux:~/fh/java1.5/examples/classes> java UsePair
(hallo,40)
HALLO
42
sep@linux:~/fh/java1.5/examples/classes>

class UniPair<at> extends Pair<at,at>{
  UniPair(at x,at y){super(x,y);}
  void swap(){
    final at z = snd;
    snd = contents;
    contents = z;
  }
}

class UseUniPair{
  public static void main(String [] _){
    UniPair<String> p
     = new UniPair<String>("welt","hallo");
    
    System.out.println(p);
    p.swap();
    System.out.println(p);
  }
}

sep@linux:~/fh/java1.5/examples/classes> java UseUniPair
(welt,hallo)
(hallo,welt)
sep@linux:~/fh/java1.5/examples/classes>

class StringBox extends Box<String>{
  StringBox(String x){super(x);}
}

class UseStringBox{
  public static void main(String [] _){
    StringBox b = new StringBox("hallo");
    System.out.println(b.contents.length());
  }
}

Einschränken der Typvariablen

class CollectMaxOld{
  private Comparable value;

  CollectMaxOld(Comparable x){value=x;}

  void setValue(Comparable x){
    if (value.compareTo(x)<0) value=x;
  }

  Comparable getValue(){return value;}
}

class CollectMax <elementType extends Comparable>{
  private elementType value;

  CollectMax(elementType x){value=x;}

  void setValue(elementType x){
    if (value.compareTo(x)<0) value=x;
  }

  elementType getValue(){return value;}
}

class UseCollectMax {
  public static void main(String [] _){
    CollectMax<String> cm = new CollectMax<String>("Brecht");
    cm.setValue("Calderon");
    cm.setValue("Horvath");
    cm.setValue("Shakespeare");
    cm.setValue("Schimmelpfennig");
    System.out.println(cm.getValue().toUpperCase());
  }
}

1.2.2  Generische Schnittstellen

Äpfel mit Birnen vergleichen

interface EQ<otherType> {
  public boolean eq(otherType other);
}

class Apfel implements EQ<Apfel>{
  String typ;

  Apfel(String typ){
    this.typ=typ;}

  public boolean eq(Apfel other){
    return this.typ.equals(other.typ); 
  }    
}

class TestEq{
  public static void main(String []_){
    Apfel a1 = new Apfel("Golden Delicious");
    Apfel a2 = new Apfel("Macintosh");
    System.out.println(a1.eq(a2));
    System.out.println(a1.eq(a1));
  }
}

class Birne implements EQ<Birne>{
  String typ;

  Birne(String typ){
    this.typ=typ;}

  public boolean eq(Birne other){
    return this.typ.equals(other.typ); 
  }    
}

class TesteEqError{
  public static void main(String []_){
    Apfel a = new Apfel("Golden Delicious");
    Birne b = new Birne("williams");
    System.out.println(a.equals(b));
    System.out.println(a.eq(b));
  }
}

./TestEQError.java:6: eq(Apfel) in Apfel cannot be applied to (Birne)
    System.out.println(a.eq(b));
                        ^
1 error

class BirneError implements EQ<Apfel>{
  String typ;

  BirneError(String typ){
    this.typ=typ;}

  public boolean eq(Birne other){
    return this.typ.equals(other.typ); 
  }    
}

sep@linux:~/fh/java1.5/examples/src> javac BirneError.java
BirneError.java:1: BirneError is not abstract and does not override abstract method eq(Apfel) in EQ
class BirneError implements EQ<Apfel>{
^
1 error
sep@linux:~/fh/java1.5/examples/src>

1.2.3  Kovarianz gegen Kontravarianz

class Kontra{
  public static void main(String []_){
    Box<Object> b  = new Box<String>("hello");
  }
}

sep@linux:~/fh/java1.5/examples/src> javac Kontra.java
Kontra.java:4: incompatible types
found   : Box<java.lang.String>
required: Box<java.lang.Object>
    Box<Object> b  = new Box<String>("hello");
                     ^
1 error
sep@linux:~/fh/java1.5/examples/src>

class Ko{
  public static void main(String []_){
    String [] x = {"hello"};
    Object [] b  = x;
    b[0]=new Integer(42);
    x[0].toUpperCase();
  }
}

sep@linux:~/fh/java1.5/examples/classes> java Ko
Exception in thread "main" java.lang.ArrayStoreException
        at Ko.main(Ko.java:5)
sep@linux:~/fh/java1.5/examples/classes>

1.2.4  Sammlungsklassen

import java.util.*;
import java.util.List;
class ListTest{
  public static void main(String [] _){
    List<String> xs = new ArrayList<String>();
    xs.add("Schimmelpfennig");
    xs.add("Shakespeare");
    xs.add("Horvath");
    xs.add("Brecht");
    String x2 = xs.get(1);
    System.out.println(xs);
  }
}

import java.util.*;
import java.util.List;
class WarnTest{
  public static void main(String [] _){
    List xs = new ArrayList<String>();
    xs.add("Schimmelpfennig");
    xs.add("Shakespeare");
    xs.add("Horvath");
    xs.add("Brecht");
    String x2 = (String)xs.get(1);
    System.out.println(xs);
  }
}

sep@linux:~/fh/java1.5/examples/src> javac WarnList.java
Note: WarnList.java uses unchecked or unsafe operations.
Note: Recompile with -warnunchecked for details.
sep@linux:~/fh/java1.5/examples/src>

1.2.5  Generische Methoden

class Trace {

  static <elementType>  elementType trace(elementType x){
    System.out.println(x);
    return x;
  }
  
  public static void main(String [] _){
    String x = trace ((trace ("hallo")
                      +trace( " welt")).toUpperCase());

    Integer y = trace (new Integer(40+2));
  }
}

1.3  Iteration

Beispiel:
In diesen Beispiel finden sich die zwei wahrscheinlich am häufigsten programmierten Schleifentypen. Einmal iterieren wir über alle Elemente einer Reihung und einmal iterieren wir mittels eines Iteratorobjekts über alle Elemente eines Sammlungsobjekts:

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

class OldIteration{

  public static void main(String [] _){
    String [] ar
      = {"Brecht","Horvath","Shakespeare","Schimmelpfennig"};
    List xs = new ArrayList();

    for (int i= 0;i<ar.length;i++){
      final String s = ar[i];
      xs.add(s);
    }  
 
    for (Iterator it=xs.iterator();it.hasNext();){
      final String s = (String)it.next();
      System.out.println(s.toUpperCase());
    }
  }
}

Beispiel:
Damit lassen sich jetzt die Iterationen der letzten beiden Schleifen wesentlich eleganter ausdrücken.

import java.util.List;
import java.util.ArrayList;

class NewIteration{

  public static void main(String [] _){
    String [] ar
     = {"Brecht","Horvath","Shakespeare","Schimmelpfennig"};
    List<String> xs = new ArrayList<String>();

    for (String s:ar) xs.add(s); 
    for (String s:xs) System.out.println(s.toUpperCase());
  }
}

1.3.1  Die neuen Schnittstellen Iterable

Beispiel:

package sep.util.io;

import java.io.Reader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Iterator;


public class ReaderIterator 
              implements Iterable<Character>
                        ,Iterator<Character>{
  private Reader reader;
  private int n;
  public ReaderIterator(Reader r){
    reader=new BufferedReader(r);
    try{n=reader.read();
    }catch(IOException _){n=-1;}
  }
  public Character next(){
    Character result = new Character((char)n);   
    try{n=reader.read();
    }catch(IOException _){n=-1;}
    return result;
  }

  public boolean hasNext(){
    return n!=-1;
  }

  public void remove(){
    throw new UnsupportedOperationException();
  }

  public Iterator<Character> iterator(){return this;}
}

import sep.util.io.ReaderIterator;
import java.io.FileReader;

class TestReaderIterator {
  public static void main(String [] args) throws Exception{
      Iterable<Character> it
        =new ReaderIterator(new FileReader(args[0]));
      for (Character c:it){
      System.out.print(c);
    }
  }
}

Beispiel:
Ein abschließendes kleines Beispiel für generische Sammlungsklassen und die neue for-Schleife. Die folgende Klasse stellt Methoden zur Verfügung, um einen String in eine Liste von Wörtern zu spalten und umgekehrt aus einer Liste von Wörtern wieder einen String zu bilden:

import java.util.*;
import java.util.List;

class TextUtils {

  static List<String> words (String s){
    final List<String> result = new ArrayList<String>();

    StringBuffer currentWord = new StringBuffer();

    for (char c:s.toCharArray()){
      if (Character.isWhitespace(c)){
        final String newWord = currentWord.toString().trim();
        if(newWord.length()>0){
          result.add(newWord);
          currentWord=new StringBuffer();
        }
      }else{currentWord.append(c);} 
    }
    return result;
  }

  static String unwords(List<String> xs){
    StringBuffer result=new StringBuffer();
    for (String x:xs) result.append(" "+x);
    return result.toString().trim();
  }

  public static void main(String []_){
    List<String> xs = words("  the   world  is my Oyster  ");

    for (String x:xs) System.out.println(x);

    System.out.println(unwords(xs));
  }
}

1.4  Automatisches Boxen

Beispiel:
In diesem Beispiel sieht man das manuelle Verpacken und Auspacken primitiver Daten.

package name.panitz.boxing;
public class ManualBoxing{
  public static void main(String [] _){
    int i1 = 42;
    Object o = new Integer(i1);
    System.out.println(o);
    Integer i2 = new Integer(17);
    Integer i3 = new Integer(4);
    int i4 = 21;
    System.out.println((i2.intValue()+i3.intValue())*i4);
  }
}

Beispiel:
Jetzt das vorherige kleine Programm ohne explizite boxing- und unboxing-Aufrufe.

package name.panitz.boxing;
public class AutomaticBoxing{
  public static void main(String [] _){
    int i1 = 42;
    Object o = i1;
    System.out.println(o);
    Integer i2 = 17;
    Integer i3 = 4;
    int i4 = 21;
    System.out.println((i2+i3)*i4);
  }
}

1.5  Aufzählungstypen

Beispiel:
Ein erster Aufzählungstyp für die Wochentage.

package name.panitz.enums;
public enum Wochentage {
  montag,dienstag,mittwoch,donnerstag
 ,freitag,sonnabend,sonntag;
}

sep@linux:fh/> javap name.panitz.enums.Wochentage
Compiled from "Wochentage.java"
public class name.panitz.enums.Wochentage extends java.lang.Enum{
    public static final name.panitz.enums.Wochentage montag;
    public static final name.panitz.enums.Wochentage dienstag;
    public static final name.panitz.enums.Wochentage mittwoch;
    public static final name.panitz.enums.Wochentage donnerstag;
    public static final name.panitz.enums.Wochentage freitag;
    public static final name.panitz.enums.Wochentage sonnabend;
    public static final name.panitz.enums.Wochentage sonntag;
    public static final name.panitz.enums.Wochentage[] values();
    public static name.panitz.enums.Wochentage valueOf(java.lang.String);
    public name.panitz.enums.Wochentage(java.lang.String, int);
    public int compareTo(java.lang.Enum);
    public int compareTo(java.lang.Object);
    static {};
}

Beispiel:
Wir fügen der Aufzählungsklasse eine Methode zu, um zu testen ob der Tag ein Werktag ist. Hierbei läßt sich eine switch-Anweisung benutzen.

package name.panitz.enums;
public enum Tage {
  montag,dienstag,mittwoch,donnerstag
 ,freitag,sonnabend,sonntag;

  public boolean isWerktag(){
    switch (this){
      case sonntag    :
      case sonnabend  :return false;
      default         :return true;
    }
  }

  public static void main(String [] _){
    Tage tag = freitag;
    System.out.println(tag);
    System.out.println(tag.ordinal());
    System.out.println(tag.isWerktag());
    System.out.println(sonntag.isWerktag());
  }
}

sep@linux:~/fh/java1.5/examples> java -classpath classes/ name.panitz.enums.Tage
freitag
4
true
false
sep@linux:~/fh/java1.5/examples>

Beispiel:
Wir iterieren in diesem Beispiel einmal über alle Wochentage.

package name.panitz.enums;
public class IterTage {
  public static void main(String [] _){
    for (Tage tag:Tage.values()) 
      System.out.println(tag.ordinal()+": "+tag);
  }
}

sep@linux:~/fh/java1.5/examples> java -classpath classes/ name.panitz.enums.IterTage
0: montag
1: dienstag
2: mittwoch
3: donnerstag
4: freitag
5: sonnabend
6: sonntag
sep@linux:~/fh/java1.5/examples>

Beispiel:
Wir schreiben eine Aufzählung für die Euroscheine. Jeder Scheinkonstante wird noch eine ganze Zahl mit übergeben. Es muß hierfür ein allgemeiner Konstruktor geschrieben werden, der diesen Parameter übergeben bekommt.

package name.panitz.enums;
public enum Euroschein {
   fünf(5),zehn(10),zwanzig(20),fünfzig(50),hundert(100)
  ,zweihundert(200),tausend(1000);
  private int value;
  public Euroschein(int v){value=v;}
  public int value(){return value();}

  public static void main(String [] _){
    for (Euroschein schein:Euroschein.values()) 
      System.out.println
        (schein.ordinal()+": "+schein+" -> "+schein.value);
  }
}

sep@linux:~/fh/java1.5/examples> java -classpath classes/ name.panitz.enums.Euroschein
0: fünf -> 5
1: zehn -> 10
2: zwanzig -> 20
3: fünfzig -> 50
4: hundert -> 100
5: zweihundert -> 200
6: tausend -> 1000
sep@linux:~/fh/java1.5/examples>

1.6  Statische Imports

Beispiel:
Wir schreiben eine Hilfsklasse zum Arbeiten mit Strings, in der wir eine Methode zum umdrehen eines Strings vorsehen:

package name.panitz.staticImport;
public class StringUtil {
  static public String reverse(String arg) {
    StringBuffer result = new StringBuffer();
    for (char c:arg.toCharArray()) result.insert(0,c);
    return result.toString();
  }
}

package name.panitz.staticImport;
import static name.panitz.staticImport.StringUtil.*;
public class UseStringUtil {
  static public void main(String [] args) {
    for (String arg:args) 
     System.out.println(reverse(arg));
  }
}

sep@linux:fh> java -classpath classes/ name.panitz.staticImport.UseStringUtil hallo welt
ollah
tlew
sep@linux:~/fh/java1.5/examples>

1.7  Variable Parameteranzahl

Beispiel:
Es läßt sich so eine Methode schreiben, die mit beliebig vielen Stringparametern aufgerufen werden kann.

package name.panitz.java15;

public class VarParams{
  static public String append(String... args){
    String result="";
    for (String a:args)
      result=result+a;
    return result;
  }

  public static void main(String [] _){
    System.out.println(append("hello"," ","world"));
  }
}

sep@linux:~/fh/java1.5/examples> javap -classpath classes/ name.panitz.java15.VarParams
Compiled from "VarParams.java"
public class name.panitz.java15.VarParams extends java.lang.Object{
    public name.panitz.java15.VarParams();
    public static java.lang.String append(java.lang.String[]);
    public static void main(java.lang.String[]);
}

sep@linux:~/fh/java1.5/examples>

1.8  Ein paar Beispielklassen

package name.panitz.crempel.util;

public interface UnaryFunction<arg,result>{
  public result eval(arg a);
}

package name.panitz.crempel.util;

public interface Closure<result>{
  public result eval();
}

package name.panitz.crempel.util;

public class Tuple1<t1> {
  public t1 e1;
  public Tuple1(t1 a1){e1=a1;}
  String parenthes(Object o){return "("+o+")";}
  String simpleToString(){return e1.toString();}
  public String toString(){return parenthes(simpleToString());}
  public boolean equals(Object other){
    if (! (other instanceof Tuple1)) return false;
    return e1.equals(((Tuple1)other).e1);
  }
}

package name.panitz.crempel.util;

public class Tuple2<t1,t2> extends Tuple1<t1>{
  public t2 e2;
  public Tuple2(t1 a1,t2 a2){super(a1);e2=a2;}
  String simpleToString(){
    return super.simpleToString()+","+e2.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple2)) return false;
    return super.equals(other)&& e2.equals(((Tuple2)other).e2);
  }
}

package name.panitz.crempel.util;

public class Tuple3<t1,t2,t3> extends Tuple2<t1,t2>{
  public t3 e3;
  public Tuple3(t1 a1,t2 a2,t3 a3){super(a1,a2);e3=a3;}
  String simpleToString(){
    return super.simpleToString()+","+e3.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple3)) return false;
    return super.equals(other)&& e3.equals(((Tuple3)other).e3);
  }
}

package name.panitz.crempel.util;

public class Tuple4<t1,t2,t3,t4> extends Tuple3<t1,t2,t3>{
  public t4 e4;
  public Tuple4(t1 a1,t2 a2,t3 a3,t4 a4){super(a1,a2,a3);e4=a4;}
  String simpleToString(){
    return super.simpleToString()+","+e4.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple4)) return false;
    return super.equals(other)&& e4.equals(((Tuple4)other).e4);
  }
}

package name.panitz.crempel.util;

import java.util.Iterator;

public class FromTo implements Iterable<Integer>,Iterator<Integer>{
  private final int to; 
  private int from; 
  public FromTo(int f,int t){to=t;from=f;}
  public boolean hasNext(){return from<=to;}
  public Integer next(){int result = from;from=from+1;return result;}
  public Iterator<Integer> iterator(){return this;}
  public void remove(){new UnsupportedOperationException();}
}

data Maybe a = Nothing|Just a

package name.panitz.crempel.util;
public interface Maybe<a> {}

package name.panitz.crempel.util;
public class Nothing<a> implements Maybe<a>{

  public String toString(){return "Nothing("+")";}
  public boolean equals(Object other){
    return (other instanceof Nothing);
  }
}

package name.panitz.crempel.util;

public class Just<a> implements Maybe<a>{
  private a just;

  public Just(a just){this.just = just;}
  public a getJust(){return just;}

  public String toString(){return "Just("+just+")";}
  public boolean equals(Object other){
    if (!(other instanceof Just)) return false;
    final Just o= (Just) other;
    return just.equals(o.just);
  }
}

package name.panitz.crempel.tool;
public interface CrempelTool{String getDescription();void startUp();}

1.9  Aufgaben

{\bf \alph{unteraufgabe})}
Schreiben Sie eine Schnittstelle Smaller, in der es eine Methode le mit zwei generischen Parametern gleichen Typs gibt.
Lösung

Smaller
package name.panitz.aufgaben;
public interface Smaller<at> {
  public boolean le(at x1,at x2);
}

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse, die Smaller<Integer>, so implementiert, daß gerade Zahlen kleiner als ungerade Zahlen sind.
Lösung

SmallEven
package name.panitz.aufgaben;
public class SmallEven implements Smaller<Integer> {
  public boolean le(Integer x1,Integer x2){
    if (x1%2 != x2%2){return x1%2==0;};
    return x1<=x2;
  }
}

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse, die Smaller<String>, so implementiert, daß kurze Zeichenketten kleiner als lange sind.
Lösung

SmallShort
package name.panitz.aufgaben;
public class SmallShort implements Smaller<String> {
  public boolean le(String x1,String x2){
    return x1.length()<=x2.length();
  }
}

{\bf \alph{unteraufgabe})} Schreiben Sie den Methodenkopf für eine statische generische Methode bubbleSort zum Sortieren von Reihungen, die zwei Parameter hat: eine zu sortierende Reihung und ein passendes Objekt des Typs Smaller.
Lösung

Hier mit dem Methodenrumpf, der aber nicht verlangt war:
Bubble
package name.panitz.aufgaben;
public class Bubble {
  public static <at> void bubbleSort(at[] ar,Smaller<at> rel){
    boolean toBubble = true;
    int end=ar.length;
    while (toBubble){ 
      toBubble = bubble(ar,rel,end);
      end=end-1;
    }
  }

  static <at> boolean bubble(at[] ar,Smaller<at> rel,int end){
    boolean result = false;
    for (int i=0;i<end;i=i+1){
      try {
        if (!rel.le(ar[i],ar[i+1])){
          at o = ar[i];
          ar[i]=ar[i+1];
          ar[i+1]=o;
          result=true;
        }
      }catch (ArrayIndexOutOfBoundsException _){}
    }
    return result;
  }  
}

{\bf \alph{unteraufgabe})} Schreiben Sie zwei Beispielaufrufe der Methode bubbleSort mit SmallerEven bzw. SmallerShort.
Lösung

TestBubble

package name.panitz.aufgaben;
public class TestBubble{
  public static void main(String [] _){
    String [] xs = {"1","4444","22","55555","","333"};
    System.out.print("[");
    for (String x:xs)System.out.print(","+x);
    System.out.println("]");
    Bubble.bubbleSort(xs,new SmallShort());
    System.out.print("[");
    for (String x:xs)System.out.print(","+x);
    System.out.println("]");

    int [] ys_ = {2,3,4,5,6,7,78,8,8};
    Integer [] ys = new Integer[9];
    for (int i=0;i<9;i++) ys[i]=new Integer(ys_[i]);
    System.out.print("[");
    for (Integer x:ys)System.out.print(","+x);
    System.out.println("]");
    Bubble.bubbleSort(ys,new SmallEven());
    System.out.print("[");
    for (Integer x:ys)System.out.print(","+x);
    System.out.println("]");
  }
}

Chapter 2
Algebraische Typen und Besucher

2.1  Einführung

2.1.1  Funktionale Programmierung

Fallunterscheidungen

fak 0 = 1
fak n = n*fak (n-1)

main = print (fak 5)

fak n
  |n==0      = 1
  |otherwise = n*fak (n-1)

main = print (fak 5)

Generische Typen

lastOfList [x] = x
lastOfList (_:xs) = lastOfList xs

main = do
  print (lastOfList [1,2,3,4,5])
  print (lastOfList ["du","freches","lüderliches","weib"])

Objektorientierte Programmierung in Haskell

class DoubleThis a where
  doubleThis :: a -> a

instance DoubleThis [a] where
  doubleThis s =  s ++  s

instance DoubleThis Integer where
  doubleThis x = 2*x

main = do
  print (doubleThis "hallo")
  print (doubleThis [1,2,3,4])
  print (doubleThis (21::Integer))

2.1.2  Java

Überladung: pattern matching des armen Mannes

Beispiel:
In folgender Klasse ist die Methode doubleThis überladen, wie im entsprechenden Haskellprogramm oben. Einmal für Integer und einmal für Listen.

package example;
import java.util.*;
public class JavaDoubleThis {
  public static Integer doubleThis(Integer x){return 2*x;}
  public static List<Integer> doubleThis(List<Integer> xs){
    List<Integer> result = new ArrayList<Integer>();
    result.addAll(xs);
    result.addAll(xs);
    return result;
  }
  public static void main(String _){
    System.out.println(doubleThis(21));
    List<Integer> xs = new ArrayList<Integer>();
    xs.add(1);
    xs.add(2);
    xs.add(3);
    xs.add(4);
    System.out.println(doubleThis(xs));
  }
}

Generische Typen

2.2  Algebraische Typen

2.2.1  Algebraische Typen in funktionalen Sprachen

Beispiel:
Wir definieren einen algebraischen Typen für Binärbäume in Haskell. Der Typ heiße Tree und sei generisch über die im Baum gespeicherten Elemente. Hierfür steht die Typvariabel a. Es gibt zwei Konstruktoren:

• Empty: zur Erzeugung leerer Bäume
• Branch: zur Erzeugung einer Baumverzweigung. Branch hat drei Argumente: einen linken und einen rechten Teilbaum, sowie ein Element an der Verzweigung.

data Tree a =  Branch (Tree a) a (Tree a)
              |Empty

size Empty = 0
size (Branch l _ r) = 1+size l+size r

flatten Empty = []
flatten (Branch Empty x xs) = (x: (flatten xs))
flatten (Branch (Branch l y r) x xs) 
  = flatten (Branch l  y (Branch r x xs))

main =  do
  print (size (Branch Empty "hallo" Empty))
  print (flatten (Branch (Branch Empty "freches" Empty) 
                         "lüderliches" 
                         (Branch Empty "Weib" Empty )
                  )
         )

2.2.2  Implementierungen in Java

Objektmethoden

package example;
public abstract class Tree<a>{
  public abstract int size();
  public abstract java.util.List<a> flatten();
}

package example;
public class Empty<a> extends Tree<a>{
  public int size(){return 0;} 
  public java.util.List<a> flatten(){
    return new java.util.ArrayList<a>() ;
  }
}

package example;
public class Branch<a> extends Tree<a>{

  private a element;
  private Tree<a> left;
  private Tree<a> right;

  public a getElement(){return element;}
  public Tree<a> getLeft(){return left;}
  public Tree<a> getRight(){return right;}

  public Branch(Tree<a> l,a e,Tree<a> r){
    left=l;element=e;right=r;
  }

  public int size(){return 1+getLeft().size()+getRight().size();}

  public java.util.List<a> flatten(){
    if (getLeft() instanceof Empty){ 
      java.util.List<a> result = new java.util.ArrayList<a>();
      result.add(getElement());
      result.addAll(getRight().flatten());
      return result;
    }

    Branch<a> theLeft = (Branch<a>)getLeft();
    return new Branch<a>(theLeft.getLeft()
                        ,theLeft.getElement()
                        ,new Branch<a>(theLeft.getRight()
                                      ,getElement()
                                      ,getRight()) 
                        ).flatten() ;
  }

  public static void main(String []_){
    System.out.println(
      new Branch<String>
        (new Empty<String>(),"hallo",new Empty<String>())
        .size());
    System.out.println(
      new Branch<String>
       (new Branch<String>
          (new Empty<String>(),"freches",new Empty<String>())
       ,"lüderliches"
       ,new Branch<String>
          (new Empty<String>(),"Weib",new Empty<String>())
       ).flatten());
  }
}

Fallunterscheidung in einer Methode

package example;
class Size{
  static public <a> int size(Tree<a> t){
    if (t instanceof Empty) return 0;
    if (t instanceof Branch<a>) {
      Branch<a> dies = (Branch<a>) t;
      return
         1+size(dies.getLeft())
          +size(dies.getRight());
    }
    throw new RuntimeException("unmatched pattern: "+t);
  };
  public static void main(String [] _){
    System.out.println(size(
     new Branch<String>(new Empty<String>()
                       ,"hallo"
                       ,new Empty<String>())));
  }
}

package example;
import java.util.*;
class Flatten{
  static public <a> List<a> flatten(Tree<a> t){
    if (t instanceof Empty) return new ArrayList<a>();
    Branch<a> dies = (Branch<a>) t;
    if (dies.getLeft() instanceof Empty){ 
      List<a> result = new ArrayList<a>();
      result.add(dies.getElement());
      result.addAll(flatten(dies.getRight()));
      return result;
    }
    Branch<a> theLeft = (Branch<a>)dies.getLeft();
    return flatten(
           new Branch<a>(theLeft.getLeft()
                        ,theLeft.getElement()
                        ,new Branch<a>(theLeft.getRight()
                                      ,dies.getElement()
                                      ,dies.getRight()) 
                        )) ;
  }

  public static void main(String []_){
    System.out.println(flatten(
      new Branch<String>
       (new Branch<String>
          (new Empty<String>(),"freches",new Empty<String>())
       ,"lüderliches"
       ,new Branch<String>
          (new Empty<String>(),"Weib",new Empty<String>())
       )));
  }
}

2.3  Visitor

2.3.1  Besucherobjekte als Funktionen über algebraische Typen

package name.panitz.crempel.util;

public interface Visitor<arg,result> 
                      extends UnaryFunction<arg,result>{
}

package example;
import name.panitz.crempel.util.Visitor;

public interface TreeVisitor<a,result>
                     extends Visitor<Tree<a>,result>{
  public result eval(Tree<a> t);
  public result eval(Branch<a> t);
  public result eval(Empty<a> t);
}

package example;

public class TreeSizeVisitor<a> implements TreeVisitor<a,Integer>{
  public Integer eval(Branch<a> t){
    return 1+eval(t.getLeft())+eval(t.getRight());
  }

  public Integer eval(Empty<a> t){return 0;}

  public Integer eval(Tree<a> t){
    throw new RuntimeException("unmatched pattern: "+t);
  }
}

package example;
public class TreeSizeVisitorNonWorking{
  public static void main(String [] _){
    Tree<String> t = new Branch<String>(new Empty<String>()
                                       ,"hallo"
                                       ,new Empty<String>());
    System.out.println(new TreeSizeVisitor<String>().eval(t));
  }
}

sep@linux:~/fh/adt/examples> java example.TreeSizeVisitorNonWorking
Exception in thread "main" java.lang.RuntimeException: unmatched pattern: example.Branch@1a46e30
        at example.TreeSizeVisitor.eval(TreeSizeVisitor.java:12)
        at example.TreeSizeVisitorNonWorking.main(TreeSizeVisitorNonWorking.java:8)
sep@linux:~/fh/adt/examples>

2.3.2  Besucherobjekte und Späte-Bindung

package example;
import name.panitz.crempel.util.Visitor;

public abstract class VTree<a>{
  public <result> result visit(VTreeVisitor<a,result> v){
    return v.eval(this);
  }
}

package example;
import name.panitz.crempel.util.Visitor;

public interface VTreeVisitor<a,result> 
                      extends Visitor<VTree<a>,result>{
  public result eval(VTree<a> t);
  public result eval(VBranch<a> t);
  public result eval(VEmpty<a> t);
}

package example;
public class VEmpty<a> extends VTree<a>{
  public <result> result visit(VTreeVisitor<a,result> v){
    return v.eval(this);
  }
}

package example;
public class VBranch<a> extends VTree<a>{
  private a element;
  private VTree<a> left;
  private VTree<a> right;
  public a getElement(){return element;}
  public VTree<a> getLeft(){return left;}
  public VTree<a> getRight(){return right;}
  public VBranch(VTree<a> l,a e,VTree<a> r){
    left=l;element=e;right=r;
  }
  public <result> result visit(VTreeVisitor<a,result> v){
    return v.eval(this);
  }
}

package example;

public class VTreeSizeVisitor<a> 
            implements VTreeVisitor<a,Integer> {
  public Integer eval(VBranch<a> t){
    return 1+t.getLeft().visit(this)+t.getRight().visit(this);
  }
  public Integer eval(VEmpty<a> t){return 0;}
  public Integer eval(VTree<a> t){
    throw new RuntimeException("unmatched pattern: "+t);
  }

}

package example;
public class TreeSizeVisitorWorking{
  public static void main(String [] _){
    VTree<String> t = new VBranch<String>(new VEmpty<String>()
                                       ,"hallo"
                                       ,new VEmpty<String>());
    System.out.println(t.visit(new VTreeSizeVisitor<String>()));
  }
}

package example;
import java.util.*;

public class VFlattenVisitor<a> 
                   implements VTreeVisitor<a,List<a>>{

  public List<a> eval(VEmpty<a> t){return new ArrayList<a>();}

  public List<a> eval(VBranch<a> t){
    return t.getLeft().visit(
      new InnerFlattenVisitor(t.getElement(),t.getRight(),this)
    );
  }

  public List<a> eval(VTree<a> t){
    throw new RuntimeException("unmatched pattern: "+t);
  }

  public class InnerFlattenVisitor<a> 
            implements VTreeVisitor<a,List<a>> {

    final a element;
    final VTree<a> right; 
    final VFlattenVisitor<a> outer;

    InnerFlattenVisitor(a e,VTree<a> r,VFlattenVisitor<a> o){
     element=e;right=r;outer=o;}

    public List<a> eval(VEmpty<a> t){
      List<a> result = new ArrayList<a>();
      result.add(element);
      result.addAll(right.visit(outer));
      return result;
    }

    public List<a> eval(VBranch<a> t){
      return new VBranch<a>(t.getLeft()
                           ,t.getElement()
                           ,new VBranch<a>(t.getRight()
                                          ,element
                                          ,right) 
                           ).visit(outer) ;
    }

    public List<a> eval(VTree<a> t){
      throw new RuntimeException("unmatched pattern: "+t);
    }
  }
}

2.4  Generierung von Klassen für algebraische Typen

2.4.1  Eine Syntax für algebraische Typen

Beispiel:
In der solcherhand vorgeschlagenen Syntax lassen sich Binärbäume wie folgt deklarieren:

package example.tree;
data class T<a> {
  Branch(T<a> left,a element,T<a> right);
  Empty();
}

Generierte Klassen

package example.tree;

public abstract class T<a> implements TVisitable<a>{
  abstract public <b_> b_ visit(TVisitor<a,b_> visitor);
}

package example.tree;

public interface TVisitable<a>{
  public <_b> _b visit(TVisitor<a,_b> visitor);}

package example.tree;
import name.panitz.crempel.util.Visitor;

public abstract class TVisitor<a,result> 
  implements Visitor<T<a>,result>{
  public abstract result eval(Branch<a> _);
  public abstract result eval(Empty<a> _);
  public result eval(T<a> xs){
  throw new RuntimeException("unmatched pattern: "+xs.getClass());
  }}

package example.tree;
public class Empty<a> extends T<a>{
  public Empty(){}

  public <_b> _b visit(TVisitor<a,_b> visitor){
    return visitor.eval(this);
  }
  public String toString(){
    return "Empty("+")";
  }
  public boolean equals(Object other){
    if (!(other instanceof Empty)) return false;
    final Empty o= (Empty) other;
    return true  ;
  }
}

package example.tree;

public class Branch<a> extends T<a>{
  private T<a> left;
  private a element;
  private T<a> right;

  public Branch(T<a> left,a element,T<a> right){
    this.left = left;
    this.element = element;
    this.right = right;
  }

  public T<a> getLeft(){return left;}
  public a getElement(){return element;}
  public T<a> getRight(){return right;}
  public <_b> _b visit(TVisitor<a,_b> visitor){
    return visitor.eval(this);
  }
  public String toString(){
    return "Branch("+left+","+element+","+right+")";
  }
  public boolean equals(Object other){
    if (!(other instanceof Branch)) return false;
    final Branch o= (Branch) other;
    return true  &&left.equals(o.left)
                 &&element.equals(o.element)
                 &&right.equals(o.right);
  }
}

Schreiben von Funktionen auf algebraische Typen

package example.tree;
public class TSize<a> extends TVisitor<a,Integer>{
  public Integer eval(Branch<a> x){
    return 1+size(x.getLeft())+size(x.getRight());
  }
  public Integer eval(Empty<a> _){return 0;}

  public int size(T<a> t){
    return t.visit(this);}
}

Verschachtelte algebraische Typen

package example.baum;
data class Li<a> {
  Cons(a head ,Li<a> tail);
  Empty();
}

package example.baum;
data class Baum<a> {
  Zweig(Li<Baum<a>> children,a element);
  Leer();
}

Beispiel:
Für die Bäume mit beliebig großer Kinderanzahl ergeben sich folgende Besucher für das Zählen der Elemente:

package example.baum;
public class BaumSize<a> extends BaumVisitor<a,Integer>{
  final BaumVisitor<a,Integer> dies = this;
  final LiBaumSize inner = new LiBaumSize();

  public Integer size(Baum<a> t){return t.visit(this);}
  public Integer size(Li<Baum<a>> xs){return xs.visit(inner);}

  class LiBaumSize  extends LiVisitor<Baum<a>,Integer>{
    public Integer eval(Empty<Baum<a>> _){return 0;}
    public Integer eval(Cons<Baum<a>> xs){
      return size(xs.getHead()) + size(xs.getTail());}
  }
    public Integer eval(Zweig<a> x){
      return 1+size(x.getChildren());}
    public Integer eval(Leer<a> _){return 0;}
}

package example.baum;
public class BaumSizeTest{
  public static void main(String [] _){
    Baum<String> b
      = new Zweig<String>
         (new Cons<Baum<String>>
           (new Leer<String>()
           ,new Cons<Baum<String>>
              (new Zweig<String>
                    (new Empty<Baum<String>>(),"welt")
              ,new Empty<Baum<String>>()))
           ,"hallo");
    System.out.println(new BaumSize<String>().size(b));
  }
}

package example.baum;
import name.panitz.crempel.util.Visitor;

public class BaumSizeError<a> 
                 implements Visitor<Baum<a>,Integer>
                          , Visitor<Li<Baum<a>>,Integer>{
  public Integer size(Baum<a> t){return t.visit(this);}
  public Integer size(Li<Baum<a>> xs){return xs.visit(this);}

  public Integer eval(Empty<Baum<a>> _){return 0;}
  public Integer eval(Cons<Baum<a>> xs){
    return size(xs.getHead())+size(xs.getTail());}
  public Integer eval(Zweig<a> x){return size(x.getChildren());}
  public Integer eval(Leer<a> _){return 0;}

  public Integer eval(Li<Baum<a>> t){
    throw new RuntimeException("unsupported pattern: "+t);}
  public Integer eval(Baum<a> t){
    throw new RuntimeException("unsupported pattern: "+t);}
}

BaumSizeError.java:5: name.panitz.crempel.util.Visitor cannot
be inherited with different arguments: 
    <example.baum.Baum<a>,java.lang.Integer> 
and <example.baum.Li<example.baum.Baum<a>>,java.lang.Integer>

2.4.2  Java Implementierung

Abstrakte Typbeschreibung

package name.panitz.crempel.util.adt;

import java.util.List;
import java.util.ArrayList;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
import java.io.IOException;

public class AbstractDataType {

• einen Typnamen für den den algebraischen Typen
• eventuell eine Paketspezifikation
• eine Liste Imports
• eine Liste von Typvariablen
• eine Liste von Konstrurtordefinitionen

  String name;
  String thePackage;
  List<String> typeVars;
  List<String> imports;
  public List<Constructor> constructors;

  public AbstractDataType(String p,String n,List tvs,List ps){
    this(p,n,tvs,ps,new ArrayList<String>());
  }

  public AbstractDataType
                 (String p,String n,List tvs,List ps,List im){
    thePackage = p;
    name=n;
    typeVars=tvs;
    constructors=ps;
    imports=im;
  }

  public String toString(){
    StringBuffer result = new StringBuffer("data class "+name);
    if (!typeVars.isEmpty()){
      result.append("<");
      for (String tv:typeVars){result.append("\u0020"+tv);}
      result.append(">");
    }
    result.append("{\n");
    for (Constructor c:constructors){result.append(c.toString());}
    result.append("}\n");
    return result.toString();
  }

  public String getFullName(){return name+getParamList();}

  public String getName(){return name;}

  String commaSepParams(){
    String paramList = "";
      boolean first=true;
      for (String tv:typeVars){
        if (!first)paramList=paramList+",";
        paramList=paramList+tv;
        first=false;
      }
      return paramList;
  }

  public String getParamList(){
    if (!typeVars.isEmpty()){return '<'+commaSepParams()+'>';}
    return "";
  }

  String getPackageDef(){
    return  thePackage.length()==0
           ?""
           :"package "+thePackage+";\n\n";
  }

  public void generateClasses(String path){
    try{
      generateVisitorInterface(path);
      generateVisitableInterface(path);
      generateClass(path);
    }catch (IOException _){}
}

  public void generateClass(String path) throws IOException{
    String fullName = getFullName();

    if (constructors.size()!=1){
      FileWriter out = new FileWriter(path+"/"+name+".java");
      out.write( getPackageDef());
      writeImports(out);
      out.write("public abstract class ");
      out.write(fullName);
      out.write(" implements "+name+"Visitable"+getParamList());
      out.write("{\n");
      out.write("  abstract public <b_> b_ visit("
              +name+"Visitor<"+commaSepParams()
                              +(typeVars.isEmpty()?"":",")
                              +"b_> visitor);\n");  
      out.write("}");
      out.close();
      for (Constructor c:constructors){c.generateClass(path,this);}

    }else{constructors.get(0).generateClass(path,this,true);}
  }

  void writeImports(Writer out) throws IOException{
    for (String imp:imports){
      out.write("\nimport ");
      out.write(imp);
    }
    out.write("\n\n");
  }

  public void generateVisitableInterface(String path){
    try{
      final String interfaceName = name+"Visitable";	
      final String fullName = interfaceName+getParamList();
      FileWriter out
        = new FileWriter(path+"/"+interfaceName+".java");
      out.write( getPackageDef());
      writeImports(out);
      out.write("public interface ");
      out.write(fullName+"{\n");
      out.write("  public <_b> _b visit("
		+name+"Visitor<"+commaSepParams()
                                +(typeVars.isEmpty()?"":",")
                                +"_b> visitor);"); 
      out.write("}");
      out.close();
    }catch (Exception _){}
  }

  public void generateVisitorInterface(String path){
    try{
      final String interfaceName = name+"Visitor";	
      final String fullName
       = interfaceName+"<"
                      +commaSepParams()
                      +(typeVars.isEmpty()?"":",")
                      +"result>";
      FileWriter out 
       = new FileWriter(path+"/"+interfaceName+".java");
      out.write( getPackageDef());
      out.write( "\n");
      out.write("import name.panitz.crempel.util.Visitor;\n");
      writeImports(out);
      out.write("public abstract class ");
      out.write(fullName+" implements Visitor<");
      out.write(getFullName()+",result>{\n");
      if (constructors.size()!=1){
        for (Constructor c:constructors) 
          out.write("  "+c.makeEvalMethod(this)+"\n");
      }

      out.write("  public result eval("+getFullName() +" xs){\n");
      out.write("    throw new RuntimeException(");
      out.write("\"unmatched pattern: \"+xs.getClass());\n");
      out.write("  }");

      out.write("}");
      out.close();
    }catch (Exception _){}
  }
}

Konstruktordarstellung

package name.panitz.crempel.util.adt;

import name.panitz.crempel.util.Tuple2;

import java.util.List;
import java.util.ArrayList;
import java.io.FileWriter;
import java.io.Writer;
import java.io.IOException;

public class Constructor {

  String name;
  List<Tuple2<Type,String>> params;

  public Constructor(String n,List ps){name=n;params=ps;}
  public Constructor(String n){this(n,new ArrayList());}

  public String toString(){
    StringBuffer result = new StringBuffer("  ");
    result.append(name);
    result.append("(");
    boolean first = true;
    for (Tuple2<Type,String> t:params){
	if (first) {first=false;}
	else {result.append(",");}
      result.append(t.e1+"\u0020"+t.e2);
    }
    result.append(");\n");
    return result.toString();
  }

• das Objekt, das den algebraischen Typen darstellt
• und der Pfad zum Order des Dateisystems.

  public void generateClass(String path,AbstractDataType theType){
    generateClass(path,theType,false);
  }

  public void generateClass
        (String path,AbstractDataType theType,boolean standalone){
    try{
      if (standalone) name=theType.getFullName();
      FileWriter out = new FileWriter(path+"/"+name+".java");
      out.write( theType.getPackageDef());
      theType.writeImports(out);

      out.write("public class ");
      out.write(name);
      out.write(theType.getParamList());
      if (!standalone){
        out.write(" extends ");
        out.write(theType.getFullName());
      } else{
        out.write(" implements "+theType.name+"Visitable");
      }
      out.write("{\n");

• Felder für die Argumente des Konstruktors
• Get-Methoden für diese Felder
• die Methode visit
• die Methode equals
• die Methode toString

      writeFields(out);
      writeConstructor(out);
      writeGetterMethods( out);
      writeVisitMethod(theType, out);
      writeToStringMethod(out);
      writeEqualsMethod(out);
      out.write("}\n");
      out.close();
    }catch (Exception _){}
  }

  private void writeFields(Writer out)throws IOException{
    for (Tuple2<Type,String> pair:params){
     out.write("  private final ");
     out.write(pair.e1.toString());
     out.write("\u0020");
     out.write(pair.e2);
     out.write(";\n");
    }
  }

  private void writeConstructor(Writer out)throws IOException{
    out.write("\n  public "+name+"(");
    boolean first= true;
    for (Tuple2<Type,String> pair:params){
      if (!first){out.write(",");}
      out.write(pair.e1.toString());
      out.write("\u0020");
      out.write(pair.e2);
      first=false;
    }
    out.write("){\n");
    for (Tuple2<Type,String> pair:params){
      out.write("    this."+pair.e2);
      out.write(" = ");
      out.write(pair.e2);
      out.write(";\n");
    }
    out.write("  }\n\n");
  }

  private void writeGetterMethods(Writer out)throws IOException{
    for (Tuple2<Type,String> pair:params){
      out.write("  public ");
      out.write(pair.e1.toString());
      out.write(" get");
      out.write(Character.toUpperCase(pair.e2.charAt(0)));
      out.write(pair.e2.substring(1));
      out.write("(){return "+pair.e2 +";}\n");
    }
  }

  private void writeVisitMethod
                   (AbstractDataType theType,Writer out)
         throws IOException{
      out.write("  public <_b> _b visit("
		+theType.name+"Visitor<"+theType.commaSepParams()
                                +(theType.typeVars.isEmpty()?"":",")
                                +"_b> visitor){"
                +"\n    return visitor.eval(this);\n  }\n"); 
  }

  private void writeToStringMethod(Writer out) throws IOException{
    out.write("  public String toString(){\n");
    out.write("    return \""+name+"(\"");
    boolean first=true;
    for (Tuple2<Type,String> p:params){
     if (first){first=false;}
     else out.write("+\",\"");
     out.write("+"+p.e2);
    }
    out.write("+\")\";\n  }\n"); 
  }

  private void writeEqualsMethod(Writer out) throws IOException{
    out.write("  public boolean equals(Object other){\n");
    out.write("    if (!(other instanceof "+name+")) ");
    out.write("return false;\n");
    out.write("    final "+name+" o= ("+name+") other;\n");
    out.write("    return true  ");
    for (Tuple2<Type,String> p:params){
      out.write("&& "+p.e2+".equals(o."+p.e2+")");
    }
    out.write(";\n  }\n"); 
  }

  public String makeEvalMethod(AbstractDataType theType){
    return "public abstract result eval("
            +name+theType.getParamList()+" _);";
  }
}

Parametertypen

package name.panitz.crempel.util.adt;

import java.util.List;
import java.util.ArrayList;

public class Type {

    private String name;
    private List<Type> params;
    public String getName(){return name;}
    public List<Type> getParams(){return params;}
    
    public Type(String n,List ps){name=n;params=ps;}
    public Type(String n){this(n,new ArrayList());}

    public String toString(){
      StringBuffer result = new StringBuffer(name);
      if (!params.isEmpty()){
	result.append("<");
	boolean first=true;
        for (Type t:params){
          if (!first) result.append(',');  
	  result.append(t);
          first=false;
	}
        result.append('>');  
      }
      return result.toString();
    }
}

Hauptgenerierungsprogramm

package name.panitz.crempel.util.adt;

import name.panitz.crempel.util.adt.parser.ADT;
import java.util.List;
import java.util.ArrayList;
import java.io.FileReader;
import java.io.File;

public class ADTMain {
  public static void main(String args[])  {
    try{
      List<String> fileNames = new ArrayList<String>();

      if (args.length==1 && args[0].equals("*.adt")){
        for (String arg:new File(".").list()){
          if (arg.endsWith(".adt")) fileNames.add(arg);
        }
      }else for (String arg:args) fileNames.add(arg);
     
      for (String arg:fileNames){
        File f = new File(arg);  
        ADT parser = new ADT(new FileReader(f));
        AbstractDataType adt = parser.adt();
        System.out.println(adt);
        final String path
          = f.getParentFile()==null?".":f.getParentFile().getPath();
        adt.generateClasses(path);
      }
    }catch (Exception _){_.printStackTrace();} 
  }
}

2.5  Beispiel: eine kleine imperative Programmiersprache

2.5.1  Algebraischer Typ für Klip

package name.panitz.crempel.util.adt.examples;

import java.util.List;

data class Klip{
  Num(Integer i);
  Add(Klip e1,Klip e2);
  Mult(Klip e1,Klip e2);
  Sub(Klip e1,Klip e2);
  Div(Klip e1,Klip e2);
  Var(String name);
  Assign(String var,Klip e);
  While(Klip cond,Klip body);
  Block(List stats);
}

2.5.2  Besucher zur textuellen Darstellung

Beispiel:
Ein kleines Beispiel für ein Klipprogramm zur Berechnung der Fakultät von 5.

x := 5;
y:=1;
while (x){y:=y*x;x:=x-1;};
y;

package name.panitz.crempel.util.adt.examples;
import name.panitz.crempel.util.*;
import java.util.*;

public class ShowKlip extends KlipVisitor<String> {
  public String show(Klip a){return a.visit(this);}

  public String eval(Num x){return x.getI().toString();}
  public String eval(Add x){
    return "("+show(x.getE1())+" + "+show(x.getE2())+")";}
  public String eval(Sub x){
    return "("+show(x.getE1())+" - "+show(x.getE2())+")";}
  public String eval(Div x){
    return "("+show(x.getE1())+" / "+show(x.getE2())+")";}
  public String eval(Mult x){
    return "("+show(x.getE1())+" * "+show(x.getE2())+")";}
  public String eval(Var v){return v.getName();}
  public String eval(Assign x){
    return x.getVar()+" := "+show(x.getE());}
  public String eval(Block b){
    StringBuffer result=new StringBuffer();
    for (Klip x:(List<Klip>)b.getStats()) 
      result.append(show(x)+";\n");
    return result.toString();
  }
  public String eval(While w){
    StringBuffer result=new StringBuffer("while (");
    result.append(show(w.getCond()));
    result.append("){\n");
    result.append(show(w.getBody()));
    result.append("\n}");
    return result.toString();
  }
}

2.5.3  Besucher zur Interpretation eines Klip Programms

package name.panitz.crempel.util.adt.examples;
import name.panitz.crempel.util.*;
import java.util.*;

public class EvalKlip extends KlipVisitor<Integer> {
  Map<String,Integer> env = new HashMap<String,Integer>();
  public Integer val(Klip x){return x.visit(this);}

 public Integer eval(Num x){return x.getI();}
 public Integer eval(Add x){return val(x.getE1())+val(x.getE2());}
 public Integer eval(Sub x){return val(x.getE1())-val(x.getE2());}
 public Integer eval(Div x){return val(x.getE1())/val(x.getE2());}
 public Integer eval(Mult x){return val(x.getE1())*val(x.getE2());}
 public Integer eval(Var v){return env.get(v.getName());}
 public Integer eval(Assign ass){
   Integer i = val(ass.getE());
   env.put(ass.getVar(),i);
   return i;
 }
 public Integer eval(Block b){
    Integer result = 0;
    for (Klip x:(List<Klip>)b.getStats()) result=val(x);
    return result;
 }
 public Integer eval(While w){
    Integer result = 0;
    while (w.getCond().visit(this)!=0){
      System.out.println(env); //this is a trace output
      result = w.getBody().visit(this);
    }    
    return result;
 }
}

2.5.4  javacc Parser für Klip

options {
   STATIC=false;
}

PARSER_BEGIN(KlipParser)
package name.panitz.crempel.util.adt.examples;

import name.panitz.crempel.util.Tuple2;
import java.util.List;
import java.util.ArrayList;
import java.io.FileReader;

public class KlipParser  {
  public static void main(String [] args)throws Exception{
    Klip klip = new KlipParser(new FileReader(args[0]))
                .statementList();

    System.out.println(klip.visit(new ShowKlip()));
    System.out.println(klip.visit(new EvalKlip()));
  }
}
PARSER_END(KlipParser)

Scanner

TOKEN :
{<WHILE: "while">
|<#ALPHA:	["a"-"z","A"-"Z","_","."]	>
|<NUM:		["0"-"9"]		>
|<#ALPHANUM:	<ALPHA> | <NUM>		>
|<NAME: <ALPHA> ( <ALPHANUM> )*>
|<ASS: ":=">
|<LPAR: "(">
|<RPAR: ")">
|<LBRACKET: "{">
|<RBRACKET: "}">
|<SEMICOLON: ";">
|<STAR: "*">
|<PLUS: "+">
|<SUB: "-">
|<DIV: "/">
}

SKIP :
{ "\u0020"
| "\t"
| "\n"
| "\r"
}

Parser

Klip statementList() : 
{  List stats = new ArrayList();
   Klip stat;}
{ 
  (stat=statement() {stats.add(stat);} <SEMICOLON>)*
  {return new Block(stats);}
}

Klip statement():
{Klip e2;Klip result;boolean sub=false;}
{  
  result=multExpr() 
  [ (<PLUS>|<SUB>{sub=true;}) e2=statement() 
   {result = sub?new Sub(result,e2):new Add(result,e2);}]
  {return result;}
}

Klip multExpr():
{Klip e2;Klip result;boolean div= false;}
{  
  result=atomicExpr() 
  [ (<STAR>|<DIV>{div=true;}) 
    e2=multExpr() 
    {result = div?new Div(result,e2):new Mult(result,e2);}]
  {return result;}
}

Klip atomicExpr():
{Klip result;}
{  
   (result=integerLiteral()
   |result=varOrAssign()
   |result=whileStat()
   |result=parenthesesExpr()
   )
  {return result;}
}

Klip integerLiteral():
{ int result = 0;
  Token n;
  boolean m=false;}
{  [<SUB> {m = true;}]
   (n=<NUM>  
    {result=result*10+n.toString().charAt(0)-48;})+
   {return new Num(new Integer(m?-result:result));}
}

Klip parenthesesExpr():
{Klip result;}
{ <LPAR> result = statement() <RPAR>
{return result;}}

Klip varOrAssign():
{ Token n;Klip result;Klip stat;}
{ n=<NAME>{result=new Var(n.toString());} 
  [<ASS> stat=statement() 
    {result = new Assign(n.toString(),stat);}
  ]
  {return result;}
}

Klip whileStat():{
  Klip cond; Klip body;}
{ <WHILE> <LPAR>cond=statement()<RPAR> 
  <LBRACKET> body=statementList()<RBRACKET>
  {return new While(cond,body);}
}

Klip-Beispiele

2*7+14*2;

2*(7+9)*2;

sep@linux:~> java name.panitz.crempel.util.adt.examples.KlipParser arith1.klip
((2 * 7) + (14 * 2));

42
sep@linux:~> java name.panitz.crempel.util.adt.examples.KlipParser arith2.klip
(2 * ((7 + 9) * 2));

64
sep@linux:~>

sep@linux:~> java name.panitz.crempel.util.adt.examples.KlipParser fak.klip
x := 5;
y := 1;
while (x){
y := (y * x);
x := (x - 1);

};
y;

{y=1, x=5}
{y=5, x=4}
{y=20, x=3}
{y=60, x=2}
{y=120, x=1}
120
sep@linux:~>

2.6  Javacc Definition für ATD Parser

options {
   STATIC=false;
}

PARSER_BEGIN(ADT)
package name.panitz.crempel.util.adt.parser;

import name.panitz.crempel.util.Tuple2;
import name.panitz.crempel.util.adt.*;
import java.util.List;
import java.util.ArrayList;
import java.io.FileReader;

public class ADT {

}
PARSER_END(ADT)

TOKEN :
{<DATA: "data">
|<CLASS: "class">
|<DOT: ".">
|<#ALPHA:	["a"-"z","A"-"Z","_","."]	>
|<#NUM:		["0"-"9"]		>
|<#ALPHANUM:	<ALPHA> | <NUM>		>
|<PAKET: "package">
|<IMPORT: "import">
|<NAME: <ALPHA> ( <ALPHANUM> )*>
|<EQ: "=">
|<BAR: "|">
|<LPAR: "(">
|<RPAR: ")">
|<LBRACKET: "{">
|<RBRACKET: "}">
|<LE: "<">
|<GE: ">">
|<SEMICOLON: ";">
|<COMMA: ",">
|<STAR: "*">
}

SKIP :
{ "\u0020"
| "\t"
| "\n"
| "\r"
}

AbstractDataType adt() : 
{ Token nameT;
  String name;
  String paket;
  List typeVars = new ArrayList();
  List constructors;
  List imports;
}
{
   paket=packageDef()
   imports=importDefs()
   
   <DATA> <CLASS> nameT=<NAME>{name=nameT.toString();} 

   [ <LE> 
       (nameT=<NAME> {typeVars.add(nameT.toString());}) 
       (<COMMA> nameT=<NAME> {typeVars.add(nameT.toString());})* 
     <GE>]
    <LBRACKET>
   constructors=defs()
    <RBRACKET>
{return 
  new AbstractDataType(paket,name,typeVars,constructors,imports);}
}

String packageDef():
{StringBuffer result=new StringBuffer();Token n;}
{
  [<PAKET> n=<NAME>{result.append(n.toString());} 
    (<DOT> n=<NAME>{result.append("."+n.toString());})*
    <SEMICOLON>
  ]
{return result.toString();}
}


List importDefs():{
  List result=new ArrayList();Token n;StringBuffer current;}
{
  ({current = new StringBuffer();}
    <IMPORT> n=<NAME>{current.append(n.toString());} 
    (<DOT> n=<NAME>{current.append("."+n.toString());})*
    [<DOT><STAR>{current.append(".*");}]
    <SEMICOLON>
    {current.append(";");result.add(current.toString());}
  )*
{return result;}
}


List defs() :
{
  Constructor def ;
  ArrayList result=new ArrayList();
}
{
   def=def(){result.add(def);} (def=def() {result.add(def);} )*
   {return result;}
}

Constructor def() : 
{ Token n;
  Type param ;
  String name;
  ArrayList params=new ArrayList();
}
{
  n=<NAME> {name=n.toString();}
     <LPAR>[(param=type() n=<NAME>
                {params.add(new Tuple2(param,n.toString()));}  ) 
         (<COMMA> param=type() n=<NAME> 
            {params.add(new Tuple2(param,n.toString()));}  )* 
     ]<RPAR>
  <SEMICOLON>
  {return new Constructor(name,params);}
}

Type type():
{ Type result;
  Token n;
  Type typeParam;
  ArrayList params=new ArrayList();
}
{
  ( n=<NAME>
   ([<LE>
         typeParam=type() {params.add(typeParam);}
        (<COMMA> typeParam=type() {params.add(typeParam);}   )* 
        {result = new Type(n.toString(),params);}
     <GE>])
 )
{
{result = new Type(n.toString(),params);}
return result;
}
}

2.7  Aufgaben

data HLi a 
  =   Empty 
    | Cons a (HLi a)

odds(Cons x (Cons y ys)) = (Cons x (odds(ys)))
odds(Cons x Empty)       = (Cons x Empty)
odds(Empty)              = Empty

data HBT a 
  =   T a
    | E 
    | B (HBT a) a (HBT a)

addLeft (T a)     = a
addLeft (E)       = 0
addLeft (B l x r) = x+addLeft(l)

package name.panitz.aufgaben;
data class BT<at>{
  E();
  Branch(BT<at> left,at mark,BT<at> right);
}

{\bf \alph{unteraufgabe})} Schreiben Sie einen Besucher HTMLTree<at>, der BTVisitor<at,StringBuffer> erweitert. Er soll in einem StringBuffer einen String erzeugen, der HTML-Code darstellt. Die Kinder eines Knotens sollen dabei mit einem <ul>-Tag gruppiert werden und jedes Kind als <li> Eintrag in dieser Gruppe auftreten.
Beispiel: Für folgenden Baum:
HTMLTreeExample

package name.panitz.aufgaben;
public class HTMLTreeExample{
  public static void main(String [] _){
    BT<String> bt 
     =new Branch<String>
       (new Branch<String>(new E<String>()
                          ,"brecht"
                          ,new E<String>())
       ,"horvath"
       ,new Branch<String>
         (new Branch<String>(new E<String>()
                            ,"ionesco"
                            ,new E<String>())
         ,"shakespeare"
         ,new E<String>()));
    System.out.println(bt.visit(new HTMLTree()));
  }
}

Wird folgenden HTML Code erzeugt:

horvath
<ul>
<li>brecht
<ul>
<li>E()</li>
<li>E()</li></ul></li>
<li>shakespeare
<ul>
<li>ionesco
<ul>
<li>E()</li>
<li>E()</li></ul></li>
<li>E()</li></ul></li></ul>

Lösung

HTMLTree
package name.panitz.aufgaben;
import java.util.List;
import java.util.ArrayList;
public class HTMLTree<at> extends  BTVisitor<at,StringBuffer>{
  StringBuffer result=new StringBuffer();
  public StringBuffer eval(E<at> _){
    result.append("E()");return result;} 

  public StringBuffer eval(Branch<at> n){
    result.append(n.getMark());    
    result.append("\n<ul>");
    result.append("\n<li>");
    n.getLeft().visit(this);
    result.append("</li>");
    result.append("\n<li>");
    n.getRight().visit(this);
    result.append("</li>");
    result.append("</ul>");
    return result;
  } 
}

{\bf \alph{unteraufgabe})} Schreiben Sie einen Besucher FlattenTree<at>, der BTVisitor<at,List<at>> erweitert. Er soll alle Knotenmarkierungen des Baumes in seiner Ergebnisliste sammeln.
Lösung

FlattenTree

package name.panitz.aufgaben;
import java.util.List;
import java.util.ArrayList;
public class FlattenTree<at> extends  BTVisitor<at,List<at>>{
  List<at> result = new ArrayList<at>();

  public List<at> eval(E<at> _){return result;} 
  public List<at> eval(Branch<at> n){
    n.getLeft().visit(this);
    result.add(n.getMark());
    n.getRight().visit(this);
    return result;
  } 
}

Chapter 3
XML

Beispiel:
Der eigentliche Text des Dokuments sei:

The Beatles White Album

Die einzelnen Bestandteile dieses Textes können markiert werden:

<cd>
  <artist>The Beatles</artist>
  <title>White Album</title>
</cd>

3.1  XML-Format

<?xml version="1.0"?>

3.1.1  Elemente

Beispiel:
Somit ist ein einfaches XML-Dokument ein solches Dokument, in dem der gesammte Text mit einem einzigen Element markiert ist:

<?xml version="1.0"?>
<myText>Dieses ist der Text des Dokuments. Er ist
mit genau einem Element markiert.
</myText>

Beispiel:
Folgendes Dokument enthält ein Element ohne Inhalt:

<?xml version="1.0"?>
<skript>
  <page>erste Seite</page>
  <page></page>
  <page>dritte Seite</page>
</skript>

Leere Elemente

Beispiel:
Das vorherige Dokument läßt sich somit auch wie folgt schreiben:

<?xml version="1.0"?>
<skript>
  <page>erste Seite</page>
  <page/>
  <page>dritte Seite</page>
</skript>

Gemischter Inhalt

Beispiel:
Ein Dokument, in dem das oberste Element einen gemischten Inhalt hat:

<?xml version="1.0"?>
<myText>Der <landsmann>Italiener</landsmann>
<eigename>Ferdinand Carulli</eigename> war  als Gitarrist 
ebenso wie der <landsmann>Spanier</landsmann> 
<eigename>Fernando Sor</eigename> in <ort>Paris</ort>
ansäßig.</myText>

XML-Dokumente als Bäume

Beispiel:
Das folgende ist kein gültiges XML-Dokument. Das Element <bf> wird geschlossen bevor das später geöffnete Element <em> geschlossen worde.

<?xml version="1.0"?>
<illegalDocument>
  <bf>fette Schrift <em>kursiv und fett</bf> 
  nur noch kursiv</em>.
</illegalDocument>

Das Dokument wäre wie folgt als gültiges XML zu schreiben:

<?xml version="1.0"?>
<validDocument>
  <bf>fette Schrift</bf><bf> <em>kursiv und fett</em></bf> 
  <em>nur noch kursiv</em>.
</validDocument>

Dieses Dokument hat eine hierarchische Struktur.

3.1.2  Attribute

Beispiel:
Dokument mit einem Attribut für ein Element.

<?xml version="1.0"?>
<text>Mehr Information zu XML findet man auf den Seiten
des <link address="www.w3c.org">W3C</link>.</text>

3.1.3  Kommentare

Beispiel:
Im folgenden Dokument ist ein Kommentar eingefügt:

<?xml version="1.0"?>
<drehbuch filmtitel="Ben Hur">
<akt>
  <szene>Ben Hur am Vorabend des Wagenrennens.
    <!--Diese Szene muß noch ausgearbeitet werden.-->
  </szene>
</akt>
</drehbuch>

3.1.4  Character Entities

Entity	Zeichen	Beschreibung
&lt;	<	(less than)
&gt;	>	(greater than)
&amp;	&	(ampersant)
&quot;	"	(quotation mark)
&apos;	'	(apostroph)

Beispiel:
Folgendes Dokument benutzt Character Entities um mathematische Formeln zu schreiben:

<?xml version="1.0"?>
<gleichungen>
  <gleichung>x+1&gt;x</gleichung>
  <gleichung>x*x&lt;x*x*x für x&gt;1</gleichung>
</gleichungen>

3.1.5  CDATA-Sections

Beispiel:
Die im vorherigen Beispiel mit Character Entities beschriebenen Formeln lassen sich innerhalb einer CDATA-Section wie folgt schreiben.

<?xml version="1.0"?>
<formeln><![CDATA[
  x+1>x 
  x*x<x*x*x für x > 1
]]></formeln>

3.1.6  Processing Instructions

Beispiel:
Ausschnitt aus dem XML-Dokument diesen Skripts, in dem auf ein Stylesheet verwiesen wird, daß das Skript in eine HTML-Darstellung umwandelt:

<?xml version="1.0"?>
<?xml-stylesheet 
   type="text/xsl" 
   href="../transformskript.xsl"?>

<skript>
<titelseite>
<titel>Grundlagen der Datenverarbeitung<white/>II</titel>
<semester>WS 02/03</semester>
</titelseite>
</skript>

3.1.7  Namensräume

• dem Präfix, der vor dem Doppelpunkt steht.
• dem lokalen Namen, der nach dem Doppelpunkt folgt.

Beispiel:
Ein Beispiel für ein XML-Dokument, daß den Präfix sep an einem bestimmten Namensraum gebunden hat:

<?xml version="1.0"?>
<sep:skript 
   xmlns:sep="http://www.tfh-berlin.de/~panitz/dv2">
  <sep:titel>Grundlagen der DV 2</sep:titel>
  <sep:autor>Sven Eric Panitz</sep:autor>
</sep:skript>

3.2  Codierungen

Beispiel:
Dieses Skript ist in einer Codierung gespeichert, die für westeuropäische Dokumente gut geeignet ist, da es für die verschiedenen Sonderzeichen der westeuropäischen Schriften einen Zahlenwert im 8-Bit-Bereich zugeordnet hat. Die Codierung mit dem Namen: iso-8859-1. Diese wird im Kopf des Dokuments angegeben:

<?xml version="1.0" encoding="iso-8859-1" ?>
<skript><kapitel>blablabla</kapitel></skript>

3.3  Dokumente als Bäume in Java

3.3.1  Ein algebraischer Typ für XML

package name.panitz.xml;
import java.util.List;
data class XML{
  Element(Name name,List attributes,List children);
  Comment(String comment);
  Text(String text);
  CDataSection(String cdata);
  Entity(String name);
  ProcessingInstruction(String target,String instruction);
}

package name.panitz.xml;
public class Attribute{
  Name name; String value;
  public Attribute(Name n,String v){name=n;value=v;}
  public String toString(){return name+" = \""+value+"\"";}
}

package name.panitz.xml;
import java.util.Map;
public class Name{
  String prefix; String name;String nas;
  public Name(String p,String n,String s){prefix=p;name=n;nas=s;}

  public String toString(){
    return prefix+(prefix.length()==0?"":":")+name;
  }

  public boolean equals(Object other){
    if (other instanceof Name) return equals((Name)other);
    return false;
  }

  public boolean equals(Name other){
    return name.equals(other.name)&&prefix.equals(other.prefix) ;
  }

  public boolean equals
                (Name other,Map<String,String> namespaceBinding){
    return name.equals(other.name) 
     && namespaceBinding.get(prefix)
        .equals(namespaceBinding.get(other.prefix));
  } 
}

Besucher für den Typ XML

package name.panitz.xml;
import java.util.List;

public class Show extends XMLVisitor<StringBuffer> {
  StringBuffer result = new StringBuffer();

  public StringBuffer eval(Element element){
    result.append("<");
    result.append(element.getName().toString());
    for (Attribute attr:(List<Attribute>)element.getAttributes())
      result.append("\u0020"+attr);
    if (element.getChildren().isEmpty())result.append("/>");
    else {
      result.append(">");
      for (XML xml:(List<XML>)element.getChildren()) 
        xml.visit(this);
      result.append("</");
      result.append(element.getName().toString());
      result.append(">");}
    return result; }      
  public StringBuffer eval(Comment comment){
    result.append("<!--"+comment.getComment()+"-->");
    return result;}
  public StringBuffer eval(Text text){
    result.append(text.getText());
    return result;}
  public StringBuffer eval(CDataSection cdata){
    result.append("<![CDATA["+cdata.getCdata()+"]"+"]>");
    return result;}
  public StringBuffer eval(Entity entity){
    result.append("&"+entity.getName()+";");
    return result;} 
  public StringBuffer eval(ProcessingInstruction pi){
    result.append("<?"+pi.getTarget()+"\u0020");
    result.append(pi.getInstruction()+"?>");
    return result;}
}

package name.panitz.xml;
import java.util.List;
import java.util.ArrayList;

public class SelectElement extends  XMLVisitor<List<XML>> {
  List<Name> selectThese;
  List<XML> result = new ArrayList<XML>();
  public SelectElement(List<Name> st){selectThese=st;}
  public SelectElement(Name n){
    selectThese=new ArrayList<Name>();
    selectThese.add(n);
  }

  public List<XML> eval(Element element){
    if (selectThese.contains(element.getName())) 
      result.add(element);
    for (XML xml:(List<XML>)element.getChildren())
      xml.visit(this);
    return result;
  }
  public List<XML> eval(Comment comment){return result;}
  public List<XML> eval(Text text){return result;}
  public List<XML> eval(CDataSection cdata){return result;}
  public List<XML> eval(Entity entity){return result;}
  public List<XML> eval(ProcessingInstruction pi){return result;}
}

package name.panitz.xml;
import java.util.List;

public class Size extends  XMLVisitor<Integer> {
  int result=0;

  public Integer eval(Element element){
    result=result+1;
    for (XML xml:(List<XML>)element.getChildren())
      xml.visit(this);
    return result;
  }
  public Integer eval(Comment comment){
    result=result+1;return result;}
  public Integer eval(Text text){result=result+1;return result;}
  public Integer eval(CDataSection cdata){
    result=result+1;return result;}
  public Integer eval(Entity entity){
    result=result+1;return result;}
  public Integer eval(ProcessingInstruction pi){
    result=result+1;return result;}
}

package name.panitz.xml;
import java.util.List;

public class Depth extends  XMLVisitor<Integer> {
  public Integer eval(Element element){
    int result=0;
    for (XML xml:(List<XML>)element.getChildren()){
      final int currentDepth = xml.visit(this);
      result=result<currentDepth?currentDepth:result;
    }
    return result+1;
  }
  public Integer eval(Comment comment){return 1;}
  public Integer eval(Text text){return 1;}
  public Integer eval(CDataSection cdata){return 1;}
  public Integer eval(Entity entity){return 1;}
  public Integer eval(ProcessingInstruction pi){return 1;}
}

package name.panitz.xml;
import java.util.List;

public class Content extends XMLVisitor<StringBuffer> {
  StringBuffer result = new StringBuffer();

  public StringBuffer eval(Element element){
    for (XML xml:(List<XML>)element.getChildren())xml.visit(this);
    return result; }      
  public StringBuffer eval(Comment comment){return result;}
  public StringBuffer eval(Text text){
    result.append(text.getText());
    return result;}
  public StringBuffer eval(CDataSection cdata){
    result.append(cdata.getCdata());
    return result;}
  public StringBuffer eval(Entity entity){return result;} 
  public StringBuffer eval(ProcessingInstruction pi){
    return result;}
}

package name.panitz.xml;
import java.util.List;

public class ToHTML extends XMLVisitor<StringBuffer> {
  StringBuffer result = new StringBuffer();

  public StringBuffer eval(Element element){
    result.append("<dl>");
    result.append("<dt><tt><b><font color=\"red\">&lt;"
                  +element.getName()+"</font></b></tt>");
    if (!element.getAttributes().isEmpty()){
      result.append("<dl>");
      for (Attribute atr:(List<Attribute>)element.getAttributes()){
        result.append("<dd>");
        result.append("<b><font = color=\"blue\">"+atr.name);
        result.append("</font> = <font color=\"green\">");
        result.append("\""+atr.value+"\"</font></b>");
        result.append("</dd>");
      }
      result.append("</dl>");
    }
    result.append("<tt><b><font color=\"red\">");
    result.append("&gt;</font></b></tt></dt>");
    for (XML xml:(List<XML>)element.getChildren()){
      result.append("<dd>");
      xml.visit(this);
      result.append("</dd>");
    }
    result.append("<dt><tt><b><font color=\"red\">&lt;/"
                  +element.getName()+"&gt;</font></b></tt></dt>");
    result.append("</dl>");
    return result; }      
  public StringBuffer eval(Comment comment){return result;}
  public StringBuffer eval(Text text){
    result.append(text.getText());
    return result;}
  public StringBuffer eval(CDataSection cdata){
    result.append(cdata.getCdata());
    return result;}
  public StringBuffer eval(Entity entity){return result;} 
  public StringBuffer eval(ProcessingInstruction pi){
    return result;}
}

3.3.2  APIs für XML

DOM

interface org.w3c.dom.Node
 | 
 |--interface org.w3c.dom.Attr
 |--interface org.w3c.dom.CharacterData
 |   | 
 |   |--interface org.w3c.dom.Comment
 |   |--interface org.w3c.dom.Text
 |       |
 |       |--interface org.w3c.dom.CDATASection
 | 
 |--interface org.w3c.dom.Document
 |--interface org.w3c.dom.DocumentFragment
 |--interface org.w3c.dom.DocumentType
 |--interface org.w3c.dom.Element
 |--interface org.w3c.dom.Entity
 |--interface org.w3c.dom.EntityReference
 |--interface org.w3c.dom.Notation
 |--interface org.w3c.dom.ProcessingInstruction

int getLength()
Node item(int index)

Beispiel:
Wir können so eine statischen Methode zum Parsen eines XML-Dokuments schreiben:

package name.panitz.domtest;

import org.w3c.dom.Document;
import javax.xml.parsers.*;
import java.io.File;

public class ParseXML {
  public static Document parseXml(String xmlFileName){
    try{
     return
      DocumentBuilderFactory
       .newInstance()
       .newDocumentBuilder()
       .parse(new File(xmlFileName));
    }catch(Exception _){return null;}
  }

  public static void main(String [] args){
   System.out.println(parseXml(args[0]));
  }
}

sep@linux:~/fh/prog4/examples> java -classpath classes/ name.panitz.domtest.ParseXML ../skript.xml
[#document: null]

package name.panitz.domtest;

import org.w3c.dom.Node;

public class CountNodes{
  static int count(Node node){
    int result = 1;
    for (Node n:new NoteListIterator(node.getChildNodes()))
      result=result+count(n);
    return result; 
  }
  public static void main(String [] args){
    System.out.println(count(ParseXML.parseXml(args[0])));
  }
}

package name.panitz.domtest;

import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.Iterator;

public class NoteListIterator implements Iterator<Node>
                                       , Iterable<Node>{
  NodeList nodes;
  int current=-1;
  public NoteListIterator(NodeList n){nodes=n;}

  public Node next(){
    current=current+1; return nodes.item(current);}

  public boolean hasNext(){return current+1<nodes.getLength();}

  public void remove(){
    throw new UnsupportedOperationException();
  }

  public Iterator<Node> iterator(){return this;}
}

sep@linux:~/fh/prog4> java -classpath classes/ name.panitz.domtest.CountNodes skript.xml
1316

package name.panitz.domtest;

import org.w3c.dom.Node;

public class DomDepth{
  static int depth(Node node){
    int result = 0;
    for (Node n:new NoteListIterator(node.getChildNodes())){
      final int currentDepth = depth(n);
      if (result<currentDepth) result=currentDepth;
    }
    return result+1; 
  }
  public static void main(String [] args){
    System.out.println(depth(ParseXML.parseXml(args[0])));
  }
}

sep@linux:~/fh/prog4> java -classpath classes/ name.panitz.domtest.DomDepth skript.xml
13

package name.panitz.domtest;

import name.panitz.crempel.util.FromTo;
import java.util.Enumeration;
import java.util.Iterator;

import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
import org.w3c.dom.CharacterData;
import javax.swing.tree.*;
import javax.swing.*;

public class DomTreeNode implements TreeNode{
  Node node;
  public DomTreeNode(Node n){node=n;}

  public TreeNode getChildAt(int childIndex){
    return new DomTreeNode(node.getChildNodes().item(childIndex));
  }

  public int getChildCount(){
    return node.getChildNodes().getLength();}
  public boolean isLeaf(){
    return node.getChildNodes().getLength()==0;} 
  public TreeNode getParent(){
    return new DomTreeNode(node.getParentNode());}
  public boolean getAllowsChildren(){
    return (node instanceof Element);}
  public int getIndex(TreeNode n){
    final NodeList children = node.getChildNodes();
    for (Integer index : new FromTo(0,children.getLength()-1)){
      if (children.item(index).equals(n)) return index;
    }
    return -1;
  }  
  public Enumeration<Node>children(){
    return new Enumeration<Node>(){
      final Iterator<Node> it
         = new NoteListIterator(node.getChildNodes());
      public boolean hasMoreElements(){return it.hasNext();}
      public Node nextElement() {return it.next();}
    };
  }

  public String toString(){
    if (node instanceof CharacterData) return node.getNodeValue();
    return node.getNodeName();}

  public static void main(String [] args){
    JFrame f = new JFrame(args[0]);
    f.getContentPane()
     .add(
       new JTree(new DomTreeNode(ParseXML.parseXml(args[0]))));
    f.pack();
    f.setVisible(true);
  }
}

Node appendChild(Node newChild)      throws DOMException;
Node insertBefore(Node newChild,Node refChild)
                                      throws DOMException;
Node replaceChild(Node newChild,Node oldChild)
                                      throws DOMException;
Node removeChild (Node oldChild)      throws DOMException;

Attr createAttribute(String name); 
Attr createAttributeNS(String namespaceURI, String qualifiedName); 
CDATASection createCDATASection(String data);
Comment createComment(String data);
DocumentFragment createDocumentFragment(); 
Element createElement(String tagName);
Element createElementNS
                 (String namespaceURI, String qualifiedName); 
EntityReference createEntityReference(String name); 
ProcessingInstruction createProcessingInstruction
                                  (String target, String data); 
Text createTextNode(String data); 

SAX

package name.panitz.saxtest;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.*;
import org.xml.sax.*;
import java.io.File;

public class SaxParse{
  public static void parse(File file,DefaultHandler handler)
                               throws Exception{
    SAXParserFactory.newInstance()
                    .newSAXParser()
                    .parse(file,handler); 
  }  
}

package name.panitz.saxtest;
import org.xml.sax.helpers.DefaultHandler;
import java.util.*;
import org.xml.sax.*;

public class SaxCountNodes extends DefaultHandler{
  public int result = 0;
  public void startElement
   (String uri, String localName
   , String qName, Attributes attributes)
                          throws SAXException {
    result=result+1;
  }

  public static void main(String [] args) throws Exception{
    SaxCountNodes counter = new SaxCountNodes();
    SaxParse.parse(new java.io.File(args[0]),counter);
    System.out.println(counter.result); 
  }
}

package name.panitz.saxtest;
data class CodeFragment {
  CodeFragment(String progName,String packageName,String code);
}

package name.panitz.saxtest;
import org.xml.sax.helpers.DefaultHandler;
import java.util.*;
import org.xml.sax.*;

public class SelectNodes extends DefaultHandler{
  final List<String> names;
  final List<CodeFragment> result = new ArrayList<CodeFragment>();

  public SelectNodes(List<String> ls){names=ls;}
  public SelectNodes(String ls){
    names=new ArrayList<String>(); names.add(ls);}

  private StringBuffer currentCode = new StringBuffer();
  private String currentProgName = "";
  private String currentPackageName = "";

  public void startElement
   (String uri, String localName, String qName, Attributes attributes)
                throws SAXException {
     if (names.contains(qName)){
       currentCode = new StringBuffer();
       currentProgName = attributes.getValue("class");
       currentPackageName = attributes.getValue("package");
     }    
  }

  public void endElement
    (String uri, String localName, String qName)
                throws SAXException {
     if (names.contains(qName)){
       result.add(
         new CodeFragment
            (currentProgName
            ,currentPackageName
            ,currentCode.toString()));
     }    
  }

  public void characters(char[] ch,int start,int length)
                throws SAXException {
    currentCode.append(ch,start,length);
  }
}

package name.panitz.saxtest;

import javax.xml.parsers.*;
import java.io.*;

public class GetCode {
  public static void main(String [] args) throws Exception{
    final  SelectNodes selectCodeHandler = new SelectNodes("code"); 

    SaxParse.parse(new File(args[0]),selectCodeHandler); 
    final Writer out = new FileWriter(args[1]+".java"); 

    for (CodeFragment cf:selectCodeHandler.result){
      if (args[1].equals(cf.getProgName()))
        out.write(cf.getCode());
    }
    out.flush();
    out.close();
  }
}

package name.panitz.xml;

import name.panitz.crempel.util.FromTo;
import name.panitz.saxtest.*;
import org.xml.sax.helpers.DefaultHandler;
import java.util.*;
import org.xml.sax.*;

public class SaxToXML extends DefaultHandler{
  Stack<List<XML>> children = new Stack<List<XML>>();
  Stack<List<Attribute>> attributes = new Stack<List<Attribute>>();
  public SaxToXML(){children.push(new ArrayList<XML>());}

  public void startElement
   (String uri, String localName, String qName, Attributes attrs)
                throws SAXException {
    children.push(new ArrayList<XML>());
    ArrayList<Attribute> myAttrs = new ArrayList<Attribute>();
    for (int i:new FromTo(0,attrs.getLength()-1))
      myAttrs.add(
         new Attribute
          (new Name(attrs.getLocalName(i)
                   ,attrs.getQName(i)
                   ,attrs.getURI(i))
          ,attrs.getValue(i)));
    attributes.push(myAttrs);
  }

  public void endElement
    (String uri, String localName, String qName)
                throws SAXException {
    List<XML> chds = children.pop();
    children.peek().add(new Element(new Name(localName,qName,uri)
                                   ,attributes.pop()
                                   ,chds));
  }

  public void processingInstruction(String target,String data)
                           throws SAXException {

  }

  public void characters(char[] ch,int start,int length)
                throws SAXException {
    String text = new String(ch,start,length);
    children.peek().add(
     new Text(text.replace("<","&lt;")
                  .replace(">","&gt;")
                  .replace("&","&amp;")
                  .replace("\"","&quot;")
                  .replace("'","&apos;")
    ));

  }

  public static void main(String [] args) throws Exception{
    SaxToXML toXML = new SaxToXML();
    SaxParse.parse(new java.io.File(args[0]),toXML);
    XML doc = toXML.children.pop().get(0);
    System.out.println(doc.visit(new ToHTML()));
  }
}

3.4  Transformationen und Queries

3.4.1  XPath: Pfade in Dokumenten

• Zum Selektieren bestimmter Knoten in einem Dokument. Ausgehend von einem Wurzelknoten werden anhand des Ausdrucks aus dem Baum bestimmte Knoten selektiert.
• Zum Prüfen, ob ein Knoten die in dem Pfad beschriebene Eigenschaft hat. Ausgehend von einem Knoten wird anhand des Ausdrucks getestet, ob er diese beschriebene Pfadeigenschaft hat.

Achsen

package name.panitz.xml.xpath;
public enum AxisType 
  {self
  ,child
  ,descendant
  ,descendant_or_self
  ,parent
  ,ancestor
  ,ancestor_or_self
  ,following_sibling
  ,following
  ,preceding_sibling
  ,preceding
  ,namespace
  ,attribute
}

package name.panitz.xml.xpath;
import name.panitz.crempel.util.FromTo;
import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;
import name.panitz.domtest.*;

public class Axes{
  public static List<Node> nodelistToList (NodeList nl){
    List<Node> result = new ArrayList<Node>();
    for (int i:new FromTo(0,nl.getLength()-1)){
      result.add(nl.item(i));
    }
    return result;
  }

  public static List<Node> self(Node n){
    List<Node> result = new ArrayList<Node>();
    result.add(n);
    return result;
  }

  public static List<Node> child(Node n){
    return nodelistToList(n.getChildNodes());
  }

  public static List<Node> descendant(Node n){
    List<Node> result = new ArrayList<Node>();
    for (Node child:child(n)){
      result.add(child);
      result.addAll(descendant(child));
    }
    return result;
  }

  public static List<Node> descendant_or_self(Node n){
    List<Node> result = self(n);
    result.addAll(descendant(n));
    return result;
  }

  public static List<Node> parent(Node n){
     List<Node> result = new ArrayList<Node>();
     result.add(n.getParentNode());
     return result;
  }

  public static List<Node> ancestor(Node n){
    List<Node> result = new ArrayList<Node>();
    for (Node parent:parent(n)){
      if (parent!=null){
        result.addAll(ancestor(parent));
        result.add(parent);
      }
    }
    return result;
  }

  public static List<Node> ancestor_or_self(Node n){
    List<Node> result = ancestor(n);
    result.addAll(self(n));
    return result;
  }

  public static List<Node> following_sibling(Node n){
    List<Node> result = new ArrayList<Node>();
    int nodeType = n.getNodeType();
    boolean take = false;
    if (nodeType != Node.ATTRIBUTE_NODE){
      for (Node sibling:child(n.getParentNode())){
        if (take) result.add(sibling);
        if (sibling==n) take=true;
      }
    }
    return result;
  }

  public static List<Node> preceding_sibling(Node n){
    List<Node> result = new ArrayList<Node>();
    int nodeType = n.getNodeType();
    if (nodeType != Node.ATTRIBUTE_NODE){
      for (Node sibling:child(n.getParentNode())){
        if (sibling==n) break;
        result.add(sibling);
      }
    }
    return result;
  }

  public static List<Node> following(Node n){
    List<Node> result = new ArrayList<Node>();
    for (Node follow_sib:following_sibling(n)){
      result.add(follow_sib);
      result.addAll(descendant(follow_sib));
    }
    return result;
  }

  public static List<Node> preceding(Node n){
    List<Node> result = new ArrayList<Node>();
    for (Node preced_sib:preceding_sibling(n)){
      result.add(preced_sib);
      result.addAll(descendant(preced_sib));
    }
    return result;
  }

  public static List<Node> attribute(Node n){
    List<Node> result = new ArrayList<Node>();
    if (n.getNodeType()==Node.ELEMENT_NODE){
      NamedNodeMap nnm = n.getAttributes();
      for (int i:new FromTo(0,nnm.getLength()-1)){
        Node current = nnm.item(i);
        if (!current.getNodeName().startsWith("xmlns"))
          result.add(current);
      }
    }
    return result;
  }

  public static List<Node> namespace(Node n){
    List<Node> result = new ArrayList<Node>();
    if (n.getNodeType()==Node.ELEMENT_NODE){
      NamedNodeMap nnm = n.getAttributes();
      for (int i:new FromTo(0,nnm.getLength()-1)){  
        Node current = nnm.item(i);
        if (current.getNodeName().startsWith("xmlns"))
          result.add(current);
      }
    }
    return result;
  }

  public static List<Node> getAxis(Node n,AxisType axis){
    return ancestor(n); 
 /*   switch (axis){
      case ancestor          : return ancestor(n); 
      case ancestor_or_self  : return ancestor_or_self(n); 
      case attribute         : return attribute(n);
      case child             : return child(n); 
      case descendant        : return descendant(n); 
      case descendant_or_self: return descendant_or_self(n); 
      case following         : return following(n);
      case following_sibling : return following_sibling(n); 
      case namespace         : return namespace(n);
      case parent            : return parent(n);
      case preceding         : return preceding(n); 
      case preceding_sibling : return preceding_sibling(n);
      case self              : return self(n);
      default                :throw new UnsupportedOperationException();
    }*/
  }
}

Knotentest

axisType::nodeTest

• *: beschreibt Elementknoten mit beliebigen Namen.
• pref:*: beschreibt Elementknoten mit dem Prefix pref und beliebigen weiteren Namen.
• pref:name: beschreibt Elementknoten mit dem Prefix pref und den weiteren Namen name. Der Teil vor den Namen kann dabei auch fehlen.
• comment(): beschreibt Kommentarknoten.
• text(): beschreibt Textknoten.
• processing-instruction(): beschreibt Processing-Instruction-Knoten.
• processing-instruction(target): beschreibt Processing-Instruction-Knoten mit einem bestimmten Ziel.
• node(): beschreibt beliebige Knoten.

package name.panitz.xml.xpath;
import java.util.List;

data class NodeTest{
  StarTest();
  PrefixStar(String prefix);
  QName(String prefix,String name);
  IsComment();
  IsText();
  IsProcessingInstruction();
  IsNamedProcessingInstruction(String name);
  IsNode();
}

package name.panitz.xml.xpath;

public class ShowNodeTest extends NodeTestVisitor<String> {
  public String eval(StarTest _){return "*";}
  public String eval(PrefixStar e){return e.getPrefix()+":*";}
  public String eval(QName e){String result="";
    if (e.getPrefix().length()>0) result=e.getPrefix()+":";
    result=result+e.getName();
    return result;
  }
  public String eval(IsComment _){return "comment()";}
  public String eval(IsText _){return "text()";}
  public String eval(IsProcessingInstruction _){
    return "processing-instruction()";}
  public String eval(IsNamedProcessingInstruction e){
    return "processing-instruction("+e.getName()+")";
  }
  public String eval(IsNode _){return "node()";}
}

package name.panitz.xml.xpath;

import java.util.List;
import java.util.ArrayList;
import static org.w3c.dom.Node.*;
import org.w3c.dom.*;

public class DoNodeTest extends NodeTestVisitor<Boolean> {
  Node current;
  public DoNodeTest(Node n){current=n;}

  public Boolean eval(StarTest _){
    return    current.getNodeType()==ELEMENT_NODE
           || current.getNodeType()==ATTRIBUTE_NODE;
  }

  public Boolean eval(PrefixStar e){
    String currentPrefix = current.getPrefix();
    if (currentPrefix==null) currentPrefix="";
    return   new StarTest().visit(this) 
         && currentPrefix.equals(e.getPrefix());
  }

  public Boolean eval(QName e){
    return   new PrefixStar(e.getPrefix()).visit(this) 
         &&  current.getNodeName().equals(e.getName());
  }

  public Boolean eval(IsComment _){
    return current.getNodeType()==COMMENT_NODE;}

  public Boolean eval(IsText _){
    return current.getNodeType()==TEXT_NODE;}

  public Boolean eval(IsProcessingInstruction _){
    return current.getNodeType()==PROCESSING_INSTRUCTION_NODE;}

  public Boolean eval(IsNamedProcessingInstruction e){
    return current.getNodeType()==PROCESSING_INSTRUCTION_NODE
        && e.getName().equals(current.getNodeName());
  }

  public Boolean eval(IsNode _){return true;}

  static public List<Node> evalAxisExpr
        (AxisType axis,NodeTest test,Node context){
    List<Node> result = new ArrayList<Node>();
    for (Node node:Axes.getAxis(context,axis)){
      if (test.visit(new DoNodeTest(node)))
        result.add(node);
    }
    return result;
  }
}

Pfadangaben

Beispiel:
Der Ausdruck

Abkürzende Pfadangaben

Weitere abkürzende Schreibweisen

Beispiel:
Insgesamt läßt sich der obige Ausdruck abkürzen zu: skript/*//code/@class

Vereinigung

Beispiel:
Der Audruck /skript/kapitel | /skript/anhang/kapitel beschreibt die kapitel-Elemente die unter top-level Knoten skript hängen oder die unter einen Knoten anhang, der unter dem skript-Element hängt.

Funktionen und Operatoren

Beispiel:
Der Ausdruck count(//code) gibt die Anzahl der in einem Dokument enthaltenen code-Elemente zurück.

Literale

Beispiel:
Der Ausdruck count(//kapitel)=5 wertet zu true aus, wenn des Dokument genau fünf kapitel-Elemente hat.

Qualifizierung

Berechne die Ergebnisliste des Ausdrucks. Für jedes Element dieser Liste als aktuellen Kontextknoten berechne das Ergebnis des Prädikats. Interpretiere dieses Ergebnis als bool'schen Wert und verwerfe entweder den Kontextknoten oder nimm ihn in das Ergebnis aus.

Beispiel:
Der XPath-Ausdruck //code[@lang="hs"] selektiert alle Code-Knoten des Dokuments, die ein Attribut lang mit dem Wert hs haben.

Beispiel:
Der XPath-Ausdruck //example[.//code] selektiert alle example-Knoten des Dokuments, die mindestens einen code-Nachkommen haben. Also alle Beispiele, in denen ein Programm vorkommt.

Beispiel:
Der Ausdruck /skript/kapitel[3] selektiert jeweils das dritte kapitel-Element innerhalb eines skript-Elements.

Klammerung

Beispiel:
Der Ausdruck ./skript/(./kapitel | ./anhang) bezeichnet alle kapitel- oder anhang-Elemente ausgehend vom skript-Kind des Kontextknotens. Hingegen ./skript/kapitel | ./anhang bezeichnet die kapitel-Elemente unter dem skript-Kinder des Kontextknotens oder anhang-Kinder des Kontextknotens.

Algebraischer Typ für XPath-Ausdrücke

package name.panitz.xml.xpath;
import java.util.List;

data class XPath {
  Axis(AxisType type,NodeTest nodeTest);
  RootSlash(XPath expr);
  RootSlashSlash(XPath expr);
  Slash(XPath e1,XPath e2);
  SlashSlash(XPath e1,XPath e2);
  TagName(String name);
  AttributeName(String name);
  Dot();
  DotDot();
  NodeSelect();
  TextSelect();
  PISelect();
  CommentSelect();
  Star();
  AtStar();
  Union(XPath e1,XPath e2);
  Function(String name,List<XPath> arguments);
  BinOperator(String name, XPath e1,XPath e2);
  UnaryOperator(String name, XPath expr);
  QualifiedExpr(XPath expr,XPath qualifier); 
  NumLiteral(Double value);
  StringLiteral(String value);
}

package name.panitz.xml.xpath;

public class ShowXPath extends XPathVisitor<StringBuffer> {
  StringBuffer result = new StringBuffer();
  public StringBuffer eval(Axis e){
    result.append(e.getType());
    result.append("::");
    result.append(e.getNodeTest().visit(new ShowNodeTest()));
    return result;
  }
  public StringBuffer eval(RootSlash e){
    result.append("/"); e.getExpr().visit(this);
    return result;}
  public StringBuffer eval(RootSlashSlash e){
    result.append("//"); e.getExpr().visit(this);
    return result;}
  public StringBuffer eval(Slash e){
    e.getE1().visit(this);result.append("/");e.getE2().visit(this);
    return result;}
  public StringBuffer eval(SlashSlash e){
    e.getE1().visit(this);result.append("//");e.getE2().visit(this);
    return result;}
  public StringBuffer eval(TagName e){result.append(e.getName());
    return result;}
  public StringBuffer eval(AttributeName e){
    result.append("@");result.append(e.getName());
    return result;}
  public StringBuffer eval(Dot e){result.append(".");
    return result;}
  public StringBuffer eval(DotDot e){result.append("..");
    return result;}
  public StringBuffer eval(NodeSelect e){result.append("node()");
    return result;}
  public StringBuffer eval(TextSelect e){result.append("text()");
    return result;}
  public StringBuffer eval(CommentSelect e){result.append("comment()");
    return result;}
  public StringBuffer eval(PISelect e){
    result.append("processing-instruction()");
    return result;}
  public StringBuffer eval(Star e){result.append("*");
    return result;}
  public StringBuffer eval(AtStar e){result.append("@*");
    return result;}
  public StringBuffer eval(Union e){
    e.getE1().visit(this);result.append("|");e.getE2().visit(this);
    return result;}
  public StringBuffer eval(Function e){
    result.append(e.getName());result.append("(");
    boolean first = true;
    for (XPath arg:e.getArguments()){
      if (!first) result.append(",");else first=false;
      arg.visit(this);
    }
    result.append(")");
    return result;}
  public StringBuffer eval(UnaryOperator e){
    result.append(e.getName()+"\u0020");e.getExpr().visit(this);
    return result;}
  public StringBuffer eval(BinOperator e){
    e.getE1().visit(this);result.append("\u0020"+e.getName()+"\u0020");
    e.getE2().visit(this);return result;}
  public StringBuffer eval(QualifiedExpr e){
    e.getExpr().visit(this);result.append("[");
    e.getQualifier().visit(this);result.append("]");
    return result;}
  public StringBuffer eval(NumLiteral e){result.append(""+e.getValue());
    return result;}
  public StringBuffer eval(StringLiteral e){
   result.append("\"");result.append(e.getValue()) ;result.append("\"");
   return result;}
}

Entfernen von abkürzenden Schreibweisen

package name.panitz.xml.xpath;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;
import name.panitz.domtest.*;

public class RemoveAbbreviation extends XPathVisitor<XPath> {

new RootSlash(new Slash(new Axis(AxisType.descendant_or_self,new IsNode()),expr))

public XPath eval(RootSlashSlash e){
  /* //expr -> /descendant-or-self::node()/expr  */
  return 
    new RootSlash(
     new Slash(new Axis(AxisType.descendant_or_self,new IsNode())
              ,e.getExpr().visit(this)));}

public XPath eval(SlashSlash e){
  final XPath e1 = e.getE1();
  final XPath e2 = e.getE2();
  /* e1//e2 -> e1/descendant-or-self::node()/e2 */
  return 
   new Slash
     (e1.visit(this)
     ,new Slash(new Axis(AxisType.descendant_or_self,new IsNode())
               ,e2.visit(this)));}

public XPath eval(Dot e){
  return new Axis(AxisType.self,new IsNode());}

public XPath eval(DotDot e){
  return new Axis(AxisType.parent,new IsNode());}

public XPath eval(TagName e){
  return new Axis(AxisType.child,new QName("",e.getName()));}

public XPath eval(AttributeName e){
  return new Axis(AxisType.attribute,new QName("",e.getName()));}

public XPath eval(NodeSelect e){
  return new Axis(AxisType.child,new IsNode());}

public XPath eval(TextSelect e){
  return new Axis(AxisType.child,new IsText());}

public XPath eval(PISelect e){
  return new Axis(AxisType.child,new IsProcessingInstruction());}

public XPath eval(CommentSelect e){
  return new Axis(AxisType.child,new IsComment());}

public XPath eval(Star e){
  return new Axis(AxisType.child,new StarTest());}

public XPath eval(AtStar e){
  return new Axis(AxisType.attribute,new StarTest());}

public XPath eval(Slash e){
  return new Slash(e.getE1().visit(this),e.getE2().visit(this));}
public XPath eval(Axis e){return e;}
public XPath eval(RootSlash e){
  return new RootSlash(e.getExpr().visit(this));}
public XPath eval(Union e){
  return new Union(e.getE1().visit(this),e.getE2().visit(this));}
public XPath eval(Function e){
  final List<XPath> args = e.getArguments();
  List<XPath> newArgs = new ArrayList<XPath>();
  for (XPath arg:args) newArgs.add(arg.visit(this));
  return new Function(e.getName(),newArgs);}
public XPath eval(BinOperator e){
  return new BinOperator(e.getName()
                        ,e.getE1().visit(this)
                        ,e.getE2().visit(this));}
public XPath eval(UnaryOperator e){
  return new UnaryOperator(e.getName(),e.getExpr().visit(this));}
public XPath eval(QualifiedExpr e){
  return new QualifiedExpr(e.getExpr().visit(this)
                          ,e.getQualifier().visit(this));}
public XPath eval(NumLiteral e){return e;}
public XPath eval(StringLiteral e){return e;}
}

Auswerten von XPath Ausdrücken

package name.panitz.xml.xpath;
import org.w3c.dom.Node;
import java.util.List;

data class XPathResult {
  BooleanResult(Boolean value);
  NumResult(Double value);
  StringResult(String value);
  Nodes(List<Node> value);
}

• den Kontextknoten, auf den der Ausdruck angewendet werden soll.
• die Größe der Liste, in der der Knotextknoten ist.
• die Position des Kontextknotens in der Liste, in der er sich befindet.

package name.panitz.xml.xpath;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;
import static org.w3c.dom.Node.*;
import name.panitz.domtest.*;

import static name.panitz.xml.xpath.Axes.*;

public class EvalXPath extends XPathVisitor<XPathResult> {
  Node current;
  int contextPosition=1;
  int contextSize=1;

  public EvalXPath(Node n){current=n;}
  public EvalXPath(Node n,int pos,int size){
    this(n);contextPosition=pos;contextSize=size;}

  public XPathResult eval(Axis e){
    return new Nodes(
      DoNodeTest.evalAxisExpr(e.getType(),e.getNodeTest(),current));
  }

  public XPathResult eval(RootSlash e){
    Node doc ;
    if (current.getNodeType()==DOCUMENT_NODE) doc=current;
    else{
      doc = current.getOwnerDocument();
    }
    if (doc!=null) return e.getExpr().visit(new EvalXPath(doc));

    return new Nodes(new ArrayList<Node>());
  }

  public XPathResult eval(Slash e){
    XPathResult res1 = e.getE1().visit(this);

    if (res1 instanceof Nodes){
      final List<Node> resultNodes = new ArrayList<Node>();
      final List<Node> e1s = ((Nodes)res1).getValue();
      final int size = e1s.size();
      int pos = 1;
      for (Node e1:e1s){
        XPathResult e2s = e.getE2().visit(new EvalXPath(e1,pos,size));
        if (e2s instanceof Nodes)
           resultNodes.addAll(((Nodes)e2s).getValue());
        else return e2s;
        pos=pos+1;
      }
      return new Nodes(resultNodes);
    }
    return res1;
  }

  public XPathResult eval(Union e){
    XPathResult r1 = e.getE1().visit(this);
    XPathResult r2 = e.getE1().visit(this);
    if (r1 instanceof Nodes && r2 instanceof Nodes){
      List<Node> resultNodes = ((Nodes)r1).getValue();
      resultNodes.addAll(((Nodes)r2).getValue());
      return new Nodes(resultNodes);
    }
    return r1;
  }

  public XPathResult  eval(NumLiteral e){
    return new NumResult(e.getValue());}

  public XPathResult  eval(StringLiteral e){
    return new StringResult(e.getValue());}

  public XPathResult  eval(QualifiedExpr e){
    XPathResult result1 = e.getExpr().visit(this);
    if (result1 instanceof Nodes){
      final List<Node> resultNodes = new ArrayList<Node>();
      final List<Node> rs = ((Nodes)result1).getValue();
      final int size = rs.size();
      int pos = 1;
      for (Node r : rs){
        XPathResult qs 
           = e.getQualifier().visit(new EvalXPath(r,pos,size));
        if (qs.visit(new TestQualifier(r,pos,size)))
          resultNodes.add(r);
        pos=pos+1;
      }
      return new Nodes(resultNodes);
    }
    return result1;
  }

  public XPathResult  eval(RootSlashSlash e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(SlashSlash e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(TagName e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(AttributeName e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(Dot e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(DotDot e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(NodeSelect e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(TextSelect e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(PISelect e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(CommentSelect e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(Star e){
   throw new UnsupportedOperationException();}
  public XPathResult  eval(AtStar e){
   throw new UnsupportedOperationException();}

  public XPathResult  eval(Function e){
   throw new UnsupportedOperationException();
  }
  public XPathResult  eval(BinOperator e){
   throw new UnsupportedOperationException();
  }
  public XPathResult  eval(UnaryOperator e){
   throw new UnsupportedOperationException();
  }

  public static XPathResult eval(XPath xpath,Node n){
    System.out.println(xpath.visit(new NormalizeXPath())
                            .visit(new ShowXPath()));

    System.out.println(xpath.visit(new NormalizeXPath())
                            .visit(new RemoveAbbreviation())
                            .visit(new ShowXPath()));

    return xpath.visit(new NormalizeXPath())
                .visit(new RemoveAbbreviation())
                .visit(new EvalXPath(n));
  }

  public static void main(String [] args){
    Node doc = ParseXML.parseXml(args[0]);

    XPathResult result 
     =  eval(new QualifiedExpr
           (new RootSlashSlash
               (new Slash(new TagName("code"),new AttributeName("class")))
           ,new StringLiteral("XPath"))
            ,doc);
    System.out.println(result);

    result 
     =  eval
         (new QualifiedExpr(new RootSlash
            (new Slash(new TagName("skript")
            ,new Slash(new TagName("kapitel")
            ,new Slash(new TagName("section"),new DotDot()))))
          ,new NumLiteral(1))
         ,doc);

    System.out.println(result);

    result 
     =  eval
         (new RootSlash
            (new Slash(new TagName("skript")
            ,new Slash(new TagName("kapitel")
            ,new QualifiedExpr(new TagName("section"),new NumLiteral(2)))))
         ,doc);

    System.out.println(result);
  }
}

package name.panitz.xml.xpath;

import org.w3c.dom.Node;

public class TestQualifier extends XPathResultVisitor<Boolean> {
  final int pos;
  final int size;
  final Node context;

  public TestQualifier(Node c,int p,int s){context=c;pos=p;size=s;}

  public Boolean eval(BooleanResult e){return e.getValue();}
  public Boolean eval(NumResult e){return e.getValue()==pos;}
  public Boolean eval(StringResult e) {
   return e.getValue().equals(context.getNodeValue());}
  public Boolean eval(Nodes e) {return !e.getValue().isEmpty();}
}

package name.panitz.xml.xpath;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;
import name.panitz.domtest.*;

public class NormalizeXPath extends XPathVisitor<XPath> {

public XPath eval(Axis e){return e;}

public XPath eval(RootSlash e){
  final XPath n1 = e.getExpr();
  return new RootSlash(e.getExpr().visit(this));}


public XPath eval(RootSlashSlash e){
  return new RootSlashSlash(e.getExpr().visit(this));}

/**  mache Slash(Slash(e1,e2),e3)
   zu Slash(e1,Slash(e2,e3))
und
  mache Slash(SlashSlash(e1,e2),e3)
   zu SlashSlash(e1,Slash(e2,e3))
*/

public XPath eval(Slash e){
  final XPath n1 = e.getE1();
  final XPath e3 = e.getE2();
  if (n1 instanceof Slash){
    final XPath e1 = ((Slash)n1).getE1();
    final XPath e2 = ((Slash)n1).getE2();
    return new Slash(e1,new Slash(e2,e3)).visit(this);    
  }
  if (n1 instanceof SlashSlash){
    final XPath e1 = ((SlashSlash)n1).getE1();
    final XPath e2 = ((SlashSlash)n1).getE2();
    return new SlashSlash(e1,new Slash(e2,e3)).visit(this);    
  }
  return new Slash(n1.visit(this),e3.visit(this));
}

public XPath eval(SlashSlash e){
  final XPath n1 = e.getE1();
  final XPath e3 = e.getE2();
  if (n1 instanceof Slash){
    final XPath e1 = ((Slash)n1).getE1();
    final XPath e2 = ((Slash)n1).getE2();
    return new Slash(e1,new SlashSlash(e2,e3)).visit(this);    
  }
  if (n1 instanceof SlashSlash){
    final XPath e1 = ((SlashSlash)n1).getE1();
    final XPath e2 = ((SlashSlash)n1).getE2();
    return new SlashSlash(e1,new SlashSlash(e2,e3)).visit(this);    
  }
  return new Slash(n1.visit(this),e3.visit(this));
}

public XPath eval(Union e){
  return new Union(e.getE1().visit(this),e.getE2().visit(this));}
public XPath eval(TagName e){return e;}
public XPath eval(AttributeName e){return e;}
public XPath eval(Dot e){return e;}
public XPath eval(DotDot e){return e;}
public XPath eval(NodeSelect e){return e;}
public XPath eval(TextSelect e){return e;}
public XPath eval(PISelect e){return e;}
public XPath eval(CommentSelect e){return e;}
public XPath eval(Star e){return e;}
public XPath eval(AtStar e){return e;}

public XPath eval(Function e){return e;}
public XPath eval(BinOperator e){return e;}
public XPath eval(UnaryOperator e){return e;}
public XPath eval(QualifiedExpr e){
  return new QualifiedExpr(e.getExpr().visit(this)
                          ,e.getQualifier().visit(this));}
public XPath eval(NumLiteral e){return e;}
public XPath eval(StringLiteral e){return e;}
}

3.4.2  XSLT: Transformationen in Dokumenten

Beispiel:
Wir werden die wichtigsten XSLT-Konstrukte mit folgendem kleinem XML Dokument ausprobieren:

<?xml version="1.0" encoding="iso-8859-1" ?>
<?xml-stylesheet type="text/xsl" href="cdTable.xsl"?>
<cds>
 <cd>
  <artist>The Beatles</artist>
  <title>White Album</title>
  <label>Apple</label>
 </cd>
 <cd>
  <artist>The Beatles</artist>
  <title>Rubber Soul</title>
  <label>Parlophone</label>
 </cd>
 <cd>
  <artist>Duran Duran</artist>
  <title>Rio</title>
  <label>Tritec</label>
 </cd>
 <cd>
  <artist>Depeche Mode</artist>
  <title>Construction Time Again</title>
  <label>Mute</label>
 </cd>
 <cd>
  <artist>Yazoo</artist>
  <title>Upstairs at Eric's</title>
  <label>Mute</label>
 </cd>
 <cd>
  <artist>Marc Almond</artist>
  <title>Absinthe</title>
  <label>Some Bizarre</label>
 </cd>
 <cd>
  <artist>ABC</artist>
  <title>Beauty Stab</title>
  <label>Mercury</label>
 </cd>
</cds>

Gesamtstruktur

<?xml version="1.0" encoding="iso-8859-1" ?>
<xsl:stylesheet 
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
</xsl:stylesheet>

<?xml version="1.0" encoding="iso-8859-1" ?>
<?xml-stylesheet type="text/xsl" href="cdTable.xsl"?>
<cds>
 <cd>........

Templates (Formulare)

Beispiel:
Folgendes XSLT-Skript transformiert die XML-Datei mit den CDs in eine HTML-Tabelle, in der die CDs tabellarisch aufgelistet sind.

<?xml version="1.0" encoding="iso-8859-1" ?>
<xsl:stylesheet 
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<!-- Startregel für das ganze Dokument. -->
<xsl:template match="/">
  <html><head><title>CD Tabelle</title></head>
    <body>
      <xsl:apply-templates/>
    </body>
  </html>   
</xsl:template>


<!-- Regel für die CD-Liste. -->
<xsl:template match="cds">
  <table border="1">
    <tr><td><b>Interpret</b></td><td><b>Titel</b></td></tr>
    <xsl:apply-templates/>
  </table>
</xsl:template>

<xsl:template match="cd">
  <tr><xsl:apply-templates/></tr>
</xsl:template>

<xsl:template match="artist">
  <td><xsl:apply-templates/></td>
</xsl:template>

<xsl:template match="title">
  <td><xsl:apply-templates/></td>
</xsl:template>

<!-- Regel für alle übrigen Elemente. 
     Mit diesen soll nichts gemacht werden -->
<xsl:template match="*">
</xsl:template>

</xsl:stylesheet>

Öffnen wir nun die XML Datei, die unsere CD-Liste enthält im Webbrowser, so wendet er die Regeln des referenzierten XSLT-Skriptes an und zeigt die so generierte Webseite wie in Abbildung 3.3 zu sehen an.

Figure 3.3: Anzeige der per XSLT-Skript generierten HTML-Seite.

Auswahl von Teildokumenten

Beispiel:
Im folgenden XSL Element selektieren wir für cd-Elemente nur die title und artist Kinder und ignorieren die label Kinder.

<!-- für das Element "cd" -->
<xsl:template match="cd">
 <!--erzeuge ein Element "tr" -->
 <tr>
   <!-- wende das stylesheet weiter an auf die Kinderelemente
   "title" -->
   <xsl:apply-templates select="title"/>
   <!-- wende das stylesheet weiter an auf die Kinderelemente
   "artist" -->
   <xsl:apply-templates select="artist"/>
 </tr>
</xsl:template>

Sortieren von Dokumentteilen

Beispiel:
Zum Sortieren der CD-Liste kann mit xsl:sort das Unterelement artist als Sortierschlüssel bestimmt werden.

<xsl:template match="cds">
  <table border="1">
    <tr><td><b>Interpret</b></td><td><b>Titel</b></td></tr>
    <xsl:apply-templates select="cd">
      <xsl:sort select="artist"/> 
    </xsl:apply-templates>
  </table>
</xsl:template>

Weitere Konstrukte

XSLT in Java

package name.panitz.xml.xslt;

import org.w3c.dom.Node;

import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.TransformerException; 

import java.io.StringWriter; 
import java.io.File ;

public class XSLT {
  static public String transform(File xslt,File doc){
    return transform(new StreamSource(doc),new StreamSource(doc));
  }

  static public String transform(Source xslt,Source doc){
    try{
      StringWriter writer = new StringWriter();
      Transformer t =
         TransformerFactory
          .newInstance()
          .newTransformer(xslt);
      t.transform(doc,new StreamResult(writer));
      return writer.getBuffer().toString();
    }catch (TransformerException _){
      return "";
    }
  }

  public static void main(String [] args)throws Exception {
    System.out.println(transform(new File(args[0]),new File(args[1])));
  }

}

3.4.3  XQuery: Anfragen

declare function fac($n) {if ($n=0) then 1 else $n*fac($n - 1)};
fac(5)

declare function fac($n) {if ($n=0) then 1 else $n*fac($n - 1)};

<html><body>fac(5)={fac(5)}</body></html>

count(doc("/home/sep/fh/prog4/skript.xml")//kapitel)

let $name := distinct-values
                (doc("/home/sep/fh/prog4/skript.xml")//code/@class)
return count($name)

<ul>{
for $name in distinct-values(doc("/home/sep/fh/prog4/skript.xml")//code/@class)
return <li>
         {string($name)}
       </li>
}</ul>

<ul>{
for $name in distinct-values(doc("/home/sep/fh/prog4/skript.xml")//code/@class)
order by $name
return <li>
         {string($name)}
       </li>
}</ul>

<html>
<title>Klassen aus dem Skript</title>
<body>
<ul>{
let $codeFrags := doc("/home/sep/fh/prog4/skript.xml")//code[@class]
let 
 $codes := 
   for $name in distinct-values($codeFrags/@class)
   let $codeFrag := $codeFrags[@class=$name][1]
   return 
     <code>
        <className>{string($codeFrag/@class)}</classname>
        <lang>{if ($codeFrag/@lang) 
               then string($codeFrag/@lang) 
               else "java"}</lang>
        <package>{if ($codeFrag/@package) 
                  then string($codeFrag/@package) 
                  else "."}</package>
     </code>
for $code in $codes
order by $code/className
return 
  let $name:= ($code/className/text(),".",$code/lang/text())
  let $fullname:= ($code/package/text(),"/",$name)
  return
    <li><a>{attribute href {$fullname}}{$name}</a></li>
}</ul></body></html>

3.5  Dokumenttypen

3.5.1  DTD

• <!DOCTYPE root-element [ doctype-declaration... ]>
  Legt den Namen des top-level Elements fest und enthält die gesammte Definition des erlaubten Inhalts.
• <!ELEMENT element-name content-model>
  assoziiert einen content model mit allen Elementen, die diesen Namen haben.
content models können wie folgt gebildet werden.:
• EMPTY: Das Element hat keinen Inhalt.
• ANY: Das Element hat einen beliebigen Inhalt
• #PCDATA: Zeichenkette, also der eigentliche Text.
• durch einen regulären Ausdruck, der aus den folgenden Komponenten gebildet werden kann.
  • Auswahl von Alternativen (oder): (...|...|...)
  • Sequenz von Ausdrücken: (...,...,...)
  • Option: ...?
  • Ein bis mehrfach Wiederholung: ...*
  • Null bis mehrfache Wiederholung: ...+
• <!ATTLISTelement-name attr-name attr-type attr-default ...>
  Liste, die definiert, was für Attribute ein Element hat:
Attribute werden definiert durch:
• CDATA: beliebiger Text ist erlaubt
• (value|...): Aufzählung erlaubter Werte
Attribut default sind:
• #REQUIRED: Das Attribut muß immer vorhanden sein.
• #IMPLIED: Das Attribut ist optional
• "value": Standardwert, wenn das Attribut fehlt.
• #FIXED "value": Attribut kennt nur diesen Wert.

Beispiel:
Ein Beispiel für eine DTD, die ein Format für eine Rezeptsammlung definiert.

<!DOCTYPE collection SYSTEM "collection.dtd" [
<!ELEMENT collection (description,recipe*)>

<!ELEMENT description ANY>

<!ELEMENT recipe (title,ingredient*,preparation
                 ,comment?,nutrition)>

<!ELEMENT title (#PCDATA)>

<!ELEMENT ingredient (ingredient*,preparation)?>
<!ATTLIST ingredient name CDATA #REQUIRED
                     amount CDATA #IMPLIED
                     unit CDATA #IMPLIED>

<!ELEMENT preparation (step)*>

<!ELEMENT step (#PCDATA)>

<!ELEMENT comment (#PCDATA)>

<!ELEMENT nutrition EMPTY>
<!ATTLIST nutrition fat CDATA #REQUIRED
                    calories CDATA #REQUIRED
                    alcohol CDATA #IMPLIED>]>

3.5.2  Schema

3.5.3  Geläufige Dokumenttypen

XHTML

SVG

Beispiel:
Folgendes kleine SVG-Dokument definiert eine Graphik, die einen Kreis, ein Viereck und einen Text enthält.

<?xml version="1.0" encoding="ISO-8859-1"?>
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200">
 <ellipse cx="100" cy="100" rx="48" ry="90" fill="limegreen" />
 <text x="20" y="115">SVG Textobjekt</text>
 <rect x="50" y="50" width="50" height="60" fill="red"/>
</svg>

3.6  Aufgaben

{\bf \alph{unteraufgabe})}

<a>to be </a><b> or not to be</b>

Lösung
Kein top-level Element, das das ganze Dokument umschließt.
{\bf \alph{unteraufgabe})}

<person geburtsjahr=1767>Ferdinand Carulli</person>

Lösung
Attributwerte müssen in Anführungszeichen stehen.
{\bf \alph{unteraufgabe})}

<line>lebt wohl<br/>
<b>Gott weiß, wann wir uns wiedersehen</line>

Lösung
<b> wird nicht geschlossen.
{\bf \alph{unteraufgabe})}

<kockrezept><!--habe ich aus dem Netz
  <name>Saltimbocca</name>
  <zubereitung>Zutaten aufeinanderlegen 
               und braten.</zubereitung>
</kockrezept>

Lösung
Kommentar wird nicht geschlossen.
{\bf \alph{unteraufgabe})}

<cd>
  <artist>dead&alive</artist>
  <title>you spin me round</title></cd>

Lösung
Das Zeichen & muß als character entity &amp; geschrieben werden.

<?xml version="1.0" encoding="iso-8859-1" ?>
<autoren>
<autor>
  <person>
    <nachname>Shakespeare</nachname>
    <vorname>William</vorname>
  </person>
  <werke>
    <opus>Hamlet</opus>
    <opus>Macbeth</opus>
    <opus>King Lear</opus>
  </werke>
</autor>
<autor>
  <person>
    <nachname>Kane</nachname>
    <vorname>Sarah</vorname>
  </person>
  <werke>
    <opus>Gesäubert</opus>
    <opus>Psychose 4.48</opus>
    <opus>Gier</opus>
  </werke>
</autor>
</autoren>

{\bf \alph{unteraufgabe})} Schreiben Sie eine DTD, das die Struktur dieses Dokuments beschreibt.
Lösung

AutorenType
<!DOCTYPE autoren SYSTEM "AutorenType.dtd" [
<!ELEMENT autoren (autor+)>
<!ELEMENT autor (person,werke)>
<!ELEMENT werke (opus*)>
<!ELEMENT opus (#PCDATA)>
<!ELEMENT person (nachname,vorname)>
<!ELEMENT nachname (#PCDATA)>
<!ELEMENT vorname (#PCDATA)>]>

{\bf \alph{unteraufgabe})} Entwerfen Sie Java Schnittstellen, die Objekte ihrer DTD beschreiben.
Lösung

Autoren

package name.panitz.xml.exercise;
import java.util.List;
public interface Autoren {
  List<Autor> getAutorList();
}

Autor

package name.panitz.xml.exercise;
public interface Autor {
  Person getPerson();
  Werke  getWerke();
}

Person

package name.panitz.xml.exercise;
public interface Person {
  Nachname getNachname();
  Vorname  getVorname();
}

Werke

package name.panitz.xml.exercise;
import java.util.List;
public interface Werke {
  List<Opus> getOpusList();
}

HasJustTextChild

package name.panitz.xml.exercise;
public interface HasJustTextChild {
  String getText();
}

Opus

package name.panitz.xml.exercise;
public interface Opus extends HasJustTextChild {}

Nachname

package name.panitz.xml.exercise;
public interface Nachname extends HasJustTextChild {}

Vorname
package name.panitz.xml.exercise;
public interface Vorname extends HasJustTextChild {}

{\bf \alph{unteraufgabe})} Schreiben Sie ein XSLT-Skript, das obige Dokument in eine Html Liste der Werke ohne Autorangabe transformiert.
Lösung

WerkeListe
<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
     <html><head><title>Werke</title></head>
       <body><xsl:apply-templates /></body>
     </html>
  </xsl:template>

  <xsl:template match="autoren">
     <ul><xsl:apply-templates select="autor/werke/opus"/></ul>
  </xsl:template>

  <xsl:template match="opus">
     <li><xsl:apply-templates/></li>
  </xsl:template>
</xsl:stylesheet>

{\bf \alph{unteraufgabe})} Schreiben Sie eine Javamethode
List<String> getWerkListe(Autoren autoren);,
die auf den Objekten Ihrer Schnittstelle für Autoren eine Liste von Werknamen erzeugt.
Lösung

GetWerke

package name.panitz.xml.exercise;
import java.util.List;
import java.util.ArrayList;

public class GetWerke{
  public List<String> getWerkListe(Autoren autoren){
    List<String> result = new ArrayList<String>();
    for (Autor a:autoren.getAutorList()){
      for (Opus opus: a.getWerke().getOpusList())
        result.add(opus.getText());
    }
    return result;
  }
}

<?xml version="1.0" encoding="iso-8859-1" ?>
<x1><x2><x5>5</x5><x6>6</x6></x2><x3><x7>7</x7></x3>
<x4><x8/><x9><x10><x11></x11></x10></x9></x4></x1>

{\bf \alph{unteraufgabe})} Zeichnen Sie dieses Dokument als Baum.
{\bf \alph{unteraufgabe})} Welche Dokumente selektieren, die folgenden XPath-Ausdrücke ausgehend von der Wurzel dieses Dokuments
• //x5/x6
• /descendant-or-self::x5/..
• //x5/ancestor::*
• /x1/x2/following-sibling::*
• /descendant-or-self::text()/parent::node()

package name.panitz.xml.exercise;
import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;

public class GetLeaves{
  public List<Node> getLeaves(Node n){
    List<Node> result = new ArrayList<Node>();
    NodeList ns = n.getChildNodes();
    if (ns.getLength()==0){
      result.add(n); return result;
    }
    for (int i=0;i<ns.getLength();i++){
      result.addAll(getLeaves(ns.item(i)));
    }
    return result;
  }
}

Chapter 4
Parsing XML Document Type Structures

4.1  Introduction

4.1.1  Functional Programming

Parser Combinators

type Parser result token = [token] -> [(result,[token])]

getToken tok [] = []
getToken tok (x:xs)
  |tok==x = [(x,xs)]
  |otherwise = []

• the sequence of two parsers.
• the alternativ of two parsers.

alt p1 p2 toks 
  |null res1 = p2 toks
  |otherwise = res1
 where
  res1 = p1 toks

seqP p1 p2 toks = concat
  [[((rs1,rs2),tks2) |(rs2,tks2)<-(p2 tks1) ] 
  |(rs1,tks1)<-p1 toks]

mapP f p toks = [(f rs,tks)|(rs,tks)<-p toks]

Beispiel:
A very simple parser implementation in Haskell:

parantheses = mapP (\((x1,x2),x3) -> x2)
     (getToken '(' `seqP` a `seqP` getToken ')')

a = getToken 'a' `alt` parantheses

main = do 
  print (parantheses "((((a))))")
  print (parantheses "((((a)))")
  print (parantheses "((((a))))bc")

sep@linux:~/fh/xmlparslib/examples> src/HsParse
[('a',"")]
[]
[('a',"bc")]
sep@linux:~/fh/xmlparslib/examples>

4.1.2  XML

Document Type Definition

• sequences of elements, denoted by a comma ,.
• alternatives of elements donoted by the vertical bar |.
• several kinds of repetition denoted by +, * and ?.

<!DOCTYPE musiccollection SYSTEM "musiccollection.dtd" [
  <!ELEMENT musiccollection (lp|cd|mc)*>  
  <!ELEMENT lp (title,artist,recordingyear?,track+,note*)>  
  <!ELEMENT cd (title,artist,recordingyear?,track+,note*)>  
  <!ELEMENT mc (title,artist,recordingyear?,track+,note*)>  
  <!ELEMENT track (title,timing?)>  
  <!ELEMENT note (#PCDATA|author)*>

  <!ELEMENT timing (#PCDATA)>  
  <!ELEMENT title (#PCDATA)>  
  <!ELEMENT artist (#PCDATA)>  
  <!ELEMENT author (#PCDATA)>  
  <!ELEMENT recordingyear (#PCDATA)>  
]>

<?xml version="1.0" encoding="iso-8859-1" ?>
<musiccollection>
  <lp>
    <title>White Album</title>
    <artist>The Beatles</artist>
    <recordingyear>1968</recordingyear>
    <track><title>Revolution 9</title></track>
    <note><author>sep</author>my first lp</note>
  </lp>
  <cd>
    <title>Open All Night</title>
    <artist>Marc Almond</artist>
    <track><title>Tragedy</title></track>
    <note>
     <author>sep</author>
     Marc sung tainted love in the bandSoft Cell</note>
  </cd>
</musiccollection>

<?xml version="1.0" encoding="iso-8859-1" ?>
<musiccollection/>

4.1.3  Java

Generic Types

4.2  Tree Parser

4.2.1  Parser Type

package name.panitz.crempel.util.xml.parslib;

import name.panitz.crempel.util.Tuple2;
import java.util.List;
import org.w3c.dom.Node;

public class ParseResult<a> extends Tuple2<a,List<Node>>{
  public ParseResult(a n,List<Node> xs){super(n,xs);}

  public boolean failed(){return false;}
}

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import org.w3c.dom.Node;

public class Fail<a> extends ParseResult<a>{
  public Fail(List<Node> xs){super(null,xs);}
  public boolean failed(){return true;}
}

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.Node;
import name.panitz.crempel.util.Maybe;
import name.panitz.crempel.util.Tuple2;
import name.panitz.crempel.util.UnaryFunction;

public interface  Parser<a>{
  public ParseResult<a> parse(List<Node> xs);

4.2.2  Combinators

• seq to create a sequence of this parser with some other parser.
• choice to create an alternative of this or some other parser.
• star to create a zero or more repetition parser of this parser.
• plus to create a one or more repetition parser of this parser.
• query to create a zero or one repetition parser of this parser.
• map to create a parser from this parser, which modifies the parse result with some further method.

  public <b> Parser<Tuple2<a,b>> seq(Parser<b> p2);
  public <b extends a> Parser<a> choice(Parser<b> p2);
  public Parser<List<a>> star();
  public Parser<List<a>> plus();
  public Parser<Maybe<a>> query();
  public <b> Parser<b> map(UnaryFunction<a,b> f);
}

Optional Parser

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import name.panitz.crempel.util.Maybe;
import name.panitz.crempel.util.Nothing;
import name.panitz.crempel.util.Just;
import org.w3c.dom.Node;

public  class Optional<a> extends  AbstractParser<Maybe<a>> {
  final Parser<a> p;
  public Optional(Parser<a> _p){p=_p;}
  public ParseResult<Maybe<a>> parse(List<Node> xs){
    final ParseResult<a> res = p.parse(xs);
    if (res.failed())
      return new ParseResult<Maybe<a>>(new Nothing<a>(),xs); 
    return new ParseResult<Maybe<a>>(new Just<a>(res.e1),res.e2);
  }
}

Sequence

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import name.panitz.crempel.util.Tuple2;
import org.w3c.dom.Node;

public  class Seq<a,b> extends  AbstractParser<Tuple2<a,b>> {
  final Parser<a> p1;
  final Parser<b> p2;

  public Seq(Parser<a> _p1,Parser<b> _p2){p1=_p1;p2=_p2;}

  public ParseResult<Tuple2<a,b>> parse(List<Node> xs){ 
    ParseResult<a> res1 = p1.parse(xs);
    if (res1.failed())
      return new Fail<Tuple2<a,b>>(xs);
    ParseResult<b> res2 = p2.parse(res1.e2);
    if (res2.failed())
      return new Fail<Tuple2<a,b>>(xs);
    return new ParseResult<Tuple2<a,b>>
                 (new Tuple2<a,b>(res1.e1,res2.e1),res2.e2);
  }
}

Choice

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import java.util.ArrayList;
import name.panitz.crempel.util.Tuple2;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class  Choice<c,a extends c,b extends c> 
  extends  AbstractParser<c> {
  final Parser<a> p1;
  final Parser<b> p2;

  public Choice(Parser<a> _p1,Parser<b> _p2){p1=_p1;p2=_p2;}

  public ParseResult<c> parse(List<Node> xs){ 
    final ParseResult<a> res1 =  p1.parse(xs);
    if (res1.failed()){
      final ParseResult<b> res2 = p2.parse(xs);
      if (res2.failed()) return new Fail<c>(xs);
      return new  ParseResult<c>(res2.e1,res2.e2);
    }
    return new  ParseResult<c>(res1.e1,res1.e2);
  }
}

Repetitions

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.Node;

public  class Repetition<a> extends  AbstractParser<List<a>> {
  final Parser<a> p;
  final boolean atLeastOne;
  public Repetition(Parser<a> _p,boolean one){
    p=_p;atLeastOne=one;
  }

  public ParseResult<List<a>> parse(List<Node> xs){
    final List<a> resultList = new ArrayList<a>();
    int i = 0;

    while (true){
      final ParseResult<a> res = p.parse(xs);
      xs=res.e2;

      if (res.failed()) break;
      resultList.add(res.e1);
    }

    if (resultList.isEmpty()&& atLeastOne) 
      return new Fail<List<a>>(xs);
    return new ParseResult<List<a>>(resultList,xs);
  }
}

package name.panitz.crempel.util.xml.parslib;

import java.util.List;

public class Star<a> extends Repetition<a> {
  public Star(Parser<a> p){super(p,false);}
}

package name.panitz.crempel.util.xml.parslib;

import java.util.List;

public class Plus<a> extends Repetition<a> {
  public Plus(Parser<a> p){super(p,true);}
}

Map

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import org.w3c.dom.Node;
import name.panitz.crempel.util.UnaryFunction;

public class Map<a,b> extends AbstractParser<b> {
  final Parser<a> p;
  final UnaryFunction<a,b> f;

  public Map(UnaryFunction<a,b> _f,Parser<a> _p){f=_f;p=_p;}

  public ParseResult<b> parse(List<Node> xs){
    final ParseResult<a> res = p.parse(xs);
    if (res.failed()) return new Fail<b>(xs);
    return new ParseResult<b>(f.eval(res.e1),res.e2); 
  }
}

Abstract Parser Class

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import name.panitz.crempel.util.Tuple2;
import name.panitz.crempel.util.Maybe;
import name.panitz.crempel.util.UnaryFunction;

public abstract class AbstractParser<a> implements Parser<a>{
  public <b> Parser<Tuple2<a,b>> seq(Parser<b> p2){
    return new Seq<a,b>(this,p2);
  }

  public <b extends a> Parser<a> choice(Parser<b> p2){
    return new Choice<a,a,b>(this,p2);
  }

  public Parser<List<a>> star(){return new Star<a>(this);}
  public Parser<List<a>> plus(){return new Plus<a>(this);}
  public Parser<Maybe<a>> query(){return new Optional<a>(this);}
  public <b> Parser<b> map(UnaryFunction<a,b> f){
    return new Map<a,b>(f,this);
  }
}

4.2.3  Atomic Parsers

PCDATA

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import org.w3c.dom.Node;

public class PCData extends AbstractParser<String> {

  public ParseResult<String> parse(List<Node> xs){
    if (xs.isEmpty()) return new Fail<String>(xs);
    final Node x = xs.get(0);
    if (x.getNodeType()==Node.TEXT_NODE)
      return new ParseResult<String>
                  (x.getNodeValue(),xs.subList(1,xs.size()));
System.out.println("expected pcdata but got: "+x);
    return new Fail<String>(xs);
  }
}

Empty

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import org.w3c.dom.Node;

public class Return<a> extends AbstractParser<a> {
  final a returnValue;
  public Return(a r){returnValue=r;}
  public ParseResult<a> parse(List<Node> xs){
    return new ParseResult<a>(returnValue,xs);
  }
}

Element

• the name of the element to be read.
• the parser to be applied to the children of the element.

package name.panitz.crempel.util.xml.parslib;

import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import name.panitz.crempel.util.Closure;


public class Element<a> extends AbstractParser<a> {
  Parser<a> p=null;
  private final Closure<Parser<a>> pc;
  final String elementName;

  public Element(String n,Parser<a> _p){elementName=n;p=_p;pc=null;}
  public Element(String n,Closure<Parser<a>> _p){elementName=n;pc=_p;}

  public Parser<a> getP(){if (p==null) p=pc.eval(); return p;}

  public ParseResult<a> parse(List<Node> xs){
    if (xs.isEmpty()) {return new Fail<a>(xs);}
    Node x = xs.get(0);
    while (   x.getNodeType()==Node.TEXT_NODE
           && x.getNodeValue().trim().length()==0
          ){
      xs=xs.subList(1,xs.size());
      if (xs.isEmpty()) return new Fail<a>(xs);  

      x = xs.get(0);
    }

    final String name = x.getNodeName();
System.out.println(name+" <-> "+elementName);
    if (!name.equals(elementName)) 
      return new Fail<a>(xs);

    final List<Node> ys = nodelistToList(x.getChildNodes());
    ParseResult<a> res = getP().parse(ys);

    if( res.failed()) return new Fail<a>(xs); 

    for (Node y :res.e2){
      if (y.getNodeType()!=Node.TEXT_NODE 
             || y.getNodeValue().trim().length()!=0)
         return new Fail<a>(xs);
    }

    return new ParseResult<a>(res.e1,xs.subList(1,xs.size()));    
  }

  static public List<Node> nodelistToList(NodeList xs){
    List<Node> result = new ArrayList<Node>();
    for (int i=0;i<xs.getLength();i=i+1){
      result.add(xs.item(i));
    }
    return result;
  }
}

4.2.4  Building parsers

Defining a Parser

package name.panitz.crempel.test;

import java.util.List;
import org.w3c.dom.Node;
import name.panitz.crempel.util.*;
import name.panitz.crempel.util.xml.parslib.*;

public class MusiccollectionParser extends AbstractParser<String>{

  final private UnaryFunction<Tuple2<String,String>,String> concat
    = new UnaryFunction<Tuple2<String,String>,String>(){
         public String eval(Tuple2<String,String> p){
           return p.e1+p.e2;
         }
      };

  final private UnaryFunction<Maybe<String>,String> getString
    = new UnaryFunction<Maybe<String>,String>(){
         public String eval(Maybe<String> p){
           if (p instanceof Nothing) return "";  
           return ((Just<String>)p).getJust();
         }
      };

  final private UnaryFunction<List<String>,String> concatList
    = new UnaryFunction<List<String>,String>(){
         public String eval(List<String> xs){
           final StringBuffer result = new StringBuffer();
           for (String x:xs) result.append(x);
           return result.toString();
         }
      };

  final private Parser<String> recordingyear
    = new Element<String>("recordingyear",new PCData());
  final private Parser<String> artist
    = new Element<String>("artist",new PCData());
  final private Parser<String> title
    = new Element<String>("title",new PCData());
  final private Parser<String> timing
    = new Element<String>("timing",new PCData());
  final private Parser<String> author
    = new Element<String>("author",new PCData());

  final private Parser<String> note
    = new Element<String>
       ("note",author.seq(new PCData()).map(concat));

  final private Parser<String> track
    = new Element<String>("track"
        ,title.seq(timing.query().map(getString)).map(concat));
                    
  final private Parser<String> content
    =    title
        .seq(artist).map(concat)
        .seq(recordingyear.query().map(getString)).map(concat)
        .seq(track.plus().map(concatList)).map(concat)
        .seq(note.star().map(concatList)).map(concat);

  final private Parser<String> lp
    = new Element<String>("lp",content);
  final private Parser<String> cd
    = new Element<String>("cd",content);
  final private Parser<String> mc
    = new Element<String>("mc",content);

  final private Parser<String> musiccollection
   = new Element<String>
      ("musiccollection",lp.choice(cd).choice(mc)
                           .star().map(concatList));

  public ParseResult<String> parse(List<Node> xs){
    return musiccollection.parse(xs);
  }
}

Starting the parser

package name.panitz.crempel.test;

import name.panitz.crempel.util.*;
import name.panitz.crempel.util.xml.parslib.*;

import org.w3c.dom.*;
import java.util.*;
import java.io.*;
import javax.xml.parsers.*;

public class MainParser{
  public static void main(String [] args){
    System.out.println(pFile(args[0],args[1]));
  }

  public static Object pFile(String parserClass,String fileName){
    try{
      DocumentBuilderFactory factory
        = DocumentBuilderFactory.newInstance();

      factory.setIgnoringElementContentWhitespace(true);
      factory.setCoalescing(true); 
      factory.setIgnoringComments(true);

      Document doc
	=factory.newDocumentBuilder()
	.parse(new File(fileName)) ;
      doc.normalize();
      List<Node> xs = new ArrayList<Node>();
      xs.add(doc.getChildNodes().item(0));
 
      Parser<Object> p
       = (Parser<Object>)Class.forName(parserClass).newInstance();
      
      Tuple2 res = p.parse(xs);

      return res.e1;
    }catch (Exception e){e.printStackTrace();return null;}
  }
}

sep@linux:~/fh/xmlparslib/examples> java -classpath classes/  name.panitz.crempel.test.MainParser 
  name.panitz.crempel.test.MusiccollectionParser src/mymusic.xml
White AlbumThe Beatles1968Revolution 9sepmy first lpOpen All NightMarc AlmondTragedysepMarc sung tainted love
sep@linux:~/fh/xmlparslib/examples>

4.3  Building a Tree Structure

4.3.1  Java types for DTDs

4.3.2  An algebraic type for DTDs

• PCData
• some element name
• Any
• Empty
• one or more repetition
• zero or more repetition
• zero or one repetition
• a list of choices
• a list of sequence items

package name.panitz.crempel.util.xml.dtd.tree;

data class DTDDef {
  DTDPCData();
  DTDTagName(String tagName);
  DTDAny();
  DTDEmpty();
  DTDPlus(DTDDef dtd);
  DTDStar(DTDDef dtd);
  DTDQuery(DTDDef dtd);
  DTDSeq(java.util.List<DTDDef> seqParts);
  DTDChoice(java.util.List<DTDDef> choiceParts);
}

Simple visitors vor DTDDef

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;
import java.util.List;

public class DTDShow extends DTDDefVisitor<String>{
  public String eval(DTDPCData _){return "#PCDATA";};
  public String eval(DTDTagName x){return x.getTagName();}
  public String eval(DTDEmpty x){return "Empty";}
  public String eval(DTDAny x){return "Any";}
  public String eval(DTDPlus x){return show(x.getDtd())+"+";};
  public String eval(DTDStar x){return show(x.getDtd())+"*";};
  public String eval(DTDQuery x){return show(x.getDtd())+"?";};
  public String eval(DTDSeq s){
    return aux(this,",",s.getSeqParts());}
  public String eval(DTDChoice c){
  return aux(this,"|",c.getChoiceParts());}

  private String aux
              (DTDShow visitor,String sep,List<DTDDef> parts){
    StringBuffer result=new StringBuffer("(");
    boolean first = true; for (DTDDef x:parts){
      if (first) first=false; else result.append(sep);
      result.append(show(x));
    }
    result.append(")");
    return result.toString();
  }

  public String show(DTDDef def){return def.visit(this);}
}

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.*;
import java.util.List;
import java.util.ArrayList;

public class ShowType extends DTDDefVisitor<String>{
  public String eval(DTDPCData x){return "String";}
  public String eval(DTDTagName x){return x.getTagName();}
  public String eval(DTDEmpty x){return "Object";}
  public String eval(DTDAny x){return "Object";}
  public String eval(DTDPlus x){return "List<"+x.getDtd().visit(this)+">";}
  public String eval(DTDStar x){return "List<"+x.getDtd().visit(this)+">";}
  public String eval(DTDQuery x){return "Maybe<"+x.getDtd().visit(this)+">";}
  public String eval(DTDSeq x){
    return listAsType((List<DTDDef>) x.getSeqParts());}
  public String eval(DTDChoice x){
    List<DTDDef> parts = x.getChoiceParts();
    if (parts.size()==1) return parts.get(0).visit(this);
    StringBuffer result=new StringBuffer("Choice");
    for (DTDDef y:((List<DTDDef>) parts))
      result.append("_"+typeToIdent(y.visit(this)));
    return result.toString();
  }

  private  String listAsType(List<DTDDef> xs){
    int size=xs.size();

    if (size==1) return xs.get(0).visit(this);
    StringBuffer result = new StringBuffer();
    for (Integer i:new FromTo(2,size)){
      result.append("Tuple2<");
    }
    boolean first=true;
    for (DTDDef dtd:xs){
      if (!first) result.append(",");
      result.append(dtd.visit(this));
      if (!first) result.append(">");
      first=false; 
    }
    return result.toString();       
  }

  public static String showType(DTDDef def){
   return def.visit(new ShowType());}

  static public String typeToIdent(String s ){
    return s.replace('<','_').replace('>','_').replace('.','_');
  }
}

4.3.3  Generation of tree classes

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.adt.parser.ADT;
import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.*;
import name.panitz.crempel.util.adt.*;
import java.util.List;
import java.util.ArrayList;
import java.io.Writer;
import java.io.StringReader;
import java.io.FileWriter;
import java.io.StringWriter;
import java.io.IOException;

public class GenerateADT extends DTDDefVisitor<String>{

  final String elementName;
  public GenerateADT(String e){elementName=e;}

  public String eval(DTDPCData x){return "Con(String pcdata);";}
  public String eval(DTDTagName x){
    final String typeName = ShowType.showType(x);
    return "Con("+typeName+" the"+typeName+");";}
  public String eval(DTDEmpty x){return "";}
  public String eval(DTDAny x){return "";}
  public String eval(DTDPlus x){
    return "Con(List<"+ShowType.showType(x.getDtd())+"> xs);";}
  public String eval(DTDStar x){
    return "Con(List<"+ShowType.showType(x.getDtd())+"> xs);";}
  public String eval(DTDQuery x){
    return "Con(Maybe<"+ShowType.showType(x.getDtd())+"> xs);";}
  public String eval(DTDSeq x){
    StringBuffer result = new StringBuffer("Con(");
    boolean first = true;
    for (DTDDef dtd :x.getSeqParts()){
      if (!first) result.append(","); 
      final String typeName = ShowType.showType(dtd);
      result.append(typeName+" the"+ShowType.typeToIdent(typeName));

      first=false;
    }
    result.append(");");
    return result.toString();
  }
  public String eval(DTDChoice x){
    StringBuffer result = new StringBuffer();
    for (DTDDef dtd :x.getChoiceParts()){
      String typeName = ShowType.showType(dtd);
      final String varName = ShowType.typeToIdent(typeName);

      result.append("\n  C"+elementName+varName
                             +"("+typeName+" the"+varName+");");
    }
    return result.toString();
  }

  public static String generateADT(String element,DTDDef def){
   return def.visit(new GenerateADT(element));}

  public static void generateTreeClasses
                           (List<Tuple3<Boolean,String,DTDDef>> xs){
    try {
      for (Tuple3<Boolean,String,DTDDef>x:xs){
        Writer out = new FileWriter(x.e2+".adt");
        out.write("import java.util.List;\n");
        out.write("import name.panitz.crempel.util.Maybe;\n");
        out.write("data class "+x.e2+"{\n");
        out.write(generateADT(x.e2,x.e3));
        out.write("}");
        out.close();
      }
    }catch (IOException e){e.printStackTrace();}
  }

  public static void  generateADT
     (String paket,String path,List<Tuple3<Boolean,String,DTDDef>> xs){
    try {
      List<AbstractDataType> adts = new ArrayList<AbstractDataType>(); 
      for (Tuple3<Boolean,String,DTDDef>x:xs){
        StringWriter out = new StringWriter();//FileWriter(x.e2+".adt");
        out.write("package "+paket+";\n");
        out.write("import java.util.List;\n");
        out.write("import name.panitz.crempel.util.Maybe;\n");
        out.write("data class "+x.e2+"{\n");
        out.write(generateADT(x.e2,x.e3));
        out.write("}");
        out.close();
 
        System.out.println(out);        
        ADT parser = new ADT(new StringReader(out.toString()));
        AbstractDataType adt = parser.adt();
        adts.add(adt);
        adt.generateClasses(path);
       }
      }catch (Exception e){e.printStackTrace();}
  }

}

4.3.4  Generation of parser code

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.*;
import name.panitz.crempel.util.adt.*;
import java.util.List;
import java.util.ArrayList;
import java.io.Writer;
import java.io.StringWriter;
import java.io.IOException;

public class ParserCode extends DTDDefVisitor<String>{
  final String elementName;
  public ParserCode(String e){elementName=e;}

  public String eval(DTDPCData x){return "new PCData()";}
  public String eval(DTDTagName x){return "getV"+x.getTagName()+"()";}
  public String eval(DTDEmpty x){return "new Return(null)";}
  public String eval(DTDAny x){return null;}
  public String eval(DTDPlus x){return x.getDtd().visit(this)+".plus()";}
  public String eval(DTDStar x){return x.getDtd().visit(this)+".star()";}
  public String eval(DTDQuery x){return x.getDtd().visit(this)+".query()";}
  public String eval(DTDSeq x){
    StringBuffer result = new StringBuffer();
    boolean first = true;
    for (DTDDef dtd:(List<DTDDef>) x.getSeqParts()){
      if (!first){result.append(".seq(");}
      result.append(dtd.visit(this));
      if (!first){result.append(")");}
      first=false;
    }
    return result.toString();
  }

  public String eval(DTDChoice x){
    final List<DTDDef> xs =  x.getChoiceParts();
    if (xs.size()==1) {
      final DTDDef ch = xs.get(0);
      final String s  = ch.visit(this);
      return s;
    }
    StringBuffer result = new StringBuffer();
    boolean first = true;
    for (DTDDef dtd:(List<DTDDef>) xs){
      final String argType = ShowType.showType(dtd);
      final String resType = elementName;
      if (!first){result.append(".choice(");}
      result.append(dtd.visit(this));
      result.append(".<"+resType+">map(new UnaryFunction<");
      result.append(argType);
      result.append(",");
      result.append(resType);
      result.append(">(){");
      result.append("\n    public "+resType+" eval("+argType+" x){");
   
      String typeName = ShowType.showType(dtd);
      final String varName = ShowType.typeToIdent(typeName);
      result.append("\n      return ("+resType+")new C"
             +elementName+varName
             +"(x);");
      result.append("\n    }");
      result.append("\n  })");
      if (!first){result.append(")");}
      first=false;
    }
    return result.toString();
  }

  public static String parserCode(DTDDef def,String n){
   return def.visit(new ParserCode(n));}
}

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.*;
import name.panitz.crempel.util.adt.*;
import java.util.List;
import java.util.ArrayList;
import java.io.Writer;
import java.io.StringWriter;
import java.io.IOException;

public class WriteParser extends DTDDefVisitor<String>{
  final String elementName;
  final boolean isGenerated  ;
  String contentType = null;
  String typeDef = null;
  String fieldName = null;
  String getterName = null;

  public WriteParser(String e,boolean g){elementName=e;isGenerated=g;}

  private void start(DTDDef def,StringBuffer result){
    contentType = ShowType.showType(def);
    typeDef = !isGenerated?elementName:contentType;
    fieldName = "v"+elementName;  
    getterName = "getV"+elementName+"()";  

    result.append("\n\n  private Parser<"+typeDef+"> "+fieldName+" = null;"); 
    result.append("\n  public Parser<"+typeDef+"> "+getterName+"{"); 
    result.append("\n    if ("+fieldName+"==null){"); 
    result.append("\n      "+fieldName+" = ");
    if (!isGenerated) {
      result.append("new Element<"+typeDef+">(\""+typeDef+"\"");
      result.append("\n     ,");
      result.append("new Closure<Parser<"+typeDef+">>(){public Parser<"+typeDef+"> eval(){return ");      
    }

  }

  private String f(DTDDef def){
    StringBuffer result=new StringBuffer();
    start(def,result);
    result.append(ParserCode.parserCode(def,elementName));
    if (!isGenerated){
      result.append("\n     .<"+typeDef+">map(new UnaryFunction");
      result.append("<"+contentType+","+typeDef+">(){");
      result.append("\n       public "+typeDef+" eval("+contentType+" x){");
      result.append("\n         return new "+typeDef+"(x);");
      result.append("\n       }");
      result.append("\n     })");
    } 
    end(def,result);
    return result.toString();
  }

  private void end(DTDDef def,StringBuffer result){
    if (!isGenerated){
      result.append("\n;}}//end of closure\n"); 
      result.append(")");     

    }
    result.append(";"); 
    result.append("\n    }"); 
    result.append("\n    return "+fieldName+";"); 
    result.append("\n  }");
  }

  private String startend(DTDDef def){
    StringBuffer result=new StringBuffer();
    start(def,result);
    result.append(ParserCode.parserCode(def,elementName));
    end(def,result);
    return result.toString();
  }

  public String eval(DTDPCData x){return f(x);}
  public String eval(DTDTagName x){return f(x);}
  public String eval(DTDEmpty x){return f(x);}
  public String eval(DTDAny x){return null;}
  public String eval(DTDPlus x){return f(x);}
  public String eval(DTDStar x){return f(x);}
  public String eval(DTDQuery x){return f(x);}
  public String eval(DTDChoice x){return startend(x);}
  public String eval(DTDSeq x){
    StringBuffer result = new StringBuffer();
    start(x,result);
    result.append(ParserCode.parserCode(x,elementName));
    result.append(".map(new UnaryFunction<"
                 +ShowType.showType(x)+","+elementName+">(){");
    result.append("\n    public "+elementName);
    result.append(" eval("+ShowType.showType(x) +" p){");
    result.append("\n      return new "+elementName);
    unrollPairs(x.getSeqParts().size(),"p",result);
    result.append(";");
    result.append("\n    }");
    result.append("\n  }");
    result.append(")");
    end(x,result);
    return result.toString();
  }

  private void unrollPairs(int i,String var,StringBuffer r){
    String c = var;
    String result="";
    for (Integer j :new FromTo(2,i)){
       result=","+c+".e2"+result;
       c= c+".e1";
    }
    result=c+result;
    r.append("(");
    r.append(result);
    r.append(")");
  }

  public static String writeParser
                      (DTDDef def,String n,boolean isGenerated){
   return def.visit(new WriteParser(n,isGenerated));}
}

4.3.5  Flattening of a DTD definition

package name.panitz.crempel.util.xml.dtd;
import name.panitz.crempel.util.xml.dtd.tree.DTDDef;
import name.panitz.crempel.util.Tuple3;
import name.panitz.crempel.util.Tuple2;
import java.util.List;
import java.util.ArrayList;


public class FlattenResult
   extends Tuple2<DTDDef,List<Tuple3<Boolean,String,DTDDef>>>{

  public FlattenResult(DTDDef dtd,List<Tuple3<Boolean,String,DTDDef>> es){
    super(dtd,es);
  }

  public FlattenResult(DTDDef dtd){
    super(dtd,new ArrayList<Tuple3<Boolean,String,DTDDef>>() );
  }
}

package name.panitz.crempel.util.xml.dtd;
import name.panitz.crempel.util.xml.dtd.IsAtomic.*;
import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.Tuple3;
import name.panitz.crempel.util.Tuple2;
import name.panitz.crempel.util.UnaryFunction;
import java.util.List;
import java.util.ArrayList;
import java.util.TreeSet;
import java.util.Comparator;

public class DTDDefFlatten extends DTDDefVisitor<FlattenResult>{
  final String elementName;
  final boolean isGenerated;
  private int counter = 0;
  private String getNextName(){
    counter=counter+1;
    return elementName+"_"+counter;
  }

  public DTDDefFlatten(boolean g,String n){elementName=n;isGenerated=g;}

  public FlattenResult eval(DTDPCData x){
    return single((DTDDef)x);}
  public FlattenResult eval(DTDTagName x){
    return single((DTDDef)x);}
  public FlattenResult eval(DTDEmpty x){
    return single((DTDDef)x);}
  public FlattenResult eval(DTDAny x){
    return single((DTDDef)x);}
  public FlattenResult eval(DTDPlus x){
    if (IsAtomic.isAtomic(x.getDtd())) return single((DTDDef)x);
    return flattenModified(elementName,x.getDtd()
          ,new UnaryFunction<DTDDef,DTDDef>(){
             public DTDDef eval(DTDDef dtd){return new DTDPlus(dtd);}
           });
  }
  public FlattenResult eval(DTDStar x){
    if (IsAtomic.isAtomic(x.getDtd())) return single((DTDDef)x);
    return 
     flattenModified(elementName,x.getDtd()
          ,new UnaryFunction<DTDDef,DTDDef>(){
             public DTDDef eval(DTDDef dtd){return new DTDStar(dtd);}
           });
  }
  public FlattenResult eval(DTDQuery x){
    if (IsAtomic.isAtomic(x.getDtd())) return single((DTDDef)x);
    return flattenModified(elementName,x.getDtd()
          ,new UnaryFunction<DTDDef,DTDDef>(){
             public DTDDef eval(DTDDef dtd){return new DTDQuery(dtd);}
           });
  }
  public FlattenResult eval(DTDSeq x){
    return flattenPartList(x.getSeqParts()
          ,new UnaryFunction<List<DTDDef>,DTDDef>(){
             public DTDDef eval(List<DTDDef> dtds){
               return new DTDSeq(dtds);}
           });
  }
  public FlattenResult eval(DTDChoice x){
    return flattenPartList(x.getChoiceParts()
          ,new UnaryFunction<List<DTDDef>,DTDDef>(){
             public DTDDef eval(List<DTDDef> dtds){
System.out.println("the new choice"+dtds);
               return new DTDChoice(dtds);}
           });
   }

  private FlattenResult  single(DTDDef x){return new FlattenResult(x);}

  private FlattenResult flattenModified
          (final String orgElem,DTDDef content
          ,UnaryFunction<DTDDef,DTDDef> constr){
    List<Tuple3<Boolean,String,DTDDef>> result 
     = new ArrayList<Tuple3<Boolean,String,DTDDef>>();
    if (needsNewElement(content)){
    System.out.println("owo needs new element: "+content );
      final String newElemName
        = ShowType.typeToIdent(ShowType.showType(content));

      result.add(new Tuple3<Boolean,String,DTDDef>
         (true,newElemName,content));
      return new FlattenResult
                (constr.eval(new DTDTagName(newElemName)),result);
    } 
    System.out.println("does not need new element");
    FlattenResult innerRes  = content.visit(this);
    System.out.println(innerRes);
    return new FlattenResult(constr.eval(innerRes.e1),innerRes.e2);
  }

  private FlattenResult flattenPartList
      (List<DTDDef> parts,UnaryFunction<List<DTDDef>,DTDDef> constr){
    final List<Tuple3<Boolean,String,DTDDef>> result 
      = new ArrayList<Tuple3<Boolean,String,DTDDef>>();
    if (parts.size()==1) {return single(parts.get(0));}

    List<DTDDef> newParts = new ArrayList<DTDDef>();    
    for (DTDDef part:parts){
      if (IsAtomic.isAtomic(part)) {System.out.println("atomic part:"+part);newParts.add(part);}
      else if (needsNewElement(part)){
        final String newElemName
          = ShowType.typeToIdent(ShowType.showType(part));
        result.add(new Tuple3<Boolean,String,DTDDef>
             (true,newElemName,part));
        newParts.add(new DTDTagName(newElemName));
      }else{
        FlattenResult innerRes  = part.visit(this);
        newParts.add(innerRes.e1);
        result.addAll(innerRes.e2);
      }
    } 
    return new FlattenResult(constr.eval(newParts),result);

  }

  static private boolean needsNewElement(DTDDef d){
    return 
     (d instanceof DTDSeq && ((DTDSeq)d).getSeqParts().size()>1)
            ||
     (d instanceof DTDChoice &&((DTDChoice)d).getChoiceParts().size()>1);
  }

  static public List<Tuple3<Boolean,String,DTDDef>> 
       flattenDefList(List<Tuple3<Boolean,String,DTDDef>> defs){
    boolean changed = true;
    List<Tuple3<Boolean,String,DTDDef>> result = defs;
    while (changed){
      Tuple2<Boolean,List<Tuple3<Boolean,String,DTDDef>>> once
        = flattenDefListOnce(result);
      changed=once.e1;
      result=once.e2;
    } 

    TreeSet<Tuple3<Boolean,String,DTDDef>> withoutDups
      = new TreeSet<Tuple3<Boolean,String,DTDDef>>(
         new Comparator<Tuple3<Boolean,String,DTDDef>>(){
           public int compare(Tuple3<Boolean,String,DTDDef> o1
                             ,Tuple3<Boolean,String,DTDDef> o2){
              return o1.e2.compareTo(o2.e2);
           }
         });
    withoutDups.addAll(result); 

    result = new ArrayList<Tuple3<Boolean,String,DTDDef>> ();
    result.addAll(withoutDups);
    return result;
  }

  private static Tuple2<Boolean,List<Tuple3<Boolean,String,DTDDef>>> 
       flattenDefListOnce(List<Tuple3<Boolean,String,DTDDef>> defs){

    final List<Tuple3<Boolean,String,DTDDef>> result
     = new ArrayList<Tuple3<Boolean,String,DTDDef>>();

    boolean changed = false;

    for (Tuple3<Boolean,String,DTDDef> def:defs){
      final FlattenResult singleResult
        = def.e3.visit(new DTDDefFlatten(def.e1,def.e2));
      changed=changed||singleResult.e2.size()>0;
      result.addAll(singleResult.e2);
      result.add(
       new Tuple3<Boolean,String,DTDDef>(
         singleResult.e2.isEmpty()&&def.e1,def.e2,singleResult.e1));
    }
    return new Tuple2<Boolean,List<Tuple3<Boolean,String,DTDDef>>>
                  (changed,result); 
  }

  public static FlattenResult flatten(DTDDef def,String n){
   return def.visit(new DTDDefFlatten(false,n));}
}

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;

public class IsAtomic extends DTDDefVisitor<Boolean>{
  public Boolean eval(DTDPCData x){return true;}
  public Boolean eval(DTDTagName x){return true;}
  public Boolean eval(DTDEmpty x){return true;}
  public Boolean eval(DTDAny x){return true;}
  public Boolean eval(DTDPlus x){return x.getDtd().visit(this);}
  public Boolean eval(DTDStar x){return x.getDtd().visit(this);}
  public Boolean eval(DTDQuery x){return x.getDtd().visit(this);}
  public Boolean eval(DTDSeq x){return false;}
  public Boolean eval(DTDChoice x){return false;}

  public static Boolean isAtomic(DTDDef def ){
   return def.visit(new IsAtomic());}
}

4.3.6  Main generation class

package name.panitz.crempel.util.xml.dtd;

import name.panitz.crempel.util.xml.dtd.tree.*;
import java.util.List;
import java.util.ArrayList;
import java.io.*;
import name.panitz.crempel.util.*;

public class GenerateClassesForDTD{
  public static void generateAll
     (String paket,String path,String n,List<Tuple2<String,DTDDef>>dtds){
    List<Tuple3<Boolean,String,DTDDef>> xs
      = new ArrayList<Tuple3<Boolean,String,DTDDef>>();
    for (Tuple2<String,DTDDef> t:dtds)
      xs.add(new Tuple3<Boolean,String,DTDDef>(false,t.e1,t.e2));


    xs = DTDDefFlatten.flattenDefList(xs);

    System.out.println("vereinfacht und flachgemacht");
    for (Tuple3<Boolean,String,DTDDef> t:xs){
      System.out.println(t.e2);
      System.out.println(t.e3);
      System.out.println("");
    }
    

    final String parserType = dtds.get(0).e1;
    try{
      Writer out = new FileWriter(path+"/"+n+"Parser"+".java");
      out.write("package "+paket+";\n");

      out.write("import name.panitz.crempel.util.xml.parslib.*;\n");
      out.write("import name.panitz.crempel.util.*;\n");
      out.write("import java.util.*;\n");
      out.write("import org.w3c.dom.Node;\n\n");

      out.write("public class "+n+"Parser ");
      out.write("extends AbstractParser<"+parserType+">{\n");

      out.write("public ParseResult<"+parserType+"> ");
      out.write("parse(List<Node> xs){");
      out.write("  return getV"+parserType+"().parse(xs);}\n\n");

      for (Tuple3<Boolean,String,DTDDef> x :xs)
        out.write(WriteParser.writeParser(x.e3,x.e2,x.e1));

      out.write("}");  
      out.close();  
    }catch (IOException e){e.printStackTrace();}
    GenerateADT.generateADT(paket,path,xs);
  }
}

4.3.7  Main generator class

package name.panitz.crempel.util.xml.dtd.parser;

import java.io.*;
import java.util.*;
import name.panitz.crempel.util.*;
import name.panitz.crempel.util.xml.dtd.tree.*;
import name.panitz.crempel.util.xml.dtd.*;

public class MainDTDParse {
  public static void main(String [] args){
    try{
      final String dtdFileName = args[0];
      final String packageName = args[1].replace('/','.');

      File f = new File(dtdFileName);  
      final String path
          = f.getParentFile()==null?".":f.getParentFile().getPath();

      final DTD parser = new DTD(new FileReader(f));


      final Tuple3<List<Tuple2<String,DTDDef>>,Object,String> dtd
          = parser.dtd();

      for (Tuple2<String,DTDDef> t:dtd.e1){
        System.out.println(t.e1);
        System.out.println(t.e2);
        System.out.println("");
      }
 
      GenerateClassesForDTD
          .generateAll(packageName,path,dtd.e3,dtd.e1);
   }catch (Exception _){_.printStackTrace();System.out.println(_);} 
  }
}

sep@linux:~/fh/xmlparslib/examples/src/name/panitz/album> java -c
lasspath /home/sep/fh/xmlparslib/examples/classes/:/home/sep/fh/java1.5/exa
mples/classes/:/home/sep/fh/adt/examples/classes/ name.panitz.crempel.util.
xml.dtd.parser.MainDTDParse album.dtd name.panitz.album
package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class Choice_String_author{

  CChoice_String_authorString(String theString);
  CChoice_String_authorauthor(author theauthor);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class Choice_lp_cd_mc{

  CChoice_lp_cd_mclp(lp thelp);
  CChoice_lp_cd_mccd(cd thecd);
  CChoice_lp_cd_mcmc(mc themc);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class artist{
Con(String pcdata);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class author{
Con(String pcdata);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class cd{
Con(title thetitle,artist theartist,Maybe<recordingyear> 
 theMaybe_recordingyear_,List<track> theList_track_,List<note> theList_note_);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class lp{
Con(title thetitle,artist theartist,Maybe<recordingyear> 
 theMaybe_recordingyear_,List<track> theList_track_,List<note> theList_note_);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class mc{
Con(title thetitle,artist theartist,Maybe<recordingyear> 
 theMaybe_recordingyear_,List<track> theList_track_,List<note> theList_note_);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class musiccollection{
Con(List<Choice_lp_cd_mc> xs);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class note{
Con(List<Choice_String_author> xs);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class recordingyear{
Con(String pcdata);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class timing{
Con(String pcdata);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class title{
Con(String pcdata);}

package name.panitz.album;
import java.util.List;
import name.panitz.crempel.util.Maybe;
data class track{
Con(title thetitle,Maybe<timing> theMaybe_timing_);}

sep@linux:~/fh/xmlparslib/examples/src/name/panitz/album> ls
CChoice_String_authorString.java    lpVisitor.java
CChoice_String_authorauthor.java    mc.java
CChoice_lp_cd_mccd.java             mcVisitable.java
CChoice_lp_cd_mclp.java             mcVisitor.java
CChoice_lp_cd_mcmc.java             musiccollection.java
Choice_String_author.java           musiccollectionParser.java
Choice_String_authorVisitable.java  musiccollectionVisitable.java
Choice_String_authorVisitor.java    musiccollectionVisitor.java
Choice_lp_cd_mc.java                note.java
Choice_lp_cd_mcVisitable.java       noteVisitable.java
Choice_lp_cd_mcVisitor.java         noteVisitor.java
album.dtd                           recordingyear.java
artist.java                         recordingyearVisitable.java
artistVisitable.java                recordingyearVisitor.java
artistVisitor.java                  timing.java
author.java                         timingVisitable.java
authorVisitable.java                timingVisitor.java
authorVisitor.java                  title.java
cd.java                             titleVisitable.java
cdVisitable.java                    titleVisitor.java
cdVisitor.java                      track.java
lp.java                             trackVisitable.java
lpVisitable.java                    trackVisitor.java
sep@linux:~/fh/xmlparslib/examples/src/name/panitz/album>

4.3.8  JaxB

sep@linux:~/fh/xmlparslib/> ~/jwsdp-1.3/jaxb/bin/xjc.sh -dtd
  album.dtd -p name.panitz.jaxb.album
parsing a schema...
compiling a schema...
name/panitz/jaxb/album/impl/runtime/GrammarInfo.java
name/panitz/jaxb/album/impl/runtime/AbstractUnmarshallingEventHandlerImpl.java
name/panitz/jaxb/album/impl/runtime/PrefixCallback.java
name/panitz/jaxb/album/impl/runtime/Discarder.java
name/panitz/jaxb/album/impl/runtime/ValidatableObject.java
name/panitz/jaxb/album/impl/runtime/SAXUnmarshallerHandlerImpl.java
name/panitz/jaxb/album/impl/runtime/ContentHandlerAdaptor.java
name/panitz/jaxb/album/impl/runtime/ValidatorImpl.java
name/panitz/jaxb/album/impl/runtime/UnmarshallerImpl.java
name/panitz/jaxb/album/impl/runtime/GrammarInfoFacade.java
name/panitz/jaxb/album/impl/runtime/XMLSerializable.java
name/panitz/jaxb/album/impl/runtime/UnmarshallingEventHandler.java
name/panitz/jaxb/album/impl/runtime/DefaultJAXBContextImpl.java
name/panitz/jaxb/album/impl/runtime/SAXMarshaller.java
name/panitz/jaxb/album/impl/runtime/GrammarInfoImpl.java
name/panitz/jaxb/album/impl/runtime/MSVValidator.java
name/panitz/jaxb/album/impl/runtime/UnmarshallableObject.java
name/panitz/jaxb/album/impl/runtime/SAXUnmarshallerHandler.java
name/panitz/jaxb/album/impl/runtime/ErrorHandlerAdaptor.java
name/panitz/jaxb/album/impl/runtime/NamespaceContext2.java
name/panitz/jaxb/album/impl/runtime/Util.java
name/panitz/jaxb/album/impl/runtime/UnmarshallingEventHandlerAdaptor.java
name/panitz/jaxb/album/impl/runtime/ValidationContext.java
name/panitz/jaxb/album/impl/runtime/ValidatingUnmarshaller.java
name/panitz/jaxb/album/impl/runtime/MarshallerImpl.java
name/panitz/jaxb/album/impl/runtime/XMLSerializer.java
name/panitz/jaxb/album/impl/runtime/UnmarshallingContext.java
name/panitz/jaxb/album/impl/runtime/NamespaceContextImpl.java
name/panitz/jaxb/album/impl/ArtistImpl.java
name/panitz/jaxb/album/impl/AuthorImpl.java
name/panitz/jaxb/album/impl/CdImpl.java
name/panitz/jaxb/album/impl/JAXBVersion.java
name/panitz/jaxb/album/impl/LpImpl.java
name/panitz/jaxb/album/impl/McImpl.java
name/panitz/jaxb/album/impl/MusiccollectionImpl.java
name/panitz/jaxb/album/impl/NoteImpl.java
name/panitz/jaxb/album/impl/RecordingyearImpl.java
name/panitz/jaxb/album/impl/TimingImpl.java
name/panitz/jaxb/album/impl/TitleImpl.java
name/panitz/jaxb/album/impl/TrackImpl.java
name/panitz/jaxb/album/Artist.java
name/panitz/jaxb/album/Author.java
name/panitz/jaxb/album/Cd.java
name/panitz/jaxb/album/Lp.java
name/panitz/jaxb/album/Mc.java
name/panitz/jaxb/album/Musiccollection.java
name/panitz/jaxb/album/Note.java
name/panitz/jaxb/album/ObjectFactory.java
name/panitz/jaxb/album/Recordingyear.java
name/panitz/jaxb/album/Timing.java
name/panitz/jaxb/album/Title.java
name/panitz/jaxb/album/Track.java
name/panitz/jaxb/album/jaxb.properties
name/panitz/jaxb/album/bgm.ser
sep@linux:~/fh/xmlparslib/examples/src/name/panitz/album>

4.4  Conclusion

4.5  Javacc input file for DTD parser

options {STATIC=false;}

PARSER_BEGIN(DTD)
package name.panitz.crempel.util.xml.dtd.parser;

import name.panitz.crempel.util.*;
import name.panitz.crempel.util.xml.dtd.tree.*;
import java.util.List;
import java.util.ArrayList;
import java.io.FileReader;

public class DTD {}
PARSER_END(DTD)

TOKEN :
{<ELEMENTDEC: "<!ELEMENT">
|<DOCTYPE:    "<!DOCTYPE"> 
|<ATTLIST:    "<!ATTLIST"> 
|<REQUIRED:   "#REQUIRED"> 
|<IMPLIED:    "#IMPLIED"> 
|<EMPTY: "EMPTY">
|<PCDATA: "#PCDATA">
|<CDATA: "CDATA">
|<ANY: "ANY">
|<SYSTEM: "SYSTEM">
|<PUBLIC: "PUBLIC">
|<GR: ">">
|<QMARK: "?">
|<PLUS: "+">
|<STAR: "*">
|<#NameStartCar: [":","A"-"Z","_","a"-"z"
                 ,"\u00C0"-"\u00D6"
                 ,"\u00D8"-"\u00F6"
                 ,"\u00F8"-"\u02FF"
                 ,"\u0370"-"\u037D"
                 ,"\u037F"-"\u1FFF"
                 ,"\u200C"-"\u200D"
                 ,"\u2070"-"\u218F"
                 ,"\u2C00"-"\u2FEF"
                 ,"\u3001"-"\uD7FF"
                 ,"\uF900"-"\uFDCF"
                 ,"\uFDF0"-"\uFFFD"]>
//                 ,"\u10000"-"\uEFFFF"]>
|<#InnerNameChar: ["-", ".","0"-"9", "\u00B7" 
                  ,"\u0300"-"\u036F"
                  ,"\u203F"-"\u2040"]>
|<#NameChar: <InnerNameChar>|<NameStartCar>>
|<Name: <NameStartCar> (<NameChar>)* >

|<#ALPHA:       ["a"-"z","A"-"Z","_","."]>
|<#NUM:	        ["0"-"9"]>
|<#ALPHANUM:    <ALPHA> | <NUM>>
|<EQ: "=">
|<BAR: "|">
|<LPAR: "(">
|<RPAR: ")">
|<LBRACKET: "{">
|<RBRACKET: "}">
|<LSQBRACKET: "[">
|<RSQBRACKET: "]">
|<LE: "<">
|<SEMICOLON: ";">
|<COMMA: ",">
|<QUOTE: "\"">
|<SINGLEQUOTE: "'">
}

SKIP :
{< ["\u0020","\t","\r","\n"] >}



void externalID():
{}
{<SYSTEM> systemLiteral()
 |<PUBLIC> systemLiteral() systemLiteral()
}

void systemLiteral():{}
{<QUOTE><Name><QUOTE>|<SINGLEQUOTE><Name><SINGLEQUOTE>
}

Tuple3 dtd():
{ 
  Token nameToken;
  List els = new ArrayList();
  List atts = new ArrayList();
  Tuple2 el;
}
{<DOCTYPE> nameToken=<Name> externalID() <LSQBRACKET>

   (el=elementdecl(){ els.add(el);}
   |AttlistDecl())* 
 <RSQBRACKET><GR>
  {return new Tuple3(els,atts,nameToken.toString());}
}

Tuple2 elementdecl():
{Token nameToken;
 DTDDef content;}
{<ELEMENTDEC> nameToken=<Name>  content=contentspec()  <GR>
  {return new Tuple2(nameToken.toString(),content);}
}


DTDDef contentspec():
{DTDDef result;}
{  <EMPTY>{result=new DTDEmpty();} 
 | <ANY>{result=new DTDAny();}
 | (<LPAR>(result=Mixed()
          |result=children()))
 { return result;}
}

DTDDef children():
{ List cps;
  DTDDef cp;
  Modifier mod = Modifier.none;
  boolean wasChoice = true;
}
{cp=cp()
  (cps=choice()| cps=seq(){wasChoice=false;})
   {cps.add(0,cp);} 
   <RPAR>(<QMARK>{mod=Modifier.query;}
     |<STAR>{mod=Modifier.star;}
     |<PLUS>{mod=Modifier.plus;})?
  {DTDDef result=wasChoice?ParserAux.createDTDChoice(cps)
                          :ParserAux.createDTDSeq(cps);
   return mod.mkDTDDef(result);
  }
}

List choice():
{ DTDDef cp;
  List result = new ArrayList();}
{(<BAR> cp=cp() {result.add(cp);} )+
  {return result;}
}

DTDDef cp():
{ Token nameToken=null;
  List cps=new ArrayList();
  DTDDef cp;
  Modifier mod=Modifier.none;
  boolean wasChoice = true;
  boolean wasTagName = false;
}
{((nameToken = <Name>{wasTagName=true;})
 |(<LPAR>cp=cp()
         (cps=choice()|cps=seq(){wasChoice=false;})
    {cps.add(0,cp);}
   <RPAR>
  )
 ) 
     (<QMARK>{mod=Modifier.query;}
     |<STAR>{mod=Modifier.star;}
     |<PLUS>{mod=Modifier.plus;})?
{
 DTDDef result;
 if (wasTagName) result=new DTDTagName(nameToken.toString());
 else result=wasChoice?ParserAux.createDTDChoice(cps)
                      :ParserAux.createDTDSeq(cps);
 return mod.mkDTDDef(result);
}
}

List seq():
{  List result = new ArrayList();
   DTDDef cp;
}
{(<COMMA> cp=cp(){result.add(cp);} )*
  {return result;}
}

DTDDef Mixed():
{Token nameToken;
 List xs = new ArrayList();
 Modifier mod=Modifier.none;
}
{  <PCDATA> {xs.add(new DTDPCData());}
  ((<BAR> nameToken=<Name> 
    {xs.add(new DTDTagName(nameToken.toString()));}
   )* <RPAR>(<STAR>{mod=Modifier.star;})?)
{return mod.mkDTDDef(ParserAux.createDTDChoice(xs));}

}

void AttlistDecl():
{Token nameToken;}
{<ATTLIST> nameToken=<Name> (AttDef() )*
{}}

void AttDef():
{Token nameToken;
 boolean isRequired;}
{nameToken=<Name> AttType() isRequired=DefaultDecl()
  {}
}

void AttType():
{}
{ StringType()}//|TokenizedType()|EnumeratedType()}

void StringType():
{}
{<CDATA>}


boolean DefaultDecl():
{ boolean isRequired=false;}

{(<REQUIRED>{isRequired=true;} | <IMPLIED>)
//| (('#FIXED' S)? AttValue)
{return isRequired;}
}

package name.panitz.crempel.util.xml.dtd.parser;

import name.panitz.crempel.util.xml.dtd.tree.*;
import java.util.List;

public class ParserAux{
  static public DTDDef createDTDSeq(List xs){
    return new DTDSeq((List<DTDDef>) xs);
  }
  static public DTDDef createDTDChoice(List xs){
    return new DTDChoice((List<DTDDef>) xs);
  }  
}

package name.panitz.crempel.util.xml.dtd.tree;

public enum Modifier { none, star, plus, query;

  public String toString(){
    switch(this) {
          case star:   return "*";
          case plus:   return "+";
          case query:  return "?";
    }
    return "";
  }

  public DTDDef mkDTDDef(DTDDef dtd){
    switch(this) {
      case star:   return new DTDStar(dtd);
      case plus:   return new DTDPlus(dtd);
      case query:  return new DTDQuery(dtd);
    }
    return dtd;
  }
}

Chapter 5
Javas Trickkisten: Bibliotheken und Mechanismen

5.1  Webapplikationen mit Servlets

5.1.1  Servlet Container

5.1.2  Struktur einer Webapplikation

applikationsname
  |--- src
  |--- docs
  |--- web
        |--- WEB-INF
        |--- images
  |--- build
  |--- dist

5.1.3  Anwendungsdaten

<!DOCTYPE Addresses SYSTEM "AddressenType.dtd" [
  <!ELEMENT Addresses  (Address)+ >
  <!ELEMENT Address  (Fullname,Email) >
  <!ELEMENT Fullname  (#PCDATA) >
  <!ELEMENT Email  (#PCDATA) >
]>

5.1.4  Anwendungslogik

package name.panitz.webexample.address;
import java.io.IOException;
import java.io.Writer;

public interface Adressverwaltung {
  Addresses getAddresses( );
  void save()throws Exception;
  Email lookup(Fullname n);
  void add(Address a) throws Exception;
  void remove(Fullname n) throws Exception;
  void writeAddresses(Writer w) throws IOException;
}

package name.panitz.webexample.address;
import java.io.IOException;
import java.io.Writer;

abstract public class AbstractAdressverwaltung 
                          implements Adressverwaltung {
  synchronized public Email lookup(Fullname n){
    for (Address address:getAddresses().getXs()){
      if (address.getTheFullname().equals(n))
        return address.getTheEmail();
    }
    return null;
  }

  synchronized public void add(Address a) throws Exception{
    getAddresses().getXs().add(a);
    save();
  }

  synchronized public void remove(Fullname n) throws Exception{
    for (Address address:getAddresses().getXs()){
      if (address.getTheFullname().equals(n)){
        getAddresses().getXs().remove(address); 
        save();
        return;
      }
    }
  }

  public void writeAddresses(Writer w) throws IOException{
    final Addresses adrs = getAddresses();
    w.write("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>");
    w.write("\n<Addresses>");

    for (Address address:adrs.getXs()){
      w.write("\n <Address><Fullname>");
      w.write(address.getTheFullname().getPcdata());
      w.write("</Fullname><Email>");
      w.write(address.getTheEmail().getPcdata());
      w.write("</Email></Address>");
    }
    w.write("\n</Addresses>");
  }
}

package name.panitz.webexample.address;
import java.io.*;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import java.util.*;
import javax.xml.parsers.*;

import name.panitz.crempel.util.xml.*;

public class AdressFile extends AbstractAdressverwaltung{
  static Map<File,AdressFile> instances
   = new HashMap<File,AdressFile>();

  File source;
  Addresses addresses = null;

  public static AdressFile getInstance(String source) 
                                        throws Exception{
    File dataFile = new File(source);
    AdressFile instance = instances.get(dataFile);
   
    if (instance == null){ 
      instance = new AdressFile(dataFile);
      instances.put(dataFile,instance);
    }
    return instance;
  }

  private AdressFile(File source) throws Exception{
    this.source=source;

    Document doc =
      DocumentBuilderFactory
       .newInstance()
       .newDocumentBuilder()
       .parse(source);
    final List<Node> ns = new ArrayList<Node>();
    ns.add(doc.getDocumentElement()); 
    addresses = new AddressesParser().parse(ns).e1;
  }

  synchronized public Addresses getAddresses( ){return addresses;}
  synchronized public void save()throws Exception{
    FileWriter write = new FileWriter(source);
    writeAddresses(write);
    write.close();
  }
}

package name.panitz.webexample.address;
import java.lang.reflect.Method;

public class AdressverwaltungFactory{
  static Method method=null;  

  public static Adressverwaltung 
                 getAdressverwaltung(String source)throws Exception{
    if (method==null){
      String className 
        = System.getProperty("adressverwaltung.klasse");
      if (className==null){
        className="name.panitz.webexample.address.AdressFile";
      }
      final Class verwalter=Class.forName(className);
      final Class[]  paramtypes = {String.class};
      method=verwalter.getMethod("getInstance",paramtypes);
    }
    final String[] params = {source};
    return (Adressverwaltung)method.invoke(null,params);
  }
}

5.1.5  Servletkonfiguration

<!DOCTYPE web-app 
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" 
  "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
  <display-name>Adressverwaltung</display-name>
  <description>
    Kleines Adressverwaltungstool.
  </description>

  <servlet>
    <servlet-name>ListServlet</servlet-name>
    <servlet-class>
       name.panitz.webexample.address.ListAddresses
    </servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ListServlet</servlet-name>
    <url-pattern>/list</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>LookupServlet</servlet-name>
    <servlet-class>
       name.panitz.webexample.address.LookupAddress
    </servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LookupServlet</servlet-name>
    <url-pattern>/lookup</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>AddServlet</servlet-name>
    <servlet-class>
       name.panitz.webexample.address.AddAddress
    </servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>AddServlet</servlet-name>
    <url-pattern>/add</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>DeleteServlet</servlet-name>
    <servlet-class>
       name.panitz.webexample.address.DeleteAddress
    </servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>DeleteServlet</servlet-name>
    <url-pattern>/delete</url-pattern>
  </servlet-mapping>

</web-app>

<html>
<head>
<title>Adressenverwaltung</title>
</head>
<body bgcolor="white">

<h1>einfache Adressverwaltung</h1>

<ul>
<li><a href="list">Auflisten der gespeicherten Adressen</a>.</li>
<li><a href="lookup.html">Adresse suchen</a>.</li>
<li><a href="add.html">Adresse hinzufügen</a>.</li>
<li><a href="delete.html">Adresse löschen</a>.</li>
</ul>
</body>
</html>

5.1.6  Servletklassen

void destroy();
ServletConfig getServletConfig(); 
java.lang.String getServletInfo(); 
void init(ServletConfig config); 
void service(ServletRequest req, ServletResponse res);

Generierung von Seiten

• ein HttpServletRequest, in dem Informationen über den Aufruf des Servlets zu finden sind.
• eine HttpServletResponse, die zur Erzeugung der Antwortseite benutzt wird.

package name.panitz.webexample.address;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.*;

import java.io.File;

public final class ListAddresses extends HttpServlet {
  public void doGet(HttpServletRequest request
                    ,HttpServletResponse response)
        throws IOException, ServletException {
    response.setContentType("text/html");
    PrintWriter writer = response.getWriter();

    writer.println("<html>");
    writer.println("<head>");
    writer.println("<title>Gespeicherte Adressen</title>");
    writer.println("</head>");
    writer.println("<body bgcolor=\"white\">");
	
    try{
      Adressverwaltung adv 
         = AdressverwaltungFactory
              .getAdressverwaltung(getServletConfig()
                                   .getServletContext()
                                   .getRealPath(".")
                                   +"/addresses.xml");

      writeAddressesAsHTML(adv.getAddresses(),writer);
    }catch(Exception e){writer.println(e);}
    writer.println("</body>");
    writer.println("</html>");
  }

  public static void writeAddressesAsHTML
                   (Addresses adrs,Writer w) throws IOException{
    w.write("\n<table>");
    w.write("\n<tr><th>Name</th><th>email</th></tr>");
    for (Address address:adrs.getXs()){
      w.write("\n <tr><td>");
      w.write(address.getTheFullname().getPcdata());
      w.write("</td><td>");
      w.write(address.getTheEmail().getPcdata());
      w.write("</td></tr>");
    }
    w.write("\n</table>");
  }
}

Lesen von Parametern

<html><body bgcolor="white">
<h1>Adresssuche</h1>
<form action="lookup" method="POST">
Name:
<input type="text" size="20" name="fullname">
<br>
<input type="submit">
</form>
</body>
</html>

package name.panitz.webexample.address;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.File;

import javax.servlet.ServletException;
import javax.servlet.http.*;
import java.util.*;

public final class LookupAddress extends HttpServlet {
  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
        throws IOException, ServletException {
    response.setContentType("text/html");
    final PrintWriter writer = response.getWriter();

    writer.println("<html>");
    writer.println("<head>");
    writer.println("<title>Gespeicherte Adressen</title>");
    writer.println("</head>");
    writer.println("<body bgcolor=white>");
	
    try{
      final String fullname = request.getParameter("fullname");
      final Adressverwaltung adv 
         = AdressverwaltungFactory
              .getAdressverwaltung(getServletConfig()
                                   .getServletContext()
                                   .getRealPath(".")
                                   +"/addresses.xml");
      final Email email = adv.lookup(new Fullname(fullname));
      if (email!=null){
        writer.println("Die gesuchte Adresse ist:<br />" );
        writer.println(email.getPcdata());
      }else
       writer.print("zum gesuchten Namen ist"); 
       writer.println(" keine Adresse gespeichert.");
    }catch(Exception e){writer.println(e);}
    writer.println("</body>");
    writer.println("</html>");
  }

  public void
   doGet(HttpServletRequest request,HttpServletResponse response)
                        throws IOException, ServletException{
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("GET Request. No Form Data Posted");
  }
}

<html><body bgcolor="white">
<h1>Adresssuche</h1>
<form action="add" method=POST>
Name:
<input type="text" size="20" name="fullname">
<br>
Email:
<input type="text" size="20" name="email">
<br>
<input type="submit">
</form>
</body>
</html>

package name.panitz.webexample.address;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.*;

import java.io.File;
import java.util.*;

public final class AddAddress extends HttpServlet {
  public void 
   doGet(HttpServletRequest request,HttpServletResponse response)
                        throws IOException, ServletException{
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("GET Request. No Form Data Posted");
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
        throws IOException, ServletException {
    response.setContentType("text/html");
    final PrintWriter writer = response.getWriter();

    writer.println("<html>");
    writer.println("<head>");
    writer.println("<title>Gespeicherte Adressen</title>");
    writer.println("</head>");
    writer.println("<body bgcolor=white>");
	
    try{
      final String fullname = request.getParameter("fullname");
      final String email = request.getParameter("email");
      final Adressverwaltung adv 
         = AdressverwaltungFactory
              .getAdressverwaltung(getServletConfig()
                                   .getServletContext()
                                   .getRealPath(".")
                                   +"/addresses.xml");
      adv.add(new Address
                (new Fullname(fullname),new Email(email)));
      writer.println("added: "+fullname+": "+email);
    }catch(Exception e){writer.println(e);}
    writer.println("</body>");
    writer.println("</html>");
  }
}

<html><body bgcolor="white">
<h1>Adresssuche</h1>
<form action="delete" method=POST>
Name:
<input type="text" size="20" name="fullname">
<br>
<input type="submit">
</form>
</body>
</html>

package name.panitz.webexample.address;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.*;

import java.io.File;
import java.util.*;

public final class DeleteAddress extends HttpServlet {
  public void 
   doGet(HttpServletRequest request, HttpServletResponse response)
                        throws IOException, ServletException{
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("GET Request. No Form Data Posted");
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
        throws IOException, ServletException {
    response.setContentType("text/html");
    final PrintWriter writer = response.getWriter();


    writer.println("<html>");
    writer.println("<head>");
    writer.println("<title>Gespeicherte Adressen</title>");
    writer.println("</head>");
    writer.println("<body bgcolor=white>");
	
    try{
      final String fullname = request.getParameter("fullname");
      final Adressverwaltung adv 
         = AdressverwaltungFactory
              .getAdressverwaltung(getServletConfig()
                                   .getServletContext()
                                   .getRealPath(".")
                                   +"/addresses.xml");
      final Fullname name = new Fullname(fullname);
      adv.remove(name);
      writer.println("removed: "+fullname);
    }catch(Exception e){writer.println(e);}
    writer.println("</body>");
    writer.println("</html>");
  }
}

5.1.7  Java Server Pages

• die angefragten Daten berechnen.
• die angefragte Html-Seite mit den berechneten Daten generieren.

Beispiel:
Die Seite zum Auflisten der Adressen in unserer Webapplikation läßt sich wesentlich kürzer als JSP schreiben.

<%@ page contentType="text/html"%> 
<html><head>
<title>Adressliste</title></head>
<body bgcolor="white">
<%  
     java.io.PrintWriter writer = response.getWriter();
     name.panitz.webexample.address
     .Adressverwaltung adv 
         =  name.panitz.webexample.address
              .AdressverwaltungFactory
              .getAdressverwaltung(getServletConfig()
                                   .getServletContext()
                                   .getRealPath(".")
                                   +"/addresses.xml");
     name.panitz.webexample.address.ListAddresses
     .writeAddressesAsHTML(adv.getAddresses(),writer);
 %>
</body>
</html>

5.2  Reflektion

• es läßt sich die Klasse erfragen, von der ein Objekt erzeugt wurde.
• es lassen sich Informationen über bestimmte Klassen erfragen
• neue Instanzen lassen sich von Klassen erzeugen, von denen nur der Name als String vorliegt.
• Methoden und Felder können benutzt werden, obwohl deren Name erst während der Laufzeit berechnet wird.

• Klassenbrowsern
• Debuggern
• Gui-Buildern

5.2.1  Eigenschaften von Klassen erfragen

• In der Klasse Objekt existiert die Methode Class getClass(). Sie gibt für Objekte ein Klassenobjekt der Klasse, von der sie erzeugt wurden zurück.
• Für jede Klasse kann über den Ausdruck KlssenName.class das Class-Objekt erhalten werden, das diese Klasse beschreibt.
• In der Klasse Class ist die statische Methode forName(String klassenName), die für einen als String vorliegenden Klassennamen das entsprechende Class-Objekt berechnet. Falls keine Klasse mit entsprechenden Namen vorhanden ist wird eine Ausnahme des Typs ClassNotFoundException geworfen.

package name.panitz.reflect;
public class RefectClass{
  public static void main(String [] args)throws Exception{
    Object o = "hallo";
    System.out.println(o.getClass());
    System.out.println(int.class);
    System.out.println(Class.forName("java.lang.Comparable"));
  }
}

sep@linux:~/fh/prog4/examples> java -classpath classes/ name.panitz.reflect.RefectClass
class java.lang.String
int
interface java.lang.Comparable
sep@linux:~/fh/prog4/examples>

package name.panitz.reflect;
public class RefectTypeVar{
  public static void main(String [] args)throws Exception{
    Object o = "hallo";
    Class<String> klasse = String.class;
    String s = klasse.newInstance();
  }
}

package name.panitz.reflect;
public class TypeVarError {
  public static void main(String [] args) throws Exception{
    Class<String> klasse = Comparable.class;
  }
}

package name.panitz.reflect;
public class TypeVarError2 {
  public static void main(String [] args) throws Exception{
    Object o = "";
    Class<String> klasse = o.getClass();
  }
}

public final Class<? extends Object> getClass()

package name.panitz.reflect;
public class UnknownType {
  public static void main(String [] args) throws Exception{
    Object o = "";
    Class<? extends Object> klasse = o.getClass();
  }
}

package name.panitz.reflect;
public class UnknownError {
  public static void main(String [] args) throws Exception{
    Object o = new Object();
    Class<Object> klasse = o.getClass();
  }
}

 Class<? super T>getSuperclass(); 

Typen und Klassen

• Class<? super T> getSuperclass(): gibt die Klasse Oberklasse zurück, wie sie in ihrer Klassendatei definiert ist.
• Type getGenericSuperclass() gibt über den konkreten Typ der Superklasse zurück.

package name.panitz.reflect;
import name.panitz.crempel.util.*;

public class TupleSuper {
  public static void main(String [] args){
    Tuple2<String,Integer> t
      = new Tuple2<String,Integer>("hallo",42); 
    Class<? extends Tuple2<String,Integer>> klasse = t.getClass();
    System.out.println(klasse.getSuperclass());
    System.out.println(klasse.getGenericSuperclass());
  }
}

sep@linux:~/fh/prog4/examples> java  name.panitz.reflect.TupleSuper
class name.panitz.crempel.util.Tuple1
sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl@a62fc3
sep@linux:~/fh/prog4/examples>

Methoden, Konstruktoren und Felder

• java.lang.reflect.Field
• java.lang.reflect.Method
• java.lang.reflect.Constructor

• Field[] getFields()
• Method[] getMethods()
• Constructor[] getConstructors()

Constructor<T> getConstructor(Class... parameterTypes)

Beispiel: Klasseninformation als XML-Format

package name.panitz.crempel.tool.classInfo;

import java.lang.reflect.Method;
import name.panitz.domtest.DomTreeNode;
import javax.swing.*;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;

public class ClassAsXML {
  static Document convert(Class klasse) 
                    throws ParserConfigurationException{
    Document doc
      = DocumentBuilderFactory
	.newInstance()
	.newDocumentBuilder()
	.newDocument() ;

    Element classEl 
     =doc.createElement(klasse.isInterface()?"interface":"class");
    doc.appendChild(classEl);

    Element nameEl =doc.createElement("name");
    nameEl.appendChild(doc.createTextNode(klasse.getName()));
    classEl.appendChild(nameEl);

    for (Method m:klasse.getMethods()){
      final Element methodEl=getMethodInformation(doc,m);
      classEl.appendChild(methodEl);
    }
    return doc;
  }

  static Element getMethodInformation(Document doc,Method m){
    final Element methodEl=doc.createElement("method");
    final Element nameEl =doc.createElement("name");
    nameEl.appendChild(doc.createTextNode(m.getName()));
    methodEl.appendChild(nameEl);
    for (Class param:m.getParameterTypes()){
     final Element paramEl=doc.createElement("parameter");
     paramEl.appendChild(doc.createTextNode(param.getName()));
     methodEl.appendChild(paramEl);
    }
    final Element resultEl=doc.createElement("result");
    resultEl.appendChild
     (doc.createTextNode(m.getReturnType().getName()));
    methodEl.appendChild(resultEl);
    return methodEl;
  }

  public static void main(String [] args) throws Exception{
    JFrame f = new JFrame(args[0]);
    f.getContentPane()
     .add(new JTree(new DomTreeNode
                      (convert(Class.forName(args[0])))));
    f.pack();
    f.setVisible(true);
  }
}

5.2.2  Instanziieren dynamisch berechneter Klassen

package name.panitz.reflect;
public class InitAnyClass{
  private static String defaultClassName="java.lang.String";
  private static Object o=null; 

  static Object getObject()throws Exception{
    if (o==null){
      final String userClass = System.getProperty("user.class");
      final String name = userClass==null?defaultClassName:userClass;
      o=Class.forName(name).newInstance();
    }
    return o;
  }

  public static void main(String[]args)throws Exception{
    System.out.println(getObject());
    System.out.println(getObject().getClass());
  }
}

5.3  Klassen Laden

5.4  RMI

5.5  Persistenz

Appendix A
Crempel

A.1  Eingesetzte Werkzeuge

A.1.1  Java 1.5

• bei der Ausgabe von Fehlermeldungen kommt es ab und an zu internen Fehlern des Übersetzers.
• Eine for Schleife, über eine generische Sammlung von Integer, deren Elemente als int iteriert, aber im Rum pf nicht benutzt werden, führt zu fehlerhaften byte code:
  for (int i:someIntegerCollection){}.

A.1.2  CVS

export CVSROOT=:pserver:benutzername@pcx22.tfh-berlin.de:/home/cvsrepository

cvs login

cvs checkout panitz

cd panitz/crempel
less README.txt

• update: zum Holen der aktuellen neuen Quellen. Wenn also jemand anderes in der Zwischenzeit etwas neues eingecheckt hat, so bekommt man diese Änderungen auf seine lokale Kopie des Repositories.
• add: zum Hinzufügen weiterer Dateien in Repository, wobei der Befehl add noch nicht dafür sorgt, daß die neue Datei auf den Server geschrieben wird, sondern nur vermerkt wird, daß diese zum Repository beim nächsten commit hinzugefügt werden soll.
• commit: Änderungen, die in der lokalen Kopie gemacht wurden, werden auf den Server geschrieben. Nun werden auch die mit add hinzugefügten Dateien auf den Server geschrieben. Es ist zu empfehlen vor einem commit immer erst ein update durchzuführen, um sicher zu stellen, daß es zu keinen Konflikten mit zwischenzeitlich von anderen Programmierern gemachten Änderungen kommt. Beim einchecken von Änderungen verlangt CVS einen Kommentar. Standardmäßig wird der Editor vi geöffnet, um diesen Kommentar einzugeben. Diese Einstellung kann auf einen anderen Editor umgesetzt werden.

A.1.3  ANT

vi build-lib.xml

export CLASSPATH=/usr/java/j2sdk1.5/lib/tools.jar:$CLASSPATH

ant run

A.1.4  JavaCC

A.2  Crempel Architektur

A.2.1  Crempel Komponenten

brauser

classinfo

filebrowser

jugs

midi

ping

pittoresque

xmlparslib

xpath

adt

corelib

Appendix B
Grammatiken

B.1  JavaCC Grammatik für einen rudimentären XML Parser

options {
   STATIC=false;
}

PARSER_BEGIN(XMLParser)
package name.panitz.xml;

import java.util.List;
import java.util.ArrayList;
import java.io.FileReader;

public class XMLParser  {
  public static void main(String [] args)throws Exception{
    XML doc = new XMLParser(new FileReader(args[0])).xml();

    System.out.println(doc.visit(new Show()));
    System.out.println(
     doc.visit(new SelectElement(new Name("","code",""))));
    System.out.println(doc.visit(new Content()));
    System.out.println(doc.visit(new Size()));
    System.out.println(doc.visit(new Depth()));

  }
}
PARSER_END(XMLParser)

TOKEN :
{< NCNAME : ( <Letter> | "_" ) ( <NCNAMECHAR> )* >}

TOKEN :
{ < NCNAMECHAR : ( <Letter> | <Digit> | "." | "-" | "_" | <Extender> )	>
| < #Letter    : ( <BaseChar> )						>
| < #BaseChar  : ["\u0041"-"\u005A","\u0061"-"\u007A","\u00C0"-"\u00D6",
		  "\u00D8"-"\u00F6","\u00F8"-"\u00FF"]			>
| < #Digit     : ["\u0030"-"\u0039"]					>
| < #Extender  : ["\u00B7"]						>
}

<CharDataSect> TOKEN :
{ < CHARDATA       : ( <CharDataStart> )+	>
| < #CharDataStart : ( ~["<","&"] )		>
}

<DEFAULT, CharDataSect> TOKEN:
{ < STAGO:   "<"					> : DEFAULT
| < ETAGO:   "</"					> : DEFAULT
| < PIO	 :   "<?"					> : DEFAULT
| < COMMENT: "<!--" (~["-"])* ("-" (~["-"])+)* "-->"	> : DEFAULT
}

TOKEN :
{<ETAGC: "/>">
|<GT: ">">
|<EQ: "=">
}


<DEFAULT,AttValueSect> TOKEN :
{  < DQUOTED: "\""	> : DEFAULT
|  < SQUOTED: "'"	> : DEFAULT
}

<AttValueSectD> TOKEN :
{ < AttValueDRest : ( ~["<","&","\""] )+ >
| < AttValueDEnd  : "\""                 > : DEFAULT
}

<AttValueSectS> TOKEN :
{ < AttValueSRest : ( ~["<","&","'"] )+ >
| < AttValueSEnd  : "'"                 > : DEFAULT
}

<DEFAULT, CharDataSect> TOKEN :
{ < CDataStart : "<![CDATA[" > : CDataSect}

<CDataSect> TOKEN :
{  < CDataContent : 
    ( ~["]"] )+ ( (( "]" ( ~["]"] ) ) | ( "]]" ~[">"] )) ( ~["]"] )* )*	>
}

<DEFAULT, CDataSect> TOKEN :
{ < CDataEnd     : "]]"">"> : DEFAULT}

<DEFAULT,CharDataSect, AttValueSectD, AttValueSectS> TOKEN :
{  < AMP: "&"	> : DEFAULT}

<RefSect> TOKEN :
{ < EOENT : ";" > : DEFAULT }


SKIP :
{ "\u0020"
| "\t"
| "\n"
| "\r"
}

XML xml():
{XML xml;}
{(xml=element()
 |xml=text()
 |xml=cdata()   { token_source.SwitchTo(CharDataSect); }
 |xml=comment() { token_source.SwitchTo(CharDataSect); }
 |xml = entity(){ token_source.SwitchTo(CharDataSect); }
// |xml=pi()      { token_source.SwitchTo(CharDataSect); }
 )
 {return xml;}}

Element element():
{List attributes=new ArrayList();
 List children=new ArrayList();
 Attribute attribute;
 XML xml;
 Name name;
 Name endName;
}
{<STAGO> name=name() 
 (attribute=attribute() {attributes.add(attribute);} )*
 ((<ETAGC>  {token_source.SwitchTo(CharDataSect); })
 |(<GT> {token_source.SwitchTo(CharDataSect);}
    (xml=xml() {children.add(xml);})* <ETAGO>endName=name()<GT>
   {token_source.SwitchTo(CharDataSect); })
 )
 {return new Element(name,attributes,children);}
}

Text text():
{Token tok;}
{tok=<CHARDATA>{return new Text(tok.image);}}

CDataSection cdata() : { String data = null; }
{ <CDataStart>
  [ data = CData() ]
  <CDataEnd> 
  {return new CDataSection(data);}
}

String CData() : { Token tok; }
{ tok = <CDataContent> { return tok.image; } }

Comment comment():{Token comment;}
{comment=<COMMENT> 
  {String com = comment.image;
   com = com.substring(4,com.length()-3);
   return new Comment(com);}
}

Entity entity():
{ String name; }
{ <AMP>
  name = ncName() { token_source.SwitchTo(RefSect); }
  <EOENT>
    { return new Entity(name); }
}

Attribute attribute():
{ Name n;
  String value;}
{ n=name() <EQ> 
   { token_source.SwitchTo(AttValueSect); }
  value = AttValue() 
{return new Attribute(n,value);}}

String AttValue() :
{ StringBuffer sb;
  char chr;
  Token tok;
  String str = null;
  char[] ac = null;
}
{ (
    <DQUOTED> { 
      token_source.SwitchTo(AttValueSectD);
       sb = new StringBuffer();
    }
    ( tok = <AttValueDRest> { sb.append(tok.image); })*
    <AttValueDEnd> { return sb.toString(); }
  )
  |
  (
    <SQUOTED> {
      token_source.SwitchTo(AttValueSectS);
       sb = new StringBuffer();
    }
    ( tok = <AttValueSRest> { sb.append(tok.image); })*
    <AttValueSEnd> { return sb.toString(); }
  )
}

String ncName() : { Token tok; }
{tok = <NCNAME> { return tok.image; }}

Name name():
{String pre="";
 String n="";}
{ pre=ncName()
  [ ":" n=ncName(){System.out.println(n);}]
  {if (n.length()==0) return new Name("",pre,"");
   return new Name(pre,n,"");}
}

B.2  Javacc Grammatik für abgekürzte XPath Ausdrücke

Appendix C
Gesammelte Aufgaben

{\bf \alph{unteraufgabe})}

<a>to be </a><b> or not to be</b>

Lösung
Kein top-level Element, das das ganze Dokument umschließt.
{\bf \alph{unteraufgabe})}

<person geburtsjahr=1767>Ferdinand Carulli</person>

Lösung
Attributwerte müssen in Anführungszeichen stehen.
{\bf \alph{unteraufgabe})}

<line>lebt wohl<br/>
<b>Gott weiß, wann wir uns wiedersehen</line>

Lösung
<b> wird nicht geschlossen.
{\bf \alph{unteraufgabe})}

<kockrezept><!--habe ich aus dem Netz
  <name>Saltimbocca</name>
  <zubereitung>Zutaten aufeinanderlegen 
               und braten.</zubereitung>
</kockrezept>

Lösung
Kommentar wird nicht geschlossen.
{\bf \alph{unteraufgabe})}

<cd>
  <artist>dead&alive</artist>
  <title>you spin me round</title></cd>

Lösung
Das Zeichen & muß als character entity &amp; geschrieben werden.

<?xml version="1.0" encoding="iso-8859-1" ?>
<autoren>
<autor>
  <person>
    <nachname>Shakespeare</nachname>
    <vorname>William</vorname>
  </person>
  <werke>
    <opus>Hamlet</opus>
    <opus>Macbeth</opus>
    <opus>King Lear</opus>
  </werke>
</autor>
<autor>
  <person>
    <nachname>Kane</nachname>
    <vorname>Sarah</vorname>
  </person>
  <werke>
    <opus>Gesäubert</opus>
    <opus>Psychose 4.48</opus>
    <opus>Gier</opus>
  </werke>
</autor>
</autoren>

{\bf \alph{unteraufgabe})} Schreiben Sie eine DTD, das die Struktur dieses Dokuments beschreibt.
Lösung

AutorenType
<!DOCTYPE autoren SYSTEM "AutorenType.dtd" [
<!ELEMENT autoren (autor+)>
<!ELEMENT autor (person,werke)>
<!ELEMENT werke (opus*)>
<!ELEMENT opus (#PCDATA)>
<!ELEMENT person (nachname,vorname)>
<!ELEMENT nachname (#PCDATA)>
<!ELEMENT vorname (#PCDATA)>]>

{\bf \alph{unteraufgabe})} Entwerfen Sie Java Schnittstellen, die Objekte ihrer DTD beschreiben.
Lösung

Autoren

package name.panitz.xml.exercise;
import java.util.List;
public interface Autoren {
  List<Autor> getAutorList();
}

Autor

package name.panitz.xml.exercise;
public interface Autor {
  Person getPerson();
  Werke  getWerke();
}

Person

package name.panitz.xml.exercise;
public interface Person {
  Nachname getNachname();
  Vorname  getVorname();
}

Werke

package name.panitz.xml.exercise;
import java.util.List;
public interface Werke {
  List<Opus> getOpusList();
}

HasJustTextChild

package name.panitz.xml.exercise;
public interface HasJustTextChild {
  String getText();
}

Opus

package name.panitz.xml.exercise;
public interface Opus extends HasJustTextChild {}

Nachname

package name.panitz.xml.exercise;
public interface Nachname extends HasJustTextChild {}

Vorname
package name.panitz.xml.exercise;
public interface Vorname extends HasJustTextChild {}

{\bf \alph{unteraufgabe})} Schreiben Sie ein XSLT-Skript, das obige Dokument in eine Html Liste der Werke ohne Autorangabe transformiert.
Lösung

WerkeListe
<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
     <html><head><title>Werke</title></head>
       <body><xsl:apply-templates /></body>
     </html>
  </xsl:template>

  <xsl:template match="autoren">
     <ul><xsl:apply-templates select="autor/werke/opus"/></ul>
  </xsl:template>

  <xsl:template match="opus">
     <li><xsl:apply-templates/></li>
  </xsl:template>
</xsl:stylesheet>

{\bf \alph{unteraufgabe})} Schreiben Sie eine Javamethode
List<String> getWerkListe(Autoren autoren);,
die auf den Objekten Ihrer Schnittstelle für Autoren eine Liste von Werknamen erzeugt.
Lösung

GetWerke

package name.panitz.xml.exercise;
import java.util.List;
import java.util.ArrayList;

public class GetWerke{
  public List<String> getWerkListe(Autoren autoren){
    List<String> result = new ArrayList<String>();
    for (Autor a:autoren.getAutorList()){
      for (Opus opus: a.getWerke().getOpusList())
        result.add(opus.getText());
    }
    return result;
  }
}

<?xml version="1.0" encoding="iso-8859-1" ?>
<x1><x2><x5>5</x5><x6>6</x6></x2><x3><x7>7</x7></x3>
<x4><x8/><x9><x10><x11></x11></x10></x9></x4></x1>

{\bf \alph{unteraufgabe})} Zeichnen Sie dieses Dokument als Baum.
{\bf \alph{unteraufgabe})} Welche Dokumente selektieren, die folgenden XPath-Ausdrücke ausgehend von der Wurzel dieses Dokuments
• //x5/x6
• /descendant-or-self::x5/..
• //x5/ancestor::*
• /x1/x2/following-sibling::*
• /descendant-or-self::text()/parent::node()

package name.panitz.xml.exercise;
import java.util.List;
import java.util.ArrayList;
import org.w3c.dom.*;

public class GetLeaves{
  public List<Node> getLeaves(Node n){
    List<Node> result = new ArrayList<Node>();
    NodeList ns = n.getChildNodes();
    if (ns.getLength()==0){
      result.add(n); return result;
    }
    for (int i=0;i<ns.getLength();i++){
      result.addAll(getLeaves(ns.item(i)));
    }
    return result;
  }
}

Index

List of Figures

Bibliography

[Arn04]

Arnaud Le Hors and Philippe Le Hégaret and Lauren Wood and Gavin Nicol and Jonathan Robie and Mike Champion and Steve Byrne. Document Object Model (DOM) Level 3 Core Specification Version 1.0. W3C Recommendation, April 2004. http://www.w3.org/TR/P3P/.

[CD99]

James Clark and Steve DeRose. XML Path Language (XPath) 1.0. W3C Recommendation, November 1999. http://www.w3.org/TR/1999/REC-xpath-19991116.xml.

[GHJV95]

Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements od Reusable Object-Oriented Software. Addison-Wesley Professional Computing Series. Addison-Wesley Publishing Company, New York, NY, 1995.

[HM96]

Graham Hutton and Eric Meijer. Monadic parser combinators. submitted for publication,
www.cs.nott.ac.uk/Department/Staff/gmh/bib.html, 1996.

[Ler97]

Xavier Leroy. The Caml Light system release 0.73. Institut National de Recherche en Informatique et Automatique, 1 1997.

[Mil78]

Robin Milner. A theory of type polymorphism in programming. J.Comp.Sys.Sci, 17:348-375, 1978.

[MTH90]

Robin Milner, Mads Tofte, and Robert Harper. The Definition of Standard ML. IT Press, Cambridge, Massachusetts, 1990.

[NB60]

Peter Naur and J. Backus. Report on the algorithmic language ALGOL 60. Communications of the ACM, 3(5):299-314, may 1960.

[OW97]

Martin Odersky and Philip Wadler. Pizza into java: Translating theory into practice. In Proc. 24th ACM Symposium on Principles of Programming Languages, 1997.

[Pan00]

Sven Eric Panitz. Generische Typen in Bolero. Javamagazin, 4 2000.

[Pan03a]

Sven Eric Panitz. Programmieren I. Skript zur Vorlesung, 2. revidierte Auflage, 2003. www.panitz.name/prog1/index.html.

[Pan03b]

Sven Eric Panitz. Programmieren II. Skript zur Vorlesung, TFH Berlin, 2003. www.panitz.name/prog2/index.html.

[Pan03c]

Sven Eric Panitz. Programmieren III. Skript zur Vorlesung, TFH Berlin, 2003. www.panitz.name/prog3/index.html.

[Pan04a]

Sven Eric Panitz. Erweiterungen in Java 1.5. Skript zur Vorlesung, TFH Berlin, 2004. www.panitz.name/java1.5/index.html.

[Pan04b]

Sven Eric Panitz. The Making of Jugs. Skript zur Vorlesung, TFH Berlin, 2004. www.panitz.name/jugs/index.html.

[PvE95]

R. Plasmeijer and M. van Eekelen. Concurrent clean: Version 1.0. Technical report, Dept. of Computer Science, University of Nijmegen, 1995. draft.

[T. 04]

T. Bray, and al. XML 1.1. W3C Recommendation, February 2004. http://www.w3.org/TR/xml11.

[Wad85]

Phil Wadler. How to replace failure by a list of successes. In Functional Programming Languages and Computer Architecture, number 201 in Lecture Notes in Computer Science, pages 113-128. Springer, 1985.

[Wad00]

Philip Wadler. A formal semantics of patterns in XSLT, March 2000.