Queue ist eine Containerklasse, die eine unbestimmte Anzahl an Werten besitzt. Man kann zur Laufzeit Werte einfügen, modifizieren und löschen.
Queues können als Literale durch Eckige Klammern definiert werden. Für die normale Definition können Anfangswerte angegeben werden. Zusatzweise darf man auch Queues nur allein durch Kommata definieren, solange sich die Queue in der ersten Ebene (z.B. nicht in Klammern) einer Anweisung befindet.
x, y, z 'Das Selbe wie [x, y, z]
[11, 4, 8] 'Lieterale Queue mit drei Elementen
my queue[] 'Leere Queue unter der Variable "myQueue"
Man kann auch Variablen als mehrdimensionale Queues definieren. Dies ist durch das ransetzen einer eckigen Klammer bei der Definition möglich. In dieser Klammer werden die Größen jeder Dimension angegeben. Nach der Klammer kann ein Typ mit einer optionalen Sofortdefinition für alle Felder angegeben werden.
field1[5, 2].i '= [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]
field2[5, 2].i(1) '= [[1, 1], [1, 1], [1, 1], [1, 1], [1, 1]]
this:count()
Gibt die Anzahl der Elemente in der Queue zurück. Verschachtelungen von mehreren Queues werden nicht beachtet!
this:first()
Ermittelt den ersten Wert in der Queue. Diese Methode ist wesentlich schneller als "this[0]". Achtung: Bei leeren Listen kann dieser Befehl unerwartete Fehler auslösen.
this:last()
Ermittelt den letzten Wert in der Queue. Diese Methode ist ebenso schneller als "this[this:count - 1]". Achtung: Bei leeren Listen kann dieser Befehl auch unerwartete Fehler auslösen.
this:append(...)
Fügt die angegebenen Werten an das Ende der Queue hinzu. Dabei werden die Werte vorerst kopiert. Für das Hinzufügen von Referenzen siehe nächster Befehl.
number.queue(1, 2)
out number 'Gibt [1, 2] aus
number:append(3, 4)
out number 'Gibt [1, 2, 3, 4] aus
this:appendReference(...), appendRef
Fügt Referenzen der angegebenen Werte an das Ende der Queue ein. Dadurch ist es möglich eine Selektion aus Werten zu bilden, ohne diese zu kopieren.
selection[]
def[x, y, z] = 0
selection:appendReference(x, z)
selection = 1
out x, y, z 'Gibt 1, 0, 1 aus
this:appendValue(class*, ...)
Fügt einen Wert der angegebenen Klasse an das Ende der Queue hinzu. Die nachfolgenden Parameter werden als Parameter für die Sofortdefinition genutzt.
number.queue(1, 2)
number:append value(integer, 3)
out number 'Gibt [1, 2, 3] aus
this:prepend(...)
Fügt die angegebenen Werte an den Anfang der Queue hinzu. Die Werte werden vorerst kopiert.
this:prependReference(...), prependRef
Fügt Referenzen der angegebenen Werte an den Anfang der Queue hinzu.
this:prependValue(class*, ...)
Fügt einen Wert der angegebenen Klasse an den Anfang der Queue hinzu. Die nachfolgenden Parameter werden als Parameter für die Sofortdefinition genutzt.
this:remove(...)
Löscht alle Elemente, die an den angegebenen Positionen stehen.
friend.queue("Max", "Nico", "Nick", "Leo")
friend:remove(1, 2)
out friend 'Gibt [Max, Leo] aus
this:clear()
Löscht alle Elemente aus der Queue. Nach dieser Methode ist die Queue leer und besitzt somit keine Elemente.
this:sum()
Gibt die Summe aller Elemente der Queue zurück. Addiert wird vom ersten Element bis zum Letzten (die Reihenfolge macht bei Strings einen Unterschied).
out [2, 8, 1, 9]:sum 'Gibt 20 aus
out ["Hello", " ", "world!"]:sum 'Gibt "Hello world!" aus
this:average()
Berechnet zurerst die Summe aus allen Elementen wie bei "sum()" und gibt dann den Durchschnitt zurück, indem die Summe durch die Anzahl der Summanden dividiert wird.
out [1, 2, 3, 4]:average 'Gibt 2.5 aus
this:random(), rand
Wählt ein zufälliges Element aus und gibt eine Referenz zu dem Wert des Elements zurück.
number.queue(1, 1, 1)
number:random = 0
out number 'Kann [0, 1, 1], [1, 0, 1] oder [1, 1, 0] ausgeben
this:enum()
Gibt eine neue Liste zurück, mit jeweils enumerierten Elementen. Die Elemente werden als Referenzen in Unterqueues abgespeichert. Nach jeder Referenz folgt der Index.
out ["a", "b", "c"]:enum '= [[a, 0], [b, 1], [c, 2]]
["a", "b", "c"]:enum for[char, index]{
out index << " : " << char
}
this:push()
Kopiert alle Werte der jeweiligen Queue in die aktuelle Parameter-Liste. Dabei werden die neuen Argumente an das Ende der Liste raungefügt. Somit kann zur Laufzeit eine variable Anzahl an Parametern übergeben werden.
display two(a, b){
out "display two called:",
"a = " << a,
"b = " << b
}
[1, 2, 3, 4]:push
display two
display two
this:analyse\min()
Gibt den kleinsten Wert (Minimum) der Liste zurück.
this:analyse\max()
Gibt den größten Wert (Maximum) der Liste zurück.
this:analyse\variations()
Erstellt eine Liste von Variationen, die in der jeweiligen Queue ausgelesen wurden. Dabei wird in dieser Liste für jede Variation eine Referenz und die Anzahl gespeichert.
out ["a", "b", "a", "c", "c", "a"]:analyse\variations
'Die Ausgabe ist [[a, 3], [b, 1], [c, 2]]
this:sort(algorithm = {a < b})
Sortiert eine Liste nach der spezifizierten Bedingung algorithm
. Diese Sortierfunktion arbeitet nach dem sog. Bubblesort.
out [8, 6, 3, 5, 1]:sort '= [1, 3, 5, 6, 8]
out ["d", "a", "c", "b"]:sort({a:ascii < b:ascii}) '= [a, b, c, d]