A TTCN-3 programozási nyelv

Template-ek

A template egy olyan minta amely üzenetek formai és tartalmi alakját határozza meg. Két típusra oszthatjuk, üzenetek fogadására és kiküldésére használatos template-eket különböztethetünk meg. Az üzenet fogadásra használt template az összes elfogadható üzenetet leírja, tartalmazhat például reguláris kifejezéseket. Ezzel szemben az üzenet küldésre használt template csakis konkrét értékeket, valamint omit értékű mezőket tartalmazhat. Az üzenet küldésre használt templatet használhatjuk üzenet fogadásához is. Ezzel szemben ha az üzenet fogadására használt templatet üzenet küldéshez használjuk, futásidejú hibát kapunk.

Template illesztési folyamatakor, a környezet összehasonlítja a kapott üzenetet az előre meghatározott template-el ami leírja az összes érvényes üzenet változatot.

Template az alábbi módon definiálható:

template <típus> <azonosító> [(<formális paraméterlista>)] [modifies <template azonosító>] := <törzs>

A template-ek származtatásakor, a szülő template mezői öröklödnek, igy nem szükséges újradefiniálni öket.

Üzenet illesztése egy template-re az üzenet minden mezőjének illesztését a template megfelelő mezőjére jelenti. Template egy mezőjének illesztése történhet két féle modon. Template mező szinten:

Template mezőértek szinten:
Template típusok
Templatek konkrét értekkel:
template integer Négy := 4; const integer Négy := 4; // a const hatékonysági szempontból jobb a templatenél template SajatRecordTipus KonkretErtek := { mező1 := omit, mező2 := false };
Érték listát és komplemens értéket tartalmazó template:
template charstring AvagyB := ("A", "B"); template SajatRecordTipus KomplemensÉrték := { mező1 := complement (1, 10, 100), mező2 := true };
Értéktartományt tartalmazó template:
template float Pi_kornyezet := (3.14 .. 3.15); template integer rgb_érték := (0 .. 255); template integer nagyobbMintNulla := (1 .. infinity); // elfogadott karakterek az A, B és C template charstring AtolCig := ("A" .. "C");
Értéktartományt és érték lista template kombinációja:
template integer tr_Intermixed := ((0..127), 200, 255); // az összes nagybető karakter elfogadott, illetve a Hello szó template charstring tr_NotThatGood := (("A".."Z"), "Hello");
Bármilyen értéket (?) és az érték nem tartalmazó template (*):

A ? tehát megköveteli, hogy az adott mező tartalmazzon értéket, ám a mező értékére további megkötést nem tartalmaz. Ezzel szemben a * megengedi, hogy a mező értéke omit lehessen (csak optional mező esetén használható).

