A TTCN-3 kialakításakor fontos szempont volt az ASN.1 nyelvvel történő magas szintű kompatibilitás, mivel nagyon sok, protokollok által használt típus leírása ebben a formában állt rendelkezésre. Ennek megfelelően a nyelv típusainak legtöbbje egyértelműen megfeleltethető egy ASN.1-beli típusnak.
A TTCN-3 rendelkezik a sok más programozási nyelvben is megtalálható egyszerű alaptípusokkal, valamint néhány speciális, beépített típussal is. Ezek mellett természetesen lehetőségünk van saját adatszerkezeteket is definiálni a strukturált típusok segítségével. A TTCN-3 típusrendszere az alábbi elemekből áll:
| Típus | Altípusdefiníció példa | Érték példa | Ekvivalens ASN.1 típus |
|---|---|---|---|
| Alaptípusok | |||
| integer | type integer MyInt; | 10 | INTEGER |
| float | type float MyFloat; | 10.0 | REAL |
| boolean | type boolean MyBool; | true | BOOLEAN |
| bitstring | type bitstring MyBitstring; | '1101'B | BIT STRING |
| hexstring | type hexstring MyHexstring; | 'AF3'H | - |
| octetstring | type octetstring MyOctetstring; | 'AF31'O | OCTET STRING |
| charstring | type charstring MyCharstring; | "Hello, world!" | IA5String |
| char (obsolete) | type char MyChar; | "A" | IA5String(SIZE(1)) |
| universal charstring | type universal charstring MyUC; | "Ελληνικά" | UniversalString |
| universal char (obsolete) | type universal char MyUChar; | "λ" | UniversalString (SIZE(1)) |
| objid | type objid MyObjid; | objid { itu_t(0) 4 etsi(0) } | OBJECT IDENTIFIER |
| Strukturált típusok | |||
| record | type record MyRecord
{
BIT_4 protVersion,
integer typeCode,
charstring payload
} |
{
protVersion := '0010'B,
typeCode := 25,
payload := "Hello, world!"
} | SEQUENCE |
| record of |
type record of integer MyRoi;
|
{ 1, 2, 3, 4, 5 }
| SEQUENCE OF |
| set |
type set MySet
{
BIT_4 protVersion,
integer typeCode,
charstring payload
}
|
{
typeCode := 25,
payload := "Hello, world!",
protVersion := '0010'B
}
| SET |
| set of |
type set of integer MySoi;
|
{ 2, 3, 4, 1, 5 }
| SET OF |
| union |
type union MyUnion
{
integer variant1,
BIT_1 variant2,
OCT_2 variant3
}
|
{
variant2 := '1'B
}
| CHOICE |
| enumerated |
type enumerated MyEnum
{
E_REQ,
E_IND(1),
E_ERR
}
|
E_IND
| ENUMERATED |
| Speciális típusok | |||
| verdicttype | - | pass | - |
| default | - | - | - |
| anytype | - | - | - |
| port | - | type port MyMessagePortType message
{
inout MyMsgType;
} | - |
| component | - | type component MyMTCType
{
var integer MyLocalInteger;
port MyMessagePortType MyPCO1;
port MyProcedurePortTypes[3][3] PCO2; // 9 port
}
| - |
| timer | - | timer T2 := 2.9 | - |
Alaptípusok
A más nyelvekben megszokottakhoz képest nincs eltérés az alaptípusok használatának tekintetében. Az integer egész, a float lebegőpontos értékek tárolására alkalmas, a boolean értékhalmaza a true és a false kulcsszavak. Lehetőségünk van különböző formájú szövegek tárolására, a charstring feleltethető meg a hagyományos string típusnak, a bitekből álló szöveget a bitstring, az oktetekből álló szöveget az octetstring, míg a hexadecimális értékekből álló szöveget a hexstring típus valósítja meg.
Strukturált típusok
A nyelvben struktúrált típusokat a record, set és union kulcsszavakkal hozhatunk létre. A record lényegében egy C/C++ struct-nak feleltethető meg. A set a recordhoz hasonló, különbség azonban, hogy míg a recordban a belső elemek sorrendje kötött, addig a set-nél ez tetszőleges lehet. Set esetében teljesül tehát a
{a := 0, b := true}={b := true, a := 0}
recordra azonban ez nem igaz.
A union típus segítségével összeállított konstrukció tetszőleges mezői közül egy pillanatban legfennebb egy tárolhat értéket, azt pedig, hogy melyik az a mező az ischosen függvénnyel kérdezhetjük le:
ischosen(myUnionVariable.fieldName)
Strukturált típusok mezőit opcionálisnak jelölhetjük az optional kulcsszóval, ekkor az adott mező típusértékei mellett az értéke lehet omit is.
type record/set MyType {
integer field1 optional,
boolean field2
}
var MyType myVar :=
{
field1 := omit,
field2 := false
}
A record of illetve a set of konstrukciót elemek egy csoportjának tárolására használhatjuk, azonos típusú elemek absztrakt konténereként tekinthetjük őket. A különbség közöttük az, hogy record of esetén fontos az elemek sorrendje, míg set of-nál ez nem számít. Két record of struktúra egyenlő, ha ugyanazokat az elemeket tartalmazzák ugyanabban a sorrendben, két set of struktúra pedig egyenlő, ha ugyanazokat az elemeket tartalmazzák akár tetszőleges sorrendben.
A típusok egymásbaágyazhatóságának természetesen nincs korlátja, sőt akár „névtelen” típusokat is használhatunk típusdefiníciókor:
type record of set of integer KulsoTipus;
ekvivalens a
type set of integer BelsoTipus;
type record of BelsoTipus KulsoTipus;
definíciókkal.
Speciális típusok
A fentiek mellett a nyelvben lévő beépített speciális adattípus a verdicctype, amely a teszt futtatás eredményeinek kezelésére alkalmas, lehetséges értékei pedig none, pass, inconc, fail, error.
Egy másik speciális típus az anytype, ez az adott modul által ismert összes (alaptípusok, felhasználó által definiáltak valamint importáltak) típus unionjaként értelmezhető.
További speciális típusokat jelölnek az address, port, component és default kulcsszavak szintén speciális típusokat vezetnek be, ezeket a későbbiekben bemutatjuk.
Altípusozás
A nyelv segítségével az ADA-hoz nagyon hasonló altípus megszorításokat vezethetünk be, ezeket az alábbi tálázat írja le.
| Megszorítási osztály | Alkalmazhatóság | Példa megszorított típusokra |
|---|---|---|
| Alapszintű megszorítások | ||
| érték lista | minden típus |
type integer MyInt(1, 2, 3);
type float MyFloat(1.0, 2.0);
type boolean MyBool(not true); // ugyanaz mint a (false)
type bitstring MyBitstring(''B, '1'B, '101'B);
type hexstring MyHexstring('F'H, '5AE'H);
type octetstring MyOctetstring('A4'O, '15AC'O);
type charstring MyCharstring(";AB";, ";CD";, ";EFG";);
type universal charstring MyUC(";Ελληνικά";, ";Русский";);
type objid MyObjid(objid { 1 2 3 }, objid { m(0) 1 });
type MyBaseRecord MyRestrictedRecord
({ f1 := 1, f2 := 5 }, { f1 := 3, f2 := 4 }, MyRecConst);
type MyBaseRecOfInt MyRestrictedRecOfInt
({ 1, 2, 3 }, { 4, 5 });
type MyBaseSet MyRestrictedSet
({ f1 := 1, f2 := 5 }, { f2 := 4, f1 := 3 });
type MyBaseSetOfInt MyRestrictedSetOfInt
({ 1, 2, 3 }, { 5, 4 });
type MyBaseUnion MyRestrictedUnion
({ u1 := 5 }, { u2 := '11'B }, MyUnionConst);
type MyBaseEnum MyRestrictedEnum(E_REQ, E_IND);
type verdicttype MyVerdictType(pass, fail);
type MyDefinedIntType MyRestrictedInt(10, 20);
|
| érték intervallum |
|
type integer MyInt(0 .. 255);
type integer NaturalNumbers(1 .. infinity);
type integer NegativeNumbers(-infinity .. -1);
type float MyFloat(0.0 .. 1.0);
type float NonNegative(0.0 .. infinity);
type float NonPositive(-infinity .. 0.0);
|
| character intervallum | minden karakteres szöveg típus |
// minden karakter a MyCharstring típusban
// a ["a" .. "z"] zárt intervallum eleme:
//
type charstring MyCharstring("a" .. "z");
|
| hossz megszorítás |
|
type bitstring MyBitstring length(5);
type hexstring MyHexstring length(2..4);
type octetstring MyOctetstring length(0..10);
type charstring MyCharstring length(10..infinity);
type universal charstring MyUC length(5);
type record length(5..infinity) of integer MyRecOfInt;
type set length (15) of integer MySetOfInt;
|
| pattern | minden karakteres szöveg típus |
type charstring MyStr1(pattern "abc*xyz";);
// ugyanaz, mint: type charstring MyStr2("a" .. "z");
type charstring MyStr2(pattern "[a-z]#(0,)");
|
| Összetett megszorítások | ||
| kevert érték lista és érték intervallum |
|
type integer MyInt(-1000, -100..-90, -10, 1..infinity);
type float MyFloat(-1E3, -1E2..-90.0, -10.0, 1.0..infinity);
|
| postfixing hossz megszorítás | minden szöveges típus |
// hosszmegszorításokat tetszőleges szöveges
// megszorítás alaphoz köthetünk
type charstring MyStr1(pattern "abc*xyz") length(10..20);
type charstring MyStr2(pattern "abc*xyz") length(15);
// ugyanaz, mint: type charstring MyStr3(pattern "[a-z]#(10,20)");
type charstring MyStr3("a" .. "z") length(10..20);
// ugyanaz, mint: type charstring MyStr4(pattern "[a-z]#(1,)");
type charstring MyStr4("a" .. "z") length(1..infinity);
// ugyanaz, mint: type charstring MyStr5(pattern "[a-z]#(,10)");
type charstring MyStr5("a" .. "z") length(0..10);
// ugyanaz, mint: type charstring MyStr6(pattern "[a-z]#(10)");
type charstring MyStr6("a" .. "z") length(10);
|
Leszármazott típusok esetén (pl. hosszmegszorítás) az új típus értékei kompatibilisek maradnak a régi típussal, amennyiben az a származási szabályt nem sérti. Kizárólag az fogadott és várt üzenet összehasonlításakor szükséges erősebb típusmegkötés, tehát amennyiben a leszármazott típusú üzenetet várunk de az őstípus érkezik (akár megfelelő értékkel) úgy az üzenet fogadása sikertelen.
Típuskonverziók
A nyelv nem támogatja sem az implicit, sem pedig az explicit típuskonverziót, azonban beépített függvényeket nyújt a típusok közötti konvertálásra.
| Hova/Honnan | integer | float | bitstring | hexstring | octetstring | charstring | universal charstring |
|---|---|---|---|---|---|---|---|
| integer | - | float2int | bit2int | hex2int | oct2int | char2int, str2int | unichar2int |
| float | int2float | - | - | - | - | str2float | - |
| bitstring | int2bit | - | - | hex2bit | oct2bit | str2bit | - |
| hexstring | int2hex | - | bit2hex | - | oct2hex | str2hex | - |
| octetstring | int2oct | - | bit2oct | hex2oct | - | char2oct, str2oct | - |
| charstring | int2char, int2str | float2str | bit2str | hex2str | oct2char, oct2str | - | - |
| universal charstring | int2unichar | - | - | - | - | - | - |