GGMan   -  Testen und Manipulieren von Geograf-Daten

Skript   Factories   Filter   Grabber   Funktionen   Macros   Utils   Files   GUI   Typen   Elemente  

Skript

Allgemeines
Syntax
Beispiel 1
Beispiel 2

Allgemeines

Die gesamte Steuerung des Auswerteprozesses geschieht über ein Ablaufskript. Ein solches Skript hat typischerweise die Endung *.ggman. Ein GGMan-Skript wird mit einem Texteditor erstellt. Nach Möglichkeit sollte ein Editor mit Syntax-Highlighting verwendet werden, damit Kommentare und Code farblich unterschieden werden können.

Ein Skript wird von GGMan nach dem Start gelesen und ausgewertet. Fehler im Skriptsyntax werden sofort erkannt und unter Angabe der Zeilennummer dem Anwender bekanntgegeben. Nur wenn das Skript fehlerfrei gelesen werden konnte, wird der Auswerteprozess gestartet.

Das Skript wird von GGMan der Reihenfolge nach abgearbeitet. Die Anzahl der aktuell abgearbeiteten Factories wird im Dialog angezeigt.

Syntax

Kommentare

Wie bei jeder Programmierung sollte auch ein GGMan-Skript in ausreichenden Maße kommentiert werden. Es bestehen zwei Möglichkeiten der Kommentarangabe:
Ein einzeiliges Kommentar wird mit den Zeichen // eingeleitet.

//diese Kommentarzeile wird nicht ausgewertet
Der Inhalt der Komentarzeilen wird durch GGMan nicht ausgewertet, es kann also ein beliebiger Text hinter den Zeichen // stehen.

Ein Kommentar kann sich auch über mehrere Zeilen erstrecken. Es wird mit den Zeichen /* eingeleitet und mit der Zeichenkombination */ abgeschlossen.


/*
   Dies
   ist
   ein mehrzeiliger Kommentar
*/
Auf diese Art und Weise können auch ganze Skriptabschnitte schnell auskommentiert werden.

Anweisungszeile

Eine Anweisung soll sich in der Regel in einer Skriptzeile befinden.

new Factory ReaderFactory //eine Anweisungszeile

new
   Factory
   ReaderFactory //Die Verteilung einer Anweisung über mehrere Zeilen ist nicht zulässig!

new \
   Factory \
   ReaderFactory //In diesem Fall muss die Zeile mit dem Zeichen '\' fortgesetzt werden
Insbesondere bei langen Anweisungszeilen kann es der Übersichtlichkeit dienen, diese auf mehrere Skriptzeilen zu verteilen. In diesem Fall muss die fortzusetzende Zeile mit dem Zeichen \ abgeschlossen werden. GGMan hängt dann die Folgezeile an.

Leerzeichen

Die Anweisungszeilen werden wortweise interpretiert. Die Trennung zwischen einzelnen Wörtern ist das Leerzeichen. Die Anzahl der trennenden Leerzeichen ist dabei beliebig. Es können also Leerzeichen verwendet werden, um den Skripttext übersichtlich zu formatieren. Im folgenden Beispiel wurde alle Anweisungen innerhalb der Factory mit drei Leerzeichen eingerückt. Die Anweisung range innerhalb des Filters wurde wiederum um drei Leerzeichen eingerückt. So ist die Anweisungsstruktur auf den ersten Blick erkennbar.

new Factory ReaderFactory
   name = PunktArtPrüfer
   filter = new Filter ArtFilter
      range = 452
   end
end

Anweisungen

Bei der Auswertung des Skriptes können dem Skript-Interpreter Anweisungen gegeben werden. Eine Anweisung wird mit dem Hashzeichen # eingeleitet. Es folgt der Befehl und nach einem Leerzeichen eventueller Inhalt.

//Eine Skriptdatei einbinden
#INCLUDE "c:\programme\ggman\macros.ggman"

Folgende Anweisungen sind implementiert:

Globale Parameter

Im Kopf des Skriptes können eine globale Einstellungen vorgenommen werden.

DETAIL_MESSAGES = true
ERROR_FILE = new File GGStapelFile
   name = fehler.stp
end

Globale Konstanten

GGMan benutzt bei der Auswertung Objekte wie Filter, Grabber, List und Map. Die Objekte können in mehreren Factories benutzt werden. Dazu müssen diese Objekte im Skript erzeugt und einer Konstanten zugewiesen werden.

Eine globale Konstante beginnt immer mit den Zeichen $. Es folgt der Konstantenname, über den das Objekt identifiziert wird. Die Zuweisung geschieht mit dem Zuweisungsoperator =.

In dem folgenden Beispiel wird ein Filter erzeugt und der Konstante $arten zugewiesen. In der darauf folgenden Factory wird dieser Filter als Parameter übergeben, das könnte in mehreren Factories geschehen.

//Filter erzeugen und $arten zuweisen
$arten = new Filter ArtFilter
   range = 452
end
//Eine Factory ...
new Factory ReaderFactory
   //... in der der Filter $arten benutzt wird
   filter = $arten
end

Einer Konstanten kann auch ein Wert zugewiesen werden. Damit können Werte am Beginn des Skriptes vereinbart werden, die dann für mehrere Factories benutzt werden.

//Die Definition einer Konstanten...
$distance = 0.50

//Eine Factory zum Finden von Punktabständen...
new Factory PointDistanceSetFinder
   filter = new Filter ArtFilter
      list = 2050, 2051, 2150, 2151, 2250, 2251
   end
   //die Übergabe der Konstanten
   maxDistance = $distance
end

Die Zuweisung der Konstanten zu der Factory erfolgt beim Auswerten des Skriptes. Der Inhalt der Konstanten wird in der Regel erst beim Ablauf der Factory ausgewertet. Fehlerhafte Inhalte der Konstanten werden demzufolge auch erst nach dem Start des Skriptes angezeigt.

Den Konstanten kann auch eine Funktion zugewiesen werden. Diese wird ebenfalls erst zur Laufzeit ausgewertet. Damit können die Parameter der Factories auch abhängig von den eingehenden Daten gestaltet werden.
In der folgenden Factory wird der Parameter maxDistance mit Hilfe einer Function abhängig von den eingehenden Punktarten gestaltet.

//Die Definition einer Konstanten...
   //Bei der Punktart 2050 gilt der Abstand 0.5
   //ansonsten gilt 1.0
$distance = @Cond(@Eq(@Get(&in, "art"), 2050), 0.5, 1.0)

//Eine Factory zum Finden von Punktabständen...
new Factory PointDistanceSetFinder
   filter = new Filter ArtFilter
      list = 2050, 2051, 2150, 2151, 2250, 2251
   end
   //die Übergabe der Konstanten
   maxDistance = $distance
end

Da die übergebene Funktion erst zur Laufzeit innerhalb der Factory ausgewertet wird, steht das Attribute &in bei der Auswertung zur Verfügung.

Globale Konstanten können auch in Textstrings eingesetzt werden. In diesem Fall muss das Ende des Konstantennamens ebenfalls mit einem $ angezeigt werden.

@Print("Der Fehler $errText$ ist aufgetreten")

Der Inhalt der Konstanten wird zum Zeitpunkt der Skriptauswertung erzeugt und eingesetzt. Eine Übergabe einer Funktion ist also nicht möglich.

Einige Konstanten werden durch GGMan zum Programmstart angelegt. Sie enthalten folgenden Inhalt:

  • $Version = 1.2 Versionsnummer
  • $Date = 29.01.2006 16:36:47 Datum und Uhrzeit
  • $Day = 29 Tag
  • $Month = 01 Monat
  • $Year = 2006 Jahr
  • $Hour = 16 Stunde
  • $Minute = 36 Minute
  • $Second = 47 Sekunde
  • $User = Georg Benutzername
  • $InFile = C:\Daten\guben.out vollständiger Pfad der Eingabedatei
  • $InFileName = guben.out Dateiname der Eingabedatei
  • $InFileSurname = guben Dateiname der Eingabedatei ohne Erweiterung
  • $InFilePath = C:\Daten\ Pfad der Eingabedatei
  • $InFileExtension = out Erweiterung der Eingabedatei
  • $OutFile = C:\Daten\guben.out vollständiger Pfad der Ausgabedatei
  • $OutFileName = guben.out Dateiname der Ausgabedatei
  • $OutFileSurname = guben Dateiname der Ausgabedatei ohne Erweiterung
  • $OutFilePath = C:\Daten\ Pfad der Ausgabedatei
  • $OutFileExtension = out Erweiterung der Ausgabedatei
  • $SkriptFile = C:\Daten\guben.out vollständiger Pfad der Skriptdatei
  • $SkriptFileName = guben.out Dateiname der Skriptdatei
  • $SkriptFileSurname = guben Dateiname der Skriptdatei ohne Erweiterung
  • $SkriptFilePath = C:\Daten\ Pfad der Skriptdatei
  • $SkriptFileExtension = out Erweiterung der Skriptdatei
  • $LogFile = C:\Daten\guben.out vollständiger Pfad der Logdatei
  • $LogFileName = guben.out Dateiname der Logdatei
  • $LogFileSurname = guben Dateiname der Logdatei ohne Erweiterung
  • $LogFilePath = C:\Daten\ Pfad der Logdatei
  • $LogFileExtension = out Erweiterung der Logdatei
  • //Stapeldatei mit dem Namen der Quelldatei erzeugen
    ERROR_FILE = new File GGStapelFile
       name = $InFilePath$$InFileSurname$.stp
    end

    lokale Variablen

    Die Factories stellen Eingabe-, Ausgabeelemente und Ergebnisse in Variablen zur Verfügung. Mit Hilfe von Funktionen kann auf diese Variablen zugegriffen werden, um eine individuelle Auswertung zu ermöglichen.
    Mit Hilfe der Funktion @Store() können aber auch eigene Ergebnisse zur weitern Verwendung zwischengespeichert werden.

    Eine Variable beginnt immer mit dem &-Zeichen. Es folgt ein Variablenbezeichner. Die Bezeichner der von den Factories zur Verfügung gestellten Variablen sind in der Beschreibung der einzelnen Factories dokumentiert. Beim Speichern von eigenen Variablen mit der Funktion @Store() können freie Namen vergeben werden. Zur besseren Unterscheidung sollten sie mit Kleinbuchstaben beginnen, zB: &errorCount.

    Die lokalen Variablen stehen nur innerhalb des umgebenden Objekts (zB. einer Factory) zur Verfügung. Um Werte objektübergreifend zu benutzen, müssen globale Variablen benutzt werden.

    globale Variablen

    Mit der Funktion @Global() können Variablen objektübergreifend gespeichert werden. Sie stehen dann in allen nachfolgenden Factories zur Verfügung. Der Variablenname wird wieder mit dem &-Zeichen eingeleitet, der Bezeichner kann frei gewählt werden. Zur besseren Unterscheidung sollten globale Variablen mit einem Großbuchstaben beginnen, zB: &ErrorCount.

    Objekte

    Objekte sind Factories, Filter, Grabber, List und Map. Objekte werden immer mit dem Schlüsselwort new eingeleitet. Es folgt der Objekttyp, zb. Factory oder Filter. Danach folgt der Name des Objekts, zB. ArtFilter. Das Objekt wird mit dem Schlüsselwort end abgeschlossen.

    new Factory ReaderFactory
       name = PunktArtPrüfer
    end

    Alle Anweisungszeilen zwischen der Einleitung new und dem Abschluss end werden dem Objekt zugeordnet. So wird im obigen Beispiel der Parameter name der ReaderFactory gesetzt. Die Anweisungszeilen innerhalb eines Objektes rückt man sinnvollerweise ein, um die Zugehörigkeit der Anweisung zum jeweiligen Objekt zu verdeutlichen.

    Objekte können ineinander geschachtelt werden. Die Anweisungszeilen gelten dann für das letzte mit new eingeleitete Objekt.

    new Factory ReaderFactory
       name = PunktArtPrüfer
       filter = new Filter ArtFilter
          range = 452
       end
    end

    Beispiel 1

    Diese Beispiel enthält nur Factories, die in der Freeware-Version enthalten sind

    /*
     * Einstellungen des GGManipulators
     * Test für GIS-Daten
     * die Grafout-Datei wird mit den Standardarten der f500.art erwartet.
     */

    //Zuerst Globale Einstellungen
    DETAIL_MESSAGES = false
    ERROR_FILE = new File GGStapelFile
       name = fehler.stp
    end

    //Dann einige Variablenfestlegungen
    $startnr    = @Counter(99990000000)     //neue Punktnummern werden ab hier vergeben
    $schutzrohr = 0.50            //für Schutzrohre werden Umringspolygone erzeugt, hier steht der Abstand von der Mittellinie
    $minAngle   = 110             //es werden Polygone für bestimmte Linienarten zusammengesucht, bei Brechungswinkeln kleiner 110 gon, wird das Polygon unterbrochen


    /**************************************************************************
     *                                                                        *
     * Fachschale Grundplan                                                   *
     *                                                                        *
     **************************************************************************/


    /*
     * Zuerst prüfen wir, ob noch alte Linienarten existieren
     */
    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft auf veraltete Linienarten"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = li, bo, bn
          end
          filter = new Filter ArtFilter
             range = 500
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Linienart ", @Get(&in, art)" ist nicht mehr zu verwenden. Umstellen auf neue Arten"))
       finally  = @Log("&count veraltete Arten von Grundplanlinien gefunden")
    end

    /*
     * Logik der Böschungen Testen
     */
    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft die Böschungslinien"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = li
          end
          filter = new Filter EbeneFilter
             range = 5
          end
          filter = new Filter ArtFilter
             mode = not
             range = 511-514
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Linie mit Art ", @Get(&in, art)" ist auf Ebene 5 nicht zulässig"))
       finally  = @Log("&count falsche Linienarten auf Ebene 5 gefunden")
    end

    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft die Böschungsschraffuren"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = bo, bn
          end
          filter = new Filter EbeneFilter
             range = 5
          end
          filter = new Filter ArtFilter
             mode = not
             range = 515
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Böschung mit Art ", @Get(&in, art)" ist auf Ebene 5 nicht zulässig"))
       finally  = @Log("&count falsche Böschungsarten auf Ebene 5 gefunden")
    end


    /**************************************************************************
     *                                                                        *
     * Fachschale ABWASSER                                                    *
     *                                                                        *
     **************************************************************************/

    /**
     * Jetzt prüfen wir, ob an allen Abwasserleitungen korrekte Punkte hängen
     */
    new Factory ReaderFactory
       name = "PunktArtPrüfer Ebene20"
       spec = "prüft, ob an den Regenwasserleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = new Filter ArtFilter
             range = 2000-2020 //Regenwasser-Leitungen
          end
       end
       filter = new Filter ArtFilter
          mode = not
          range = 452-457   //Ebene4
          range = 2000-2051 //Regenwasser
          range = 2250-2251 //Mischwasserschächte
       end
       function = @Log(WARNING, &in, @Concat("Punktart ", @Get(&in, art)" ist an Regenwasserleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Regenwasserleitungen gefunden")
    end

    new Factory ReaderFactory
       name = "PunktArtPrüfer Ebene21"
       spec = "prüft, ob an den Schmutzwasserleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = new Filter ArtFilter
             range = 2100-2120 //Schmutzwasserleitungen
          end
       end
       filter = new Filter ArtFilter
          mode = not
          range = 454-457   //Ebene4
          range = 2100-2151 //Schmutzwasser
          range = 2250-2251 //Mischwasserschächte
       end
       function = @Log(WARNING, @Concat("Punktart ", @Get(&in, art)" ist an Schmutzwasserleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Schmutzwasserleitungen gefunden")
    end

    new Factory ReaderFactory
       name = "PunktArtPrüfer Ebene22"
       spec = "prüft, ob an den Mischwasserleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = new Filter ArtFilter
             range = 2200-2220 //Mischwasserleitungen
          end
       end
       filter = new Filter ArtFilter
          mode  = not
          range = 454-457   //Ebene4
          range = 2200-2251 //Mischwasserpunkte
       end
       function = @Log(WARNING, @Concat("Punktart ", @Get(&in, art)" ist an Mischwasserleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Mischwasserleitungen gefunden")
    end


    new Factory LabelReader
       name = "BeschriftungsTextTester Ebene 20-22"
       spec = "Prüft auf korrekte Beschriftung"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = pk
          end
          filter = new Filter ArtFilter
             list = 455,456,457,459
          end
       end
       function = @If(@And(@Equals(@Get(&label, art450, @Not(@Equals(@Get(&label, allText)"A"))) , \
                      @Log(ERROR, &in, @Concat("Ungültiger Beschriftungsinhalt '", @Get(&label, allText)"' Soll: 'A'")))
       finally  = @Log("&count Beschriftungen getestet")
    end



    new Factory ReaderFactory
       name = "SchachtHöhenGrabber"
       spec = "Schiebt die Schachtdeckelhöhen in die Abwasserfachschale"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id   = te
          end
          filter = new Filter ArtFilter
             list = 603
          end
       end
       function = @Set(&in, ebene, 20)
       finally  = @Log("&count Schachthöhen auf Fachschale Abwasser verschoben")
    end


    /**************************************************************************
     *                                                                        *
     * Fachschale TRINKWASSER                                                 *
     *                                                                        *
     **************************************************************************/

    /*
     * Zuerst prüfen wir, ob noch alte Linienarten existieren
     */
    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft auf veraltete Linienarten"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = li
          end
          filter = new Filter ArtFilter
             mode = or
             range = 2300-2303
             range = 2400-2403
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Linienart ", @Get(&in, art)" ist nicht mehr zu verwenden. Umstellen auf die Arten 2310-2313"))
       finally  = @Log("&count veraltete Arten von Trinkwasserleitungen gefunden")
    end

    /**
     * Folgender Filter enthält alle Wasserleitungen
     */
    $was_ltg = new Filter ArtFilter
       mode = or
       range = 2300-2320
       range = 2400-2420
    end

    /**
     * Jetzt prüfen wir, ob an allen Wasserleitungen korrekte Punkte hängen
     */
    new Factory ReaderFactory
       name = "PunktArtPrüfer"
       spec = "prüft, ob an den Wasserleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = $was_ltg
       end
       filter = new Filter ArtFilter
          mode = not
          range = 460-469
          range = 2300-2349
          range = 2400-2449
       end
       function = @Log(WARNING, &in, @Concat("Punktart ", @Get(&in, art)" ist an Trinkwasserleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Trinkwasserleitungen gefunden")
    end


    $labels_was = new Map LongMap
       entry = 465, W
       entry = 466, W
       entry = 467, W
       entry = 468, MKW
       entry = 469, W
    end

    new Factory LabelReader
       name = "BeschriftungsTextTester Ebene 23-24"
       spec = "Prüft auf korrekte Beschriftung"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = pk
          end
          filter = new Filter ArtFilter
             list = 465,466,467,469
          end
       end
       function = @If(@And(@Equals(@Get(&label, art450, @Not(@Equals(@Get(&label, allText), @Map($labels_was, @Get(&in, art))))) , \
                      @Log(ERROR, &in, @Concat("Ungültiger Beschriftungsinhalt '", @Get(&label, allText)"' Soll: '", @Map($labels_was, @Get(&in, art))"'")))
       finally  = @Log("&count Beschriftungen getestet")
    end


    /**************************************************************************
     *                                                                        *
     * Fachschale GAS                                                         *
     *                                                                        *
     **************************************************************************/

    /*
     * Zuerst prüfen wir, ob noch alte Linienarten existieren
     */
    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft auf veraltete Linienarten"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = li
          end
          filter = new Filter ArtFilter
             range = 2500-2503
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Linienart ", @Get(&in, art)" ist nicht mehr zu verwenden. Umstellen auf die Arten 2510-2519"))
       finally  = @Log("&count veraltete Arten von Gasleitungen gefunden")
    end
    /**
     * Folgender Filter enthält alle Gasleitungen
     */
    $gas_ltg = new Filter ArtFilter
       range = 2500-2520
    end
    /**
     * Jetzt prüfen wir, ob an allen Gasleitungen korrekte Punkte hängen
     */
    new Factory ReaderFactory
       name = "PunktArtPrüfer"
       spec = "prüft, ob an den Gasleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = $gas_ltg
       end
       filter = new Filter ArtFilter
          mode = not
          range = 470-479
          range = 2500-2549
       end
       function = @Log(WARNING, &in, @Concat("Punktart ", @Get(&in, art)" ist an Gasleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Gasleitungen gefunden")
    end

    $labels_gas = new Map LongMap
       entry = 470, KS
       entry = 471, AT
       entry = 472, R
       entry = 473, G
       entry = 475, G
       entry = 476, G
       entry = 477, G
       entry = 478, MKG
       entry = 479, G
    end

    new Factory LabelReader
       name = "BeschriftungsTextTester Ebene 25"
       spec = "Prüft auf korrekte Beschriftung"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = pk
          end
          filter = new Filter ArtFilter
             list = 470,471,472,473,475,476,477,478,479
          end
       end
       function = @If(@And(@Equals(@Get(&label, art450, @Not(@Equals(@Get(&label, allText), @Map($labels_gas, @Get(&in, art))))) , \
                      @Log(ERROR, &in, @Concat("Ungültiger Beschriftungsinhalt '", @Get(&label, allText)"' Soll: '", @Map($labels_gas, @Get(&in, art))"'")))
       finally  = @Log("&count Beschriftungen getestet")
    end

    /**************************************************************************
     *                                                                        *
     * Fachschale FERNWÄRME                                                   *
     *                                                                        *
     **************************************************************************/

    /*
     * Zuerst prüfen wir, ob noch alte Linienarten existieren
     */
    new Factory ReaderFactory
       name = "LinenArtPrüfer"
       spec = "prüft auf veraltete Linienarten"
       filter = new Filter MultiFilter
          mode  = and
          filter = new Filter ElementIdFilter
             id = li
          end
          filter = new Filter ArtFilter
             range = 2800-2803
             range = 2900-2903
          end
       end
       function = @Log(WARNING, &in, @Concat("Die Linienart ", @Get(&in, art)" ist nicht mehr zu verwenden. Umstellen auf die Arten 2850-2889 bzw. 2951-2989"))
       finally  = @Log("&count veraltete Arten von Fernwärmeleitungen gefunden")
    end
    /**
     * Der folgende Filter enthält alle Linien der Fachschale Fernwärme
     */
    $fw_ltg = new Filter ArtFilter
       range = 2800-2889    //Schutzrohr, Schutzbauwerk, Leitungen E28
       range = 2900-2989    //Schutzrohr, Schutzbauwerk, Leitungen E29
    end

    /**
     * Jetzt prüfen wir, ob an allen Gasleitungen korrekte Punkte hängen
     */
    new Factory ReaderFactory
       name = "PunktArtPrüfer"
       spec = "prüft, ob an den Fernwärmeleitungen korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = $fw_ltg
       end
       filter = new Filter ArtFilter
          mode = not
          range = 480-489
          range = 2800-2849
          range = 2900-2949
       end
       function = @Log(WARNING, &in, @Concat("Punktart ", @Get(&in, art)" ist an Fernwärmeleitungen nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Fernwärmeleitungen gefunden")
    end


    $labels_fw = new Map LongMap
       entry = 484, FP
       entry = 485, H
       entry = 487, H
       entry = 488, MKH
       entry = 489, H
    end

    new Factory LabelReader
       name = "BeschriftungsTextTester Ebene 28-29"
       spec = "Prüft auf korrekte Beschriftung"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = pk
          end
          filter = new Filter ArtFilter
             list = 484,485,487,488,489
          end
       end
       function = @If(@And(@Equals(@Get(&label, art450, @Not(@Equals(@Get(&label, allText), @Map($labels_fw, @Get(&in, art))))) , \
                      @Log(ERROR, &in, @Concat("Ungültiger Beschriftungsinhalt '", @Get(&label, allText)"' Soll: '", @Map($labels_fw, @Get(&in, art))"'")))
       finally  = @Log("&count Beschriftungen getestet")
    end


    /**************************************************************************
     *                                                                        *
     * Fachschale BELEUCHTUNG                                                 *
     *                                                                        *
     **************************************************************************/
    /**
     * Dieser Filter enthält die Beleuchtungskabek
     */
    $bel_ltg = new Filter ArtFilter
       range = 3100-3109
    end

    /**
     * Jetzt prüfen wir, ob an allen Beleuchtungskabeln korrekte Punkte hängen
     */
    new Factory ReaderFactory
       name = "PunktArtPrüfer"
       spec = "prüft, ob an den Beleuchtungskabeln korrekte Punkte anhängen"
       grabber = new Grabber LinePointGrabber
          filter = $bel_ltg
       end
       filter = new Filter ArtFilter
          mode = not
          range = 407-418
          list  = 437,438,444
          list  = 490,493,495
          range = 3100-3149
       end
       function = @Log(WARNING, &in, @Concat("Punktart ", @Get(&in, art)" ist an Beleuchtungskabeln nicht erlaubt"))
       finally  = @Log("&count fehlerhafte Punkte an Beleuchtungskabeln gefunden")
    end



    /**************************************************************************
     *                                                                        *
     * Sonstiges                                                              *
     *                                                                        *
     **************************************************************************/

    //hier ist eigentlich nichts mehr notwendig

    Beispiel 2

    Dieses Skript wurde für die Bearbeitung von DIBOS-Projekten entwickelt. Einige der hier dargestellten Factories sind nicht in der Freeware-Version enthalten.

    /*
     * Einstellungen des GGManipulators
     * zur Prüfung und Bearbeitung von DIBOS-Digitalisierungen
     * die Grafout-Datei wird mit den Oskas der Geograf-Artendatei erwartet.
     */

    //Zuerst Globale Einstellungen
    DETAIL_MESSAGES = true
    ERROR_FILE = new File GGStapelFile
       name = fehler.stp
    end

    /**
     * Es folgen einige Variablen,
     * die in späteren Factorys benutzt werden
     * Wir nehmen die Einstellungen hier oben ein,
     * damit man sich nicht tot sucht
     */
    $maxTextDist = 3.0
    $maxLinePointDistance = 1.0
    $maxLineLength = 1.0
    $textLineHight = 5.0


    /**
     * Übertragung der Ackerschätzung
     */
    new Factory DibosFieldTextParser
       name = "AckerschätzungsFilter"
       spec = "Testet die Beschriftungstexte und erzeugt aus ihnen formatierte Texte, die bei der EDBS-Umsetzung übertragen werden"
       //der Grabber greift alle Elemente aus den Objekten 222,1222
       grabber = new Grabber ObjectContentGrabber
          filter = new Filter ArtFilter
             list = 22212223222
          end
       end
       //folgende Parameter prüfen die Differenz zwischen Bodenwert- und Ackerzahl
       //es gibt hier keine Vorgaben, diese Werte sind pauschal eingestellt
       //sollte es zu Fehlermeldungen bei korrekten Werten kommmen, sind die Grenzen höher zu setzen
       ltDiff   = 4          //soviel darf die Ackerzahl kleiner sein, als die Bodenwertzahl            >> ansonsten kommt eine Fehlermeldung
       gtDiff   = 4          //es kommt kaum vor, dass die Ackerzahl größer ist, als die Bodenwertzahl  >> daher kommt immer eine Fehlermeldung
       fullName = false      //das volle Schätzungsergebnis soll angezeigt werden
       delim    = "_"       //Zeichen, die im Objekttext als Trennzeichen erkannt werden
       extensions   = "Wa gt",Wa+,Wa-,RiWa,Str,Hu,A-Hack //erlaubte Zusätze, diese Zusatzinformationen schalten die Bereichsprüfung der Ackerzahl aus
       replacements = U,Hei,Mo  //Diese Texte ersetzen den vollständigen Objektnamen, es sind keine Schätzungsergebnisse zu erfassen
       //Dem erzeugten PlotText geben wir eine Art, Ebene und TextPosition
       function = @Set(&text, art, 9900, ebene, 142, pos, 1)
    end


    /**
     * Übertragung der Grünlandschätzung
     */
    new Factory DibosGrazeTextParser
       name = "GrünlandschätzungsFilter"
       spec = "Testet die Beschriftungstexte und erzeugt aus ihnen formatierte Texte, die bei der EDBS-Umsetzung übertragen werden"
       //alles analog zur vorstehenden Factory
       grabber = new Grabber ObjectContentGrabber
          filter = new Filter ArtFilter
             list = 122322233223
          end
       end
       //alles analog zum DibosFieldTextParser
       ltDiff   = 4
       gtDiff   = 4
       fullName = false
       delim    = "_"
       extensions = Str,GrStr,W,GrW,Hu,GrHu,Gr-Hack
       replacements = U,Hei,Mo
       function = @Set(&text, art, 9910, ebene, 142, pos, 1)
    end

    /**
     * Die Objektkoordinate von 3-Zeiligen Schätzungstexten liegt im GIAP
     * an der Unterkante der zweiten Zeile
     * In Geograf landen die Objektkkordinaten immer Unterkante der dritten Zeile
     * Also schieben wir in diesem Fall das Objekt samt etwas nach Norden
     */
    new Factory ReaderFactory
       name = "ObjektMover"
       spec = "Schiebt die Objektkkordinaten auf Unterkante der zweiten Zeile"
       //Der Grabber holt alle Elemente aus den Objekten
       grabber = new Grabber ObjectContentGrabber
          name = oGrabber
          filter = new Filter MultiFilter
             mode = and
             filter = new Filter EbeneFilter
                list = 42
             end
             filter = new Filter ArtFilter
                list = 22212223222122322233223
             end
          end
       end
       //bei allen Dreizeilern reagieren wir
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter ArtFilter
             list = 9902,9904,9905,9906,9907,9912,9914,9915,9916,9917
          end
       end
       function = @Store(&hasBezug, @Not(@And(@Equals(@Get(&in, x), @Get(&in, xBez)), @Equals(@Get(&in, y), @Get(&in, yBez)))))
       function = @If(&hasBezug, @Set(&in, y, @Add(@Get(&in, y), $textLineHight)))
       function = @If(@Not(&hasBezug), \
                       @Set(&oGrabber_in, y, @Add(@Get(&oGrabber_in, y), $textLineHight)), \
                       @Set(&in, y,    @Add(@Get(&in, y   ), $textLineHight)), \
                       @Set(&in, yBez, @Add(@Get(&in, yBez), $textLineHight)))
       function = @Log(@Concat("Dreizeiligen Objekttext '", @Get(&in, allText)"' verschoben."))
    end


    /**
     * Testet die Linien auf korrekte Arten
     */
    new Factory DibosLineTester
       name = "SchätzungsgrenzenTester"
       spec = "Testet Schätzungsgrenzen auf korrekte Vergabe der Linienarten"
       //ein Filter für die Flächenobjekte
       filter = new Filter ArtFilter
          list = 222,2223,1222,1223,3222,3223
       end
       //Filter für die formatierten Schätzungsergebnisse
       textFilter = new Filter ArtFilter
          range = 9901-9919
       end
       //die Arten für die Abgrenzungen der Flächen
       flaechenGrenze  = 2231
       abschnittGrenze = 2232
       sonderGrenze    = 2233
    end

    /**
     * Wir erzeugen uns ein Filter,
     * der alle Schätzungsflächenobjekte enthält
     */
    $flaecheFilter = \
       new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             list = oo, oox
          end
          filter = new Filter ArtFilter
             list = 222,1222,3222,2223,1223,3223
          end
       end

    /**
     * Jetzt erzeugen wir eine Element-HashListe.
     * Sie wird alle Linien enthalten, die in SchätzungsflächenObjekte
     * enthalten sind.
     */
    $schaetzungsObjectElemente = \
       new List ElementList
       end
    /**
     * Jetzt fügen wir alle SchätzungsflächenLinien
     * und alle Texte der Folie 42 in diese HashListe ein
     */
    new Factory ReaderFactory
       name = "ObjektElementSaver"
       spec = "Grabbt alle Elemente, die in Folie42-Objekten enthalten sind"
       //Der Grabber holt alle Elemente aus den Objekten
       grabber = new Grabber ObjectContentGrabber
          filter = new Filter MultiFilter
             mode = and
             //alle Objekte der Folie 42
             filter = new Filter EbeneFilter
                list = 42
             end
             //Beschriftungen werden ausgeschlossen
             filter = new Filter ArtFilter
                mode = not
                list = 9999
             end
          end
       end
       //Diese fügen wir nun in die HashListe ein
       function = @Put($schaetzungsObjectElemente, &in)
    end

    /**
     * Nun durchlaufen wir nochmals alle Linien
     * und schauen, ob Sie in einem Schätzungsflächenobjekt enthalten waren
     */
    new Factory ReaderFactory
       name = "FreieElementeTester"
       spec = "Testet auf Folie42-Elemente, die in keinem Objekt enthalten sind"
       filter = new Filter MultiFilter
          mode = and
          //Linien und Texte
          filter = new Filter ElementIdFilter
             id = li, te
          end
          //auf Folie 42
          filter = new Filter EbeneFilter
             list = 42
          end
       end
       //Ein Zähler wird initialisiert
       initiate = @Store(&countErrors, 0)
       //Erzeugt eine Fehlermeldung, wenn eine freie Linie gefunden wird
       function = @If(@Not(@Contains($schaetzungsObjectElemente, &in)), @Log(ERROR, &in, "Element &in ist in keinem Schätzungsobjekt enthalten"), \
                                                                        @Store(&countErrors, @L(@Add(&countErrors, 1))))
       //Schlussmeldungen
       finally  = @Log("&count Elemente getestet")
       finally  = @Log("&countErrors freie Elemente gefunden")
       //Löschen des Listeninhalts um Speicher zu sparen
       finally  = @Flush($schaetzungsObjectElemente)
    end

    /**
     * Jetzt prüfen wir die Linien, ob sie an Zwischenpunkten aufgesplittet sind
     */
    new Factory LinePointDistanceCalculator
       name = "LinienDistanceTester"
       spec = "Testet alle Linien der Folie 42 auf nahe Punkte, die eventuell Brechpunkt der Linie sein sollen"
       //Alle Linien der Folie 42 werden untersucht
       filter = new Filter EbeneFilter
          list =  42
       end
       //Es werden alle Punkte untersucht, hier kann die Suche eingegrenzt werden
       //Wir grenzen hier die Auswahl auch ein, damit nicht alle Symbole u.a. als Fehler gemeldet werden
       points = new Filter MultiFilter
          mode = and
          filter = new Filter EbeneFilter
             list = 1,2,3,21,52,85   //usw.
          end
          filter = new Filter ArtFilter
             list = 0,118,119,5118,5119 //usw.
          end
       end
       //Maximaler Abstand, für alle Punkte kleineren Abstands werden die Funktionen angestoßen
       maxDistance = $maxLinePointDistance  //wir nehmen die oben gemachte Einstellung
       //Fehlermeldung, wenn Distance kleiner
       function = @Log(WARNING, &distancePoint, @Concat("Punkt nahe einer Schätzungsgrenze, Linie teilen, Abstand: ", @Format("#0.000", &distance)))
       //Schlussmeldungen
       finally  = @Log("&count Linien untersucht, &dCount liniennahe Punkte gefunden")
    end

    /**
     * Jetzt prüfen wir auf zu kurze Linien
     */
    new Factory LineLengthCalculator
       name = "LinienLängenPrüfer"
       spec = "prüft auf zu kurze Linien"
       //Alle Linien der Folie 42 werden untersucht
       filter = new Filter EbeneFilter
          list =  42
       end
       //Maximaler Länge, für Linien kürzerer Länge werden die Funktionen angestoßen
       maxLength = $maxLineLength  //wir nehmen die oben gemachte Einstellung
       function = @Log(WARNING, &in, @Concat("kurze Linie: L=", @Format("#0.000", &length)))
       finally  = @Log("&count Linien untersucht, &lCount kritische Linien gefunden")
    end

    /**
     * Die folgende Factory rundet die Objektkoordinaten der Schätzflächen
     */
    new Factory ReaderFactory
       name = "SchätzflächenRunder"
       spec = "Rundet die ObjektKoordinaten der Schätzflächen"
       //Filter der Schätzungsflächen
       filter = $flaecheFilter
       //Objektkoorinaten runden
       function = @Set(&in, y, @Round(@Get(&in, y)1), x, @Round(@Get(&in, x)1))
       //Schlussmeldungen
       finally  = @Log("&count Objektkoordinaten gerundet")
    end

    /**
     * Dann werden auch die dazugehörigen Texte gerundet
     */
    new Factory ReaderFactory
       name = "SchätzTextRunder"
       spec = "Rundet die TextKoordinaten der Schätzflächen"
       //Filter der Schätzungsflächen
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             range = 42 9901-9919
          end
       end
       //Objektkoorinaten runden
       function = @Set(&in, y, @Round(@Get(&in, y)1), x, @Round(@Get(&in, x)1), yBez, @Round(@Get(&in, yBez)1), xBez, @Round(@Get(&in, xBez)1))
       //Schlussmeldungen
       finally  = @Log("&count Objektkoordinaten gerundet")
    end

    /**
     * Dann werden die Koordinaten der Schätzungsangaben auf die
     * Objektkoordinate gesetzt.
     * Dabei wird auf eine maximale Distanz getestet,
     * so dass nicht falsch zugeordnete Texte auf einem
     * falschen Objekt landen
     */
    new Factory ReaderFactory
       name = "SchätzungsTextRunder"
       spec = "Schiebt die Texte auf die Objektkoordinate, dabei wird der Abstand Text-Objekt getetstet, damit nichts schiefgeht"
       // Der ObjectContentGrabber holt die InhaltsElemente aus einem Objekt
       grabber = new Grabber ObjectContentGrabber
          // Dieser Filter lässt nur Elemente aus den Schätzungsflächen durch
          filter = $flaecheFilter
       end
       // Dieser Filter lässt nur Texte aus dem Objektinhalt durch
       filter = new Filter ElementIdFilter
          id = te
       end
       //auf diese Texte werden jetzt die Funktionen angewendet
       //zuerst wird die Strecke zwischen Text- und Objektkoordinate berechnet
       function = @Store(&textDist, @Distance(@Get(&ObjectContentGrabber_in, y), @Get(&ObjectContentGrabber_in, x), @Get(&in, y), @Get(&in, x)))
       //Jetzt werden die Textkoordinaten auf das Objekt verschoben
       function = @If(@And(@Lt(&textDist, $maxTextDist), @Gt(&textDist, 0.001)), @Set(&in, y, @Get(&ObjectContentGrabber_in, y), yBez, @Get(&ObjectContentGrabber_in, y), x, @Get(&ObjectContentGrabber_in, x), xBez, @Get(&ObjectContentGrabber_in, x)), \
          @Log(WARNING, &in, "Textkoordinate ungleich Objektkoordinate, Text wurde auf das Objekt verschoben &textDist"))
       //Schlussmeldungen
       finally  = @Log("&count Textkoordinaten auf die Objekte geschoben")
    end

    /**
     * Jetzt setzen wir die Textwinkel aller Texte auf der Folie 42 auf 100gon
     */
    new Factory ReaderFactory
       name = "Textorientierer"
       spec = "Setzt alle Texte auf den TextWinkel 100gon"
       //alle Texte der Folie 42
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneFilter
             list = 42
          end
       end
       //erhalten den Textwinkel 100
       function = @Set(&in, angle, 100.)
       //Schlussmeldungen
       finally  = @Log("&count Textewinkel gesetzt")
    end

    //Eine HashList mit den Grablochnamen
    $grablochNamen = new List StringList
    end

    /**
     * Es sollen alle Grablöcher auf doppelte Objektnamen untersucht werden
     * Dazu wird die Stringlist $grablochNamen benutzt, um doppelte Namen zu finden
     */
    new Factory ObjectTester
       name = "ObjektNamenTester"
       spec = "Testet die Grablöcher auf doppelte Objektnamen"
       //Alle Grablöcher der Folie 42
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter EbeneFilter
             list = 42
          end
          filter = new Filter ArtFilter
             list = 225226227228264265
          end
       end
       //Wenn der Objektname eines Grablochs schon in der Liste enthalten ist, wird eine Fehlermeldung ausgegeben
       function = @If(@Contains($grablochNamen, &fullName), @Log(ERROR, &in, "Grablochname &fullName ist mehrfach vorhanden"))
       //Der Grablochname wird in die Liste übergeben
       function = @PutValue($grablochNamen, &fullName)
       //Schlussmeldung
       finally  = @Log("&count Grablöcher getestet")
    end

    /**
     * Ebenso werden die viruellen Grablöcher getestet
     */
    new Factory ObjectTester
       name = "ObjektNamenTester"
       spec = "Testet die virtuellen Grablöcher auf doppelte Objektnamen"
       //Alle Grablöcher der Folie 42
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter EbeneFilter
             list = 42
          end
          filter = new Filter ArtFilter
             list = 9225,9226,9227,9228,9264,9265
          end
       end
       //Wenn der Objektname eines Grablochs schon in der Liste enthalten ist, wird eine Fehlermeldung ausgegeben
       function = @If(@Not(@Contains($grablochNamen, &fullName)), @Log(ERROR, &in, "virtuelles Grabloch &fullName fehlt das zugehörige Original"))
       //Schlussmeldung
       finally  = @Log("&count virtuelle Grablöcher getestet")
       //Löschen des Listeninhalts, um Speicher zu sparen
       finally  = @Flush($grablochNamen)
    end

    /**
     * Es werden alle Objekte untersucht, ob sie das korrekte Oberobjekt zugeordnet haben
     */
    new Factory ObjectHierarchyTester
       name = "OberObjektTester"
       spec = "Testet die Grablöcher auf korrekte Oberobjekte"
       //alle Grablöcher werden getestet
       filter = new Filter ArtFilter
          list = 225226227228264265
       end
       //Oberobjekt muss Tagesabschnitt sein
       require = new Filter ArtFilter
          list = 263
       end
    end
    new Factory ObjectHierarchyTester
       name = "OberObjektTester"
       spec = "Testet die Nebenflächen auf korrekte Oberobjekte"
       //alle Grablöcher werden getestet
       filter = new Filter ArtFilter
          list = 1222
       end
       //Oberobjekt muss Hauptfläche sein
       require = new Filter ArtFilter
          list = 222
       end
    end
    new Factory ObjectHierarchyTester
       name = "OberObjektTester"
       spec = "Testet die Nebenflächen auf korrekte Oberobjekte"
       //alle Grablöcher werden getestet
       filter = new Filter ArtFilter
          list = 1223
       end
       //Oberobjekt muss Hauptfläche sein
       require = new Filter ArtFilter
          list = 2223
       end
    end


    /**
     * Es folgen mehrere Filter für die Prüfung des Objektinhalts
     */
    //Filter für Objektinhalte des bestimmenden Grablochs
    $bGrablochNr = new Filter MultiFilter
          name = grablochNr
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             range = 42 264
          end
       end
    $bGrablochWert = new Filter MultiFilter
          name = grablochWert
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             range = 42 1264
          end
       end
    //Filter für Objektinhalte des unbestimmenden Grablochs
    $uGrablochNr = new Filter MultiFilter
          name = grablochNr
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             range = 42 265
          end
       end
    $uGrablochWert = new Filter MultiFilter
          name = grablochWert
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             range = 42 1265
          end
       end
    //Filter für Objektinhalte des Musterstücks
    $mGrablochNr = new Filter MultiFilter
          name = grablochNr
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 1225
             range = 42 1226
          end
       end
    $mGrablochWert = new Filter MultiFilter
          name = grablochWert
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 2225
             range = 42 2226
          end
       end
    $mGrablochKennung = new Filter MultiFilter
          name = grablochKenn
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 225
             range = 42 226
          end
       end
    //Filter für Objektinhalte des Vergleichsstücks
    $vGrablochNr = new Filter MultiFilter
          name = grablochNr
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 1228
             range = 42 1227
          end
       end
    $vGrablochWert = new Filter MultiFilter
          name = grablochWert
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 2228
             range = 42 2227
          end
       end
    $vGrablochKennung = new Filter MultiFilter
          name = grablochKenn
          mode = and
          filter = new Filter ElementIdFilter
             id = te
          end
          filter = new Filter EbeneArtFilter
             mode = or
             range = 42 228
             range = 42 227
          end
       end

    /**
     * Jetzt prüfen wir den Objektinhalt der bestimmenden Grablöcher
     */
    new Factory ObjectContentTester
       name = "Grablochprüfer"
       spec = "Prüft die bestimmenden Grablöcher auf Vorhandensein der Pflichtausgestaltung"
       filter = new Filter ArtFilter
          list = 264
       end
       //die Pflichtelemente, diese Elemente MÜSSEN im Objekt mindestens einmal enthalten sein, ansonsten gibt es eine Fehlermeldung
       require = $bGrablochNr
       require = $bGrablochWert
       //jetzt könnten noch optionale Elemente angegeben werden, diese KÖNNEN Inhalt des Objektes sein
       //optional = irgentein Filter
       //alle anderen Elemente, die nicht in einen 'require'- bzw. 'optional'-Filter passen, werden als ungültiger Objektinhalt mit einer Fehlermeldung belegt
       //
       //der ObjectContentTester gibt unter dem Namen des Filters die Anzahl der den Filter erfüllenden Elemente zurück
       //in &grablochNr steht also die Anzahl der Grablochnummern
       //bei den DIBOS-Objekten darf jeder Text nur einmal auftreten
       function = @If(@Not(@Equals(&grablochNr.count   , 1)), @Log(ERROR, &in, "Nur eine Grablochnummer ist pro Objekt zulässig, Anzahl: &grablochNr.count"))
       function = @If(@Not(@Equals(&grablochWert.count , 1)), @Log(ERROR, &in, "Nur eine Wertzahl ist pro Objekt zulässig, Anzahl: &grablochWert.count"))
       //Prüft die Länge des Objektnamens
       function = @If(@Lt(@Length(&fullName)8), @Log(ERROR, &in, "Objektname &fullName zu kurz"))
       //Die ersten 7 Zeichen des Objektnamens müssen numerisch sein (Gemeindeschlüssel)
       function = @If(@Not(@IsNumber(@Substring(&fullName, 07))),     @Log(ERROR, &in, @Concat("Gemeindeschlüssel ", @Substring(&fullName, 07)" nicht numerisch")))
       //Das Zeichen 7 im Objektnamen ist ein 'T'
       function = @If(@Not(@Equals(@Substring(&fullName, 78"T")), @Log(ERROR, &in, "Fehler im Objektnamen &fullName 'T' fehlt"))
       //Schlussmeldung
       finally  = @Log("&count bestimmende Grablöcher getestet")
    end
    /**
     * Jetzt prüfen wir den Objektinhalt der unbestimmenden Grablöcher
     */
    new Factory ObjectContentTester
       name = "Grablochprüfer"
       spec = "Prüft die nicht bestimmenden Grablöcher auf Vorhandensein der Pflichtausgestaltung"
       filter = new Filter ArtFilter
          list = 265
       end
       require = $uGrablochNr
       require = $uGrablochWert
       function = @If(@Not(@Equals(&grablochNr.count   , 1)), @Log(ERROR, &in, "Nur eine Grablochnummer ist pro Objekt zulässig, Anzahl: &grablochNr.count"))
       function = @If(@Not(@Equals(&grablochWert.count , 1)), @Log(ERROR, &in, "Nur eine Wertzahl ist pro Objekt zulässig, Anzahl: &grablochWert.count"))
       function = @If(@Lt(@Length(&fullName)8), @Log(ERROR, &in, "Objektname &fullName zu kurz"))
       function = @If(@Not(@IsNumber(@Substring(&fullName, 07))),     @Log(ERROR, &in, @Concat("Gemeindeschlüssel ", @Substring(&fullName, 07)" nicht numerisch")))
       function = @If(@Not(@Equals(@Substring(&fullName, 78"T")), @Log(ERROR, &in, "Fehler im Objektnamen &fullName 'T' fehlt"))
       finally  = @Log("&count unbestimmende Grablöcher getestet")
    end
    /**
     * Jetzt prüfen wir den Objektinhalt der Musterstücke
     */
    new Factory ObjectContentTester
       name = "Musterstückprüfer"
       spec = "Prüft die Musterstücke auf Vorhandensein der Pflichtausgestaltung"
       filter = new Filter ArtFilter
          //Musterstück bestimmend und unbestimmend
          list = 225226
       end
       require = $mGrablochNr
       require = $mGrablochWert
       require = $mGrablochKennung
       function = @If(@Not(@Equals(&grablochNr.count   , 1)), @Log(ERROR, &in, "Nur eine Grablochnummer ist pro Objekt zulässig, Anzahl: &grablochNr.count"))
       function = @If(@Not(@Equals(&grablochWert.count , 1)), @Log(ERROR, &in, "Nur eine Wertzahl ist pro Objekt zulässig, Anzahl: &grablochWert.count"))
       function = @If(@Not(@Equals(&grablochKenn.count , 1)), @Log(ERROR, &in, "Nur eine Kennung ist pro Objekt zulässig, Anzahl: &grablochKenn.count"))
       function = @If(@Lt(@Length(&fullName)8), @Log(ERROR, &in, "Objektname &fullName zu kurz"))
       function = @If(@Not(@IsNumber(@Substring(&fullName, 07))),     @Log(ERROR, &in, @Concat("Gemeindeschlüssel ", @Substring(&fullName, 07)" nicht numerisch")))
       function = @If(@Not(@Equals(@Substring(&fullName, 78"T")), @Log(ERROR, &in, "Fehler im Objektnamen &fullName 'T' fehlt"))
       finally  = @Log("&count Musterstücke getestet")
    end

    /**
     * Jetzt prüfen wir den Objektinhalt der Vergleichsstücke
     */
    new Factory ObjectContentTester
       name = "VergleichsstückPrüfer"
       spec = "Prüft die Vergleichsstücke auf Vorhandensein der Pflichtausgestaltung"
       filter = new Filter ArtFilter
          //Vergleichstückstück bestimmend und unbestimmend
          list = 227228
       end
       require = $vGrablochNr
       require = $vGrablochWert
       require = $vGrablochKennung
       function = @If(@Not(@Equals(&grablochNr.count   , 1)), @Log(ERROR, &in, "Nur eine Grablochnummer ist pro Objekt zulässig, Anzahl: &grablochNr.count"))
       function = @If(@Not(@Equals(&grablochWert.count , 1)), @Log(ERROR, &in, "Nur eine Wertzahl ist pro Objekt zulässig, Anzahl: &grablochWert.count"))
       function = @If(@Not(@Equals(&grablochKenn.count , 1)), @Log(ERROR, &in, "Nur eine Kennung ist pro Objekt zulässig, Anzahl: &grablochKenn.count"))
       function = @If(@Lt(@Length(&fullName)8), @Log(ERROR, &in, "Objektname &fullName zu kurz"))
       function = @If(@Not(@IsNumber(@Substring(&fullName, 07))),     @Log(ERROR, &in, @Concat("Gemeindeschlüssel ", @Substring(&fullName, 07)" nicht numerisch")))
       function = @If(@Not(@Equals(@Substring(&fullName, 78"T")), @Log(ERROR, &in, "Fehler im Objektnamen &fullName 'T' fehlt"))
       finally  = @Log("&count Vergleichsstücke getestet")
    end

    $nrFilter = new Filter ArtFilter
       list = 12251227264265
    end

    $wertFilter = new Filter ArtFilter
       list = 2225222712641265
    end

    $grablochArtFilter = new Filter ArtFilter
       list = 225226227228264265
    end

    /**
     * Jetzt überprüfen wir die Angaben des Objektnamens mit den Beschriftungstexten
     */
    new Factory ObjectElementTester
       name = "ObjektInhaltsprüfer"
       spec = "Prüft jedes Beschriftungselement der Grablöcher, ob es mit den Angaben im Objektnamen übereinstimmt"
       //alle Grablöcher-Objekte werden getestet
       filter = $grablochArtFilter
       //Prüfung, ob die Beschriftung 'römische Tagesabschnittsnummer' mit dem Objektnamen übereinstimmt
       function = @If(@And(@Contains($nrFilter, &elem), @Not(@Equals(@RomanToNumber(@Token(@Get(&elem, "allText")" "1)) ,   @L(@Substring(&fullName, 810))))),               \
                     @Log(ERROR, &elem, @Concat("Tagesabschnittsnummer '", @Token(@Get(&elem, "allText")" "1)" = " , @RomanToNumber(@Token(@Get(&elem, "allText")" "1)), \
                     "' stimmt nicht mit der Tagesabschnittsnummer '", @Substring(&fullName, 810)"' in &fullName überein")))
       //Prüfung ob die Beschriftung 'Grablochnummer' mit dem Objektnamen übereinstimmt
       function = @If(@And(@Contains($nrFilter, &elem), @Not(@Equals(@Token(@Get(&elem, "allText")" "2, @Substring(&fullName, 10)))),                      \
                     @Log(ERROR, &elem, @Concat("Grablochnummer '", @Token(@Get(&elem, "allText")" "2), \
                     "' stimmt nicht mit der Nummer '", @Substring(&fullName, 10)"' in &fullName überein")))
       //Prüfung, ob die Vergleichsstückkennung == V
       function = @If(@And(@Contains($vGrablochKennung, &elem), @Not(@Equals(@Get(&elem, "allText")"V"))) , \
                      @Log(ERROR, &elem, "Vergleichsstückkennung != 'V'"))
       //Prüfung, ob die Musterstückkennung == M
       function = @If(@And(@Contains($mGrablochKennung, &elem), @Not(@Equals(@Get(&elem, "allText")"M"))) , \
                      @Log(ERROR, &elem, "Vergleichsstückkennung != 'M'"))
       finally  = @Log("&count AckerGrablöcher getestet")
    end


    /**
     * Beim erzeugen der Grablochobjekte wurden teilweise falsche Punkte gefangen,
     * das testen wir jetzt
     * Dazu werden erst alle Koordinaten der Punkte in einem Hash gespeichert
     */
    $grabloecher = \
       new List StringList
       end

    new Factory ReaderFactory
       name = "GrablochSaver"
       spec = "Speichert die Grablochkoordinaten zwischen"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = pk
          end
          filter = new Filter EbeneFilter
             list = 42
          end
          filter = $grablochArtFilter
       end
       function = @Put($grabloecher, @Concat(@Format("#0.00", @Get(&in, y))"|", @Format("#0.00", @Get(&in, x))))
       finally  = @Log("&count Grablochkoordinaten gespeichert")
    end
    /**
     * Jetzt durchlaufen wir alle Grablochobjekte und schauen, ob eine entsprechende Punktkoordinate vorhanden ist
     */
    new Factory ReaderFactory
       name = "GrablochKooTester"
       spec = "Prüft ob für GrablochObjektkoordinaten eine gleiche GrablochPunktkoordinaten vorkommt"
       filter = new Filter MultiFilter
          mode = and
          filter = new Filter ElementIdFilter
             id = oo,oox
          end
          filter = new Filter EbeneFilter
             list = 42
          end
          filter = $grablochArtFilter
       end
       initiate = @Store(&countErrors, 0)
       function = @If@Not(@Contains($grabloecher, @Concat(@Format("#0.00", @Get(&in, y))"|", @Format("#0.00", @Get(&in, x))))), \
                        @Log(ERROR, &in, "GrablochObjekt hat keinen GrablochPunkt mit gleicher Koordinate"), \
                        @Store(&countErrors, @L(@Add(&countErrors, 1))))
       finally  = @Log("&count Grablochobjekte getestet, &countErrors Objekte ohne zugehöriges Grabloch gefunden")
    end
    GGMan © 2009, Jörg Schröder, WWW: GeoCalc - Softwareentwicklung Jörg Schröder, Mail: info@geocalc.de
    Impressum und Hinweise: Impressum
    weitere Informationen bei: Vermessungsbüro M. Wolf - J. Schröder