type record MyMessageType { integer field1 optional, charstring field2, octetstring field3 optional, boolean field4, MyType field5 optional, charstring field6, float field7 optional, charstring field8 } template MyMessageType myTemplate (boolean param) := { field1 := ?,//nem lehet omit, de értéke lényegtelen field2 := (”B”, ”O”, ”Q”), //lista eleme kell legyen field3 := omit, //omit kell legyen field4 := param, field5 := *, // lehet omit, vagy bármi más field6 := complement (”A”, ”L”, ”M”), //lista elemein kívül bármi field7 := (3.14 .. 3.15) ifpresent, field8 := ( (”A” .. ”Z”), ”Hello”) //tetszőleges hosszú nagybetűkből álló szó, vagy ”Hello” } //field1 miatt nem kiküldhető!
Template illesztés
Belső értékek illesztése
// ? használata bitstring tipus esetén // az utolsó 2 bit 0 vagy 1 lehet template bitstring bit := ’101101??’B; // ROI egy record of integer tipus // egy ROI tipusu valtozó tartalmazhat akarmely elemet a 2, 3 sorozat előtt illetve utana. // A 2, 3 elemeket kötelezően meg kell adni a megadott sorrendben template ROI tr_TwoThree := { *, 2, 3, * };
charstring tipusú templatek illesztése - pattern
// bármilyen szöveg megfelel ami a-val kezdődik és // z-vel ért véget template charstring szöveg := pattern "a*z"; // bármelyik 3 hosszú karaktersorozat illeszthető // ami A-val kezdődik és C-vel ér veget template charstring tr_01 := pattern "A?C";
A pattern a következő metakaraktereket tartalmazhat: Példák:
// nagybetűvel kezdődő karakterlánc template charstring tr_1 := pattern "[A-Z]*"; // 3 hosszú karakterláncokat jelöl mint példaul az "Axb" var charstring cs := "?x?"; template charstring tr_2 := pattern "{cg_in}"; // legalább 3, legfeljebb 5 hosszú nagybetűs karakterlánc template charstring tr_4 := pattern ”[A-Z]#(3,5)”;
Speciális template megszorítások:

Érték és template illesztését a

function match(<érték>, <template>) return boolean
függvény végzi. A
valueof(<template>)
függvény egy pontos értékekkel meghatározott template alapján visszaad egy a template típusának megfelelő értéket. szükséges a használata főleg templatek összehasonlitásnál, mivel a templatek nem értékek.
const integer c := 1; // konstans érték template integer t1 := 1; // érték tartalmazó template t1 == c // hiba: nem tudjuk egy templatet összehasonlitani egy értékkel valueof(t1) == c // igaz, mivel a valueof() függvény egy értékkel tér vissza

Speciális template tipusok
In-line template

Templateket megadhatjuk közvetlenül is, ott ahol használni akarjuk őket. Ezeket a templateket in-line templatenek nevezzük. A szintaktika a következő

[ <tipus : > ] [ modifies PTemplate ":=" ] < törzs >
Az in-line template nem nevesitet, ezért nem tudjuk őket újrafelhasználni vagy referálni. Az in-line template életciklusa addig tart amig az őt tartalmazó kifejezés veget nem ér. Az in-line templatek, mint minden mas template, egymasba ágyazhatók.
// integer értétartomány port1_PCO.receive((0..7)); // összetet in-line template port1_PCO.receive(MyRecordType:{ field1 := *, field2 := ? } );

Módositott template

Normál esetben egy template alapértelmezett értékekből álló halmaz. Azokban az esetekben ahol kis változtotások sükségesek egy új template létrehozására, a legjobb eredményt akkor kapjuk meg, ha egy már meglévő templatet módositunk.

Lehetőség van a modifies kulcsszó segítségével egy már létező template felhasználásával újat definiálni. Ez is egyfajta öröklési láncot határoz meg melyben a körök fordítási idejű hibához vezetnek.

A módositott templateben csak azokat a mezőket kell újradefiniálni, amiknek az érteke különbözik az eredeti templatehez képest.

// Szülő template: template MyMsgType t_MyMessage1 := { field1 := 123, field2 := true } // Módositott template: template MyMsgType t_MyMessage2 modifies t_MyMessage1 := { field2 := false } // t_MyMessage2 egyenértékű a követkető templattel template MyMsgType t_MyMessage3 := { field1 := 123, field2 := false }
In-line módositott template

Lehetőség van in-line módositott template megadására is. Tulajdonságai megegyeznek a sima in-line template-ével. Nem paraméterezhétők és nem hatékonyak, ezért nem ajanlott a használatuk.

template MyRecordType t_1 := { field1 := omit, field2 := false } control { … port_PCO.receive(modifies t_1 := { field1 := * } ); … }

Template paraméterezése

Lehetőség van paraméterezni a template-et, ezzel nővelve a használhatóságát. Paraméterként használhatjuk valódi értéket, konstansokat, modul paramétereket es változókat egyaránt.

template MyMsgType t_MyMessage( integer int, integer int2 ) := { field1 := int, field2 := int2 } port.send(t_MyMessage(1, 2))

A leszármozott template és paraméterezhetővé tehetjuk, az egyetlen megkötés az, hogy a szűlő template paramétereit feltétlenül szerepeltetni kell a paraméterlistában. Ezek mellet értelemszerűen új paraméterek és hozzáadhatjuk.

// szülő template template T_message1 parent( integer par_int, boolean par_bool ) := { field1 := par_int, field2 := par_bool, field3 := ’00FF00’O } // gyerek template template T_message2 child( integer par_int, boolean par_bool, octetstring par_oct ) modifies T_message1 := { field3 := par_oct }

Template paraméterként használhatjuk egy másik templatet. A template tipusú paraméter tartalmazhat valós értekeket, konstansokat, változókat, illesztési szimbólumokat (?, *) stb.

// paraméterezés template-tel template integer t_int := ( (3..9), 66, 444) ); template MyTemplate t_myTemplate(template integer t_int) := { field1 := 1, field2 := t_int } // hasznalata port.send(t_myTemplate( 5 ) ); port.receive (t_myTemplate( ? ) ); port.receive (t_myTemplate( t_int ) ); port.receive (t_myTemplate( (3..5) ) ); port.receive (t_myTemplate( complement (3,5,9) );