Utils

In diesem Paket werden einige Hilfsmittel zur Verfügung gestellt, die helfen sollen, komplexere Fragestellungen zu lösen.

Eine Collection stellt eine Sammlung von Values dar. Auf sie kann mit den Funktionen @Flush, @HasMore, @Next und @Reset zugegriffen werden.

• @Flush:
Leert eine Liste.

Über den Inhalt einer Collection kann mit den folgenden Funktionen iteriert werden:

• @HasMore:
Zeigt an, ob über einen weiteren Wert verfügt werden kann.
• @Next:
Gibt den nächsten verfügbaren Wert zurück,
• @Reset:
Setzt den Iterator zurück, der nächste Zugriff mit @Next gibt den ersten Wert zurück.

Die Anzahl der in einer Collection enthaltenen Objekte gibt die Function @Size zurück.

Die Utilities List und Map sind eine Collection, beide erfüllen also deren Funktionalität.

Eine Liste nimmt eine Sammlung von Werten auf. Mit der Function @Contains kann abgefragt werden, ob ein Wert in der Liste enthalten ist. So kann z.B. auf einfache Art und Weise eine Sammlung von zulässigen Werten definiert werden, die dann mit einem Funktionsaufruf abgefragt werden kann.

/*
 * zuerst wird eine Liste mit zulässigen Werten definiert
 */
$textList = new List StringList
   list = "Wohnhaus", "Schuppen", "Garage"
end

/*
 * Jetzt wird eine ReaderFactory definiert, die Objekte nach zulässigen Objektnamen überprüft
 */
new Factory ReaderFactory
   filter = new Filter MultiFilter
      filter = new Filter ElementIdFilter
         id = oo, oox
      end
      filter = new Filter ArtFilter
         list = 1001,1002
      end
   end
   function = @If( @Not( @Contains($textList, @Get(&in, name) )), @Log(ERROR, &in, "Objekt hat unzulässigen Objektnamen"))
end

Es gibt mehrere Arten von Listen, die auf einen bestimmten aufzunehmenden Werte-Typ ausgerichtet sind. So sind für jeden Value-Typ vorgesehen:

• BooleanValue: BooleanList
• LongValue: LongList
• DoubleValue: DoubleList
• StringValue: StringList
• ObjectValue: ObjectList
• ObjectValue: ElementList (hier muss das Objekt ein Geograf-Element sein)
• ObjectValue: RegisterList

Die Auswahl der zum Typ passenden Liste ist entscheidend dafür, ob ein Objekt als gleich angesehen wird oder nicht. So wird in eine DoubleList auf die Abfrage @Contains($list, 0.10000) die in der Liste stehende Zahl 0.1 mit wahr beantwortet, da sich beide Fließkommawerte nicht unterscheiden. Mit einer StringList würde die selbe Abfrage mit unwahr beantwortet, da sich die Zeichenketten 0.10000 und 0.1 unterscheiden.

Eine Liste kann auch zur Laufzeit mit Werten aufgefüllt werden. Dem dient die Function @Put.

Eine Sonderstellung nimmt die RegisterList ein. Sie behält kann beliebige Were aufnehmen und behält die Reihenfolge eingegebenen Werte bei. Die Augabe mit der Funktion @Next beginnt mit dem ersten eingegebenen Wert. Suchfunktionen wie @Contains laufen langsamer ab und vergleichen nur die StringValues der enthaltenen Werte. Die RegisterList eignet sich dadurch hauptsächlich zum Registrieren von Protokolldaten.

/*
 * zuerst wird eine leere Liste definiert
 */
$textList = new List StringList
end

/*
 * Jetzt wird eine ReaderFactory definiert, die eine Liste mit den Objektnamen auffüllt
 */
new Factory ReaderFactory
   filter = new Filter MultiFilter
      filter = new Filter ElementIdFilter
         id = oo, oox
      end
      filter = new Filter ArtFilter
         list = 1001,1002
      end
   end
   function = @Put($textList, @Get(&in, name) )
end

