Osztályok

Ez a rész az osztály típusú csomópontok szintaxisát és felépítését írja le.

Osztály és metódus

Minden metódus csak osztályon belül adható meg, a hatóköre is erre korlátozódik.

Az osztály példányosítását minden metódus megkapja, elérni a @this kulcsszóval lehet.

Virtuális metódusok

Nincs külön szintaxis hozzárendelve, az std:virtual attribútummal lehet megadni.

Statikus metódusok

A statikus metódusok nem támogatottak, mert nagy részben átfedés van a funkcióval. Viszont meg lehet adni funkciót osztályon belül, ekkor kap egy lokális névtér előtagot (az osztály nevét). Viszont a tárolása és a használata elkülönül az osztálytól.

Öröklés

Osztályoknál és a rá épülő típusoknál többszörös öröklés lehetséges, az alaposztályok külön csomópontok. Példányosításkor a közös adatokat tároló elem jön létre, ezek:

• attribútum

• virtuális metódusok

• tároló referencia

• zárolás

• referenciaszámláló.

Transzformációnál összeolvadás történik, kivéve az osztály típusokat.

Szintaxis

A tag változó kivételével a deklaráció egy kulcsszóval kezdődik.

Blokk jelölések

Csoportokból három féle található, fő blokk, al blokk, és beágyazott blokk. Osztályoknál nem annyira látványos a különbség, viszont transzformációnál és összetettebb elemeknél sokkal nagyobb az elkülönülés.

Minden nagyobb csoport fő blokkot használ. Kapcsos zárójellel kezdődik { és végződik, de kap még egy extra pontosvesszőt };. így jobban elkülönül a programkód blokk és a csoport blokk. Mivel a szintaxis bővíthető és nagyon sok kulcsszó és jelölés található meg eddig is, a szokatlan elemek határai így könnyebben beazonosíthatóak.

Al blokkok programkódnál és felsorolásoknál használatosak. Kapcsos zárójellel kezdődik { és végződik }.

A beágyazott blokk tartalma nincs feldolgozva a határolók között. Általában más nyelvnél hármas jelekkel jelölik, itt a kapcsos idézőjelek kapnak egy százalék előtagot: %{ és %}.

Példa

*class Class {
    *extends BaseClass;

    Data::String member = %{
        Több soros blokk kulcsszó (*class) értelmezés nélkül.
    %};

    *method method (Data::String value) {
        *if (value == "test") {
            System::stdout("Input: %1\n"[value]);
        }
    };
};

Csomópontok

A nyelv apró építőkövei. Az egységes felépítés megvalósításához szinte minden belőlük épül fel. Tartalmazhatnak nyers adatot, más csomópontokat, lehet nevük, vannak egységes meta metódusaik. Ezek a következők lehetnek:

• alap adat lekérdezések: @name, @type

• attribútumok kezelése: @attribAdd(), @attribGet()

• kapcsolat lekérdezés: @object, @parent, @member(), @isObject

• listás lekérdezések: @gamListNode(), @gamListString().

Adatként használva minden csomópont tartalmaz saját nevet, attribútumot, azonosítót, raktár hivatkozást, és referencia számlálót. Ekkor minden csomópont egy objektumnak számít. Példányosított összetett típusoknál több csomópont alkot egy objektumot, ekkor közösen osztoznak a felsorolt tulajdonságokon. Tárolás szempontjából nem ideális, de a keresést és a transzformációt nagyban megkönnyíti.

Attribútumok

Minden csomópont tartalmazhat egyedi attribútumot. Előtag és érték opcionális, utóbbi az alábbi lehet:

• egész (int32)

• lebegőpontos érték

• sztring

• logikai

• csomópont

    [private std:id="myClass"] *class Class1;

Jelenleg az aritmetikai műveletek kivételek, csak csoportos attribútum adható meg:

    [std:mathMode="saturating"] a = b + c;

Osztály jellegű típusok

Jellemzőjük a többszörös öröklés, virtuális metódusok, véglegesített tagváltozók. Típusai:

• általános osztály (Group::Class)

• absztrakt osztály (Group::Representation)

• projekt (System::Project)

• beolvasó (System::Parser)

Absztakt osztály

A normál osztály elemein felül tartalmazhat ontológiai definíciókat, transzformációs és kiegészítő adatokat. Átmeneti változat a futásidejű OO osztály és az ontológiai osztály között. Nem példányosítható közvetlenül, csak OO osztállyá alakítva. DSL elemet is tartalmazhat, amit akár futtatható metódussá lehet transzformálni. A nevében megadható egy megkülönböztető «#» karakter, amivel különbséget lehet tenni az absztrakt és a belőle létrehozott végrehajtható osztály között.

    *representation #Thing {
        *metadata std:memberOf #Group;

        Data::String value;

        *method restoreValue ();
    };

Adathalmaz

A Json-hoz hasonló felépítéssel lehet típust adattal feltölteni (átdolgozásra szorul).

    <<{ [attr] Type;
       member1: value1;
       group: {
           member2: value2;
       }
    }>>