Mit der obigen Funktion @Put wird die Liste $textList mit allen Objektnamen der Objekte 1001 und 1002 aufgefüllt. Diese Liste kann dann in einer nächsten Factory zur weiteren Bearbeitung benutzt werden.

Der Inhalt einer Liste kann mit der Funktion @Flush gelöscht werden.

Die folgenden Definition gilt für alle Listen:

BooleanList, LongList, DoubleList, StringList, ObjectList, ElementList, RegisterList

$textList = new List StringList
   list = "Wohnhaus", "Schuppen", "Garage"
end

Eine Map nimmt eine Sammlung von Schlüssel-Wert-Paaren auf. Damit können z.B. Umsetzungstabellen definiert werden.

/*
 * Tabelle der NutzungsartenTexte
 */
$nutz_tab = new Map LongMap
   entry   = 707, "Garten"
   entry   = 708, "Obstbaumanlage"
   entry   = 709, "Obststrauchanlage"
   entry   = 710, "Baumschule"
   entry   = 711, "Wiese"
   default = "unbekannte Nutzung"
end

/*
 * Auf den FlächenSignaturen der Ebene Nutzungsarten wird ein Text erzeugt
 */
new Factory PointToTextCopier
   filter = new Filter ArtFilter
      range = 700-799
   end
   function = @Set(&out, ebene, 7, art, 700, pos, 4, rahmen, 0, frei, 0, text, @Map($nutz_tab, @Get(&in, art)) )
   finally  = @Log("&count Flächenbeschriftungen erzeugt")
end

In dem obigen Beispiel wird eine Tabelle definiert, die jeder Punktart einen Text zuordnet. Die Funktion @Map holt aus der Tabelle mit Hilfe der mit @Get besorgten Punktart den der Art zugeordneten Text.

Im Regelfall wird bei der Map-Definition einem Schlüssel ein fester Wert zugewiesen. Es können aber auch Wertfunktionen zugewiesen werden. Der Wert zum Schlüssel wird dann erst zur Laufzeit erzeugt.

//Die möglichen Dimensionen der Stahlleitungen
$labels_stahl_dims = new List LongList
   list  = 25, 50, 65, 70, 75, 80, 100, 150, 175, 200, 250, 275, 300, 350, 400
end
//Die möglichen Dimensionen der PVC-Leitungen
$labels_pvc_dims   = new List LongList
   list  = 80, 100, 150, 175, 200
end
//Der Materialart werden die möglichen Dimensionen zugeordnet
$labels_mat = new Map StringMap
   entry = "St", @Contains($labels_stahl_dims, &text1)
   entry = "PE", @Contains($labels_pe_dims,    &text1)
end
/*
 * Mit dem LabelReader werden die Beschrifungstexte von Elementen untersucht
 */
new Factory LabelReader
   name = "LinienBeschriftungsTextTester"
   spec = "Prüft die GasLeitungen auf korrekte Beschriftung"
   filter = new Filter MultiFilter
      mode = and
      filter = new Filter ElementIdFilter
         id = li
      end
      filter = new Filter ArtFilter
         range = 2510-2518
      end
   end
   function = @Store(&text, @Get(&label, "allText"))
   function = @Store(&text1, @Token(&text, " ", 1))
   function = @Store(&text2, @Token(&text, " ", 2))
   function = @If(@Not(@Map($labels_mat, &text2)), @Log(ERROR, &label, @Concat("Ungültige Dimension '", &text1, "' für die Materialangabe '", &text2, "'")))
   finally  = @Log("&count Beschriftungen getestet")
end

Wie bei einer List liegt für jeden Schlüssel-Typen eine eige Map vor:

• BooleanValue: BooleanMap
• LongValue: LongMap
• DoubleValue: DoubleMap
• StringValue: StringMap
• ObjectValue: ObjectMap
• ObjectValue: ElementMap (hier muss das Objekt ein Geograf-Element sein)
• Filter: FilterMap

Nur so kann gewährleistet werden, dass die Schlüssel als gleich erkannt werden.

Wie eine List kann auch eine Map zur Laufzeit mit der Funktion @Put mit Schlüssel-Wert-Paaren aufgefüllt werden.

/*
 * zuerst wird eine leere Map definiert
 */
$textMap = new Map StringMap
end

/*
 * Jetzt wird eine ReaderFactory definiert, die eine Map mit dem Objektnamen als Schlüssel und dem Objekt als Wert auffüllt
 */
new Factory ReaderFactory
   filter = new Filter MultiFilter
      filter = new Filter ElementIdFilter
         id = oo, oox
      end
   end
   function = @If( @Contains( @Get(&in, name)), @Log(ERROR, &in, "Objektname schon vorhanden") )
   function = @Put($textMap, @Get(&in, name), &in )
end

In dem Beispiel wird die leere Map mit allen Objektnamen aufgefüllt. Vorher wird mit der Function @Contains überprüft, ob der Name schon in der Map vorhanden ist. Wenn ja, dann liegt der Objektname doppelt in den daten vor, wird eine Fehlermeldung ausgegeben.

Auch bei einer Map kann der Inhalt mit der Funktion @Flush gelöscht werden.

Die folgenden Definition gilt für alle Maps:

BooleanMap, LongMap, DoubleMap, StringMap, ObjectMap, ElementMap

$textMap = new Map LongMap
   entry = 1001, "Wohnhaus"
   entry = 1002, "Schuppen"
   entry = 1003, "Garage"
   default = "unbekanntes Objekt"
end

FilterMap

$filter1 = new Filter ElemFilter(pk:0850:8001) end
$filter2 = new Filter ElemFilter(pk:0850:8002, pk:0850:8003) end
$filter3 = new Filter ElemFilter(pk:0850:8005) end

$textMap = new Map LongMap
   entry = $filter1, "Wohnhaus"
   entry = $filter2, "Schuppen"
   entry = $filter3, "Garage"
   default = "unbekanntes Objekt"
end

Eine Table speichert Datenzeilen. Einer Datenzeile ist jeweils ein eindeutiger Schlüssel zugeordnet. Mit Hilfe des Schlüssels und eines Spaltenindex kann auf die einzelnen Elemente einer Zeile zugegriffen werden.

/*
 * Tabelle der Nutzungsartenkürzel und Langtexte
 */
$nutz_tab = new Table LongTable
   size = 2
   entry   = 707, "G",  "Garten"
   entry   = 708, "OB", "Obstbaumanlage"
   entry   = 709, "OS", "Obststrauchanlage"
   entry   = 710, "BS", "Baumschule"
   entry   = 711, "W",  "Wiese"
end

/*
 * Auf den FlächenSignaturen der Ebene Nutzungsarten wird ein Text erzeugt
 */
new Factory PointToTextCopier
   filter = new Filter ArtFilter
      range = 700-799
   end
   function = @Store(&art, @Get(&in, "art"))
   function = @Store(&newText1, @Tab($nutzTab, &art, 1))
   function = @Store(&newText2, @Tab($nutzTab, &art, 2))
   function = @Store(&newTextAll, @Concat(&newText1, "|", &newText2))
   function = @Set(&out, "ebene", 7, "art", 700, "text", &newTextAll)
   finally  = @Log("&count Flächenbeschriftungen erzeugt")
end

In dem obigen Beispiel wird eine Tabelle mit mehreren Schlüsseln und Datenzeilen definiert. Später kann mit der Funktion @Tab() mit Hilfe des Schlüssels und einer Spaltennummer auf die einzelnen Elemente einer Datenzeile zugegriffen werden.

Tabellen haben eine feste Anzahl von Einträgen (Spalten) pro Zeile. Die Anzahl der Spalten muss beim Anlegen der Tabelle mit dem Parameter size angezeigt werden. Für die Angabe der Spaltenanzahl zählt der Schlüsselwert nicht mit.

Mit Hilfe einer Table kann zum Beispiel eine Artentabelle verwaltet werden, bei der jeder Artennummer mehrere Werte (zB. Symbolnummer, Farbe, Größe) zugeordnet ist.