Tekstifunktsioonid XSLis

Asukoha järgi saab andmeid XSLi abil XMList ilusti välja võtta. Et kui 
soovitakse küsida kolmanda inimese eesnimi, siis kirjutatakse 
/inimesed/inimene[3]/eesnimi sobivasse kohta, näiteks xsl:value-of elemendi 
select-parameetriks. 

Kui soovitakse aga nimest vaid esitähte, siis võib kirjutada

        Esitäht: <xsl:value-of select="substring(/inimesed/inimene[1]/eesnimi, 
1, 1)" />

Funktsioonile substring tuleb ette anda otsitav tekst ning kaks arvu: mitmendast 
tähest alates ning mitu tähte väljastada. 

Funktsiooni enese kuju

substring(s1, start, nr?)

Järgnevalt siis mõned levinumad sõnefunktsioonid:

concat(s1, s2, s3*)  

Parameetritena antud tekstid liidetakse. Elementide arv ei ole piiratud. 
Üldjuhul saab hakkama ka ilma seda funktsioonid kasutamata, pannes lihtsalt 
järjestikku vajalikke xsl:value-of elemente ning tekste. Aga mõnikord on concati 
abil andmeid lühem reastada.  Näiteks initsiaalide tarbeks

          <xsl:value-of select="concat(substring(/inimesed/inimene[1]/eesnimi, 
1, 1),'.', 
                  substring(/inimesed/inimene[1]/perenimi, 1, 1), '.')" />

Ehk siis concati sees komadega eraldatult eesnime esitäht, punkt (tekstina 
esitamiseks ülakomade vahel), siis perekonnanime esitäht ning sellele järgnev 
punkt.


        <xsl:value-of select="substring-before('muna ja kana', 'ja')" />

  annab tulemuseks "muna". Mõlema funktsiooni kujud näevad välja järgnevalt, 
teine lihtsalt annab välja eraldajale järgneva osa.

substring-before(s1, s2)
substring-after(s1, s2)

Pea igas programmeerimiskeeles on käsklus teksti pikkuse küsimiseks. Nii ka 
siin.

string-length(s1) 

ehk siis näitena 

<xsl:value-of select="string-length('Mati')" />

annab tulemuseks arvu 4. 

normalize-space(s1)   
Võtab algusest ja otstest tühikud, muud vahed teeb  üheks tühikuks. Kasulik 
näiteks erikujuliste sisestatud tekstide võrdlemisel või lihtsalt väljundi 
viisakamaks muutmisel. XMLi andmete juures ei mängi korduvad tühikud rolli, küll 
aga neist võib tüli tekkida mõnda muusse kohta suunduva väljundi puhul.

translate (s1, algsümbolid, lõppsümbolid)
Tähtede asendamiseks leiab harjumatu kujuga funktsiooni. Näite järgi on aga ehk 
toimimine mõistetav: translate('pann', 'an', 'ek') -> 'pekk'


Ülesandeid

* Koosta XML-andmefail, kus on kirjas auto registrinumber ning omaniku 
perekonnanimi
* Trüki välja auto registrinumber
* Trüki välja auto registrinumbri numbrite osa
* Trüki välja auto registrinumbri tähtede osa
* Trüki välja inimese perekonnanime esimene täht
* Trüki välja inimese perekonnanime viimane täht



Loendamine

Vastuse küsimusele, mitu elementi vastab soovitud otsingule, annab funktsioon 
count. Näiteks inimeste arvu saab kokku järgnevalt:

        Inimeste arv: <xsl:value-of select="count(/inimesed/inimene)" />

Tahtes kokku loendada kõiki inimesi, kelle eesnimi on Juku, tuleb vastav piirang 
kirjutada inimese taha kandiliste sulgude sisse.

        Jukude arv: <xsl:value-of 
select="count(/inimesed/inimene[eesnimi='Juku'])" />

Saab võrrelda ka suurem ja väikesem olemist. Vastavad võrdlused aga on viisakas 
kirjutada XMLi jaoks sobivate märgikombinatsioonidena. "Väiksem kui" oleks siis 
kujul &lt; (less than) ning "suurem kui" kujul &gt; (greater than).

        Enne Moskva olümpiat sündinud: <xsl:value-of 
select="count(/inimesed/inimene[synd &lt; 1980])" />

Ülesandeid

* Koosta/otsi XML-andmefail, kus on kirjas auto registrinumber ning omaniku 
perekonnanimi
* Leia, mitme inimese perekonnanimi on Kaalikas
* Leia, mitme inimese perekonnanimi algab M-tähega
* Leia, mitme auto registrimärgi numbritest viimane on 2
* Leia, mitme auto registrimärgi numbritest viimane on 1 või 2




Tingimused

Programmeerimise juures on võimalik tingimusele vastavalt midagi teha või 
tegemata jätta. Nii ka siin. Tavalise valiku tarvis on käsklus xsl:if. Näide:

        <xsl:if test="starts-with(/inimesed/inimene[1]/eesnimi, 'J')">
          Esimene nimi algab jotiga
        </xsl:if>

Kui tingimus vastab tõele, siis sealne tekst trükitakse, muidu mitte. Käsu kuju 
siis
	starts-with(s1, s2)  
ning selgitus
	Kontrollitakse, kas esimesena antud tekst algab teisena antud tekstiga.

Mõnevõrra sarnane funktsioon on 
	contains(s1, s2)
Võrreldes eelmisega ei pruugita alustada algusest, vaid otsitakse lõigu leidmist 
kogu teksti ulatuses.

Tõeväärtuse saab vastuspidiseks pöörata funktsiooniga not(), eraldi else-lauset 
ei ole. 

        <xsl:if test="not(starts-with(/inimesed/inimene[1]/eesnimi, 'A'))">
            Esimene nimi ei alga a-ga
        </xsl:if>

Tingimuseks sobivad ka igasugu võrdlused, mille vastuseks on "jah" või "ei". 
Näiteks, et kas teksti pikkus on väiksem kui viis sümbolit. Märk "on väiksem 
kui" ehk "<" kirjutatakse kujul &lt; (less than), sest nii vastab see XMLi 
süntaksile (millele XSL leht peab töötamiseks vastama. Näiteks 

        <xsl:if test="string-length(/inimesed/inimene[1]/eesnimi) &lt; 5">
           Lühike nimi
        </xsl:if>

Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas auto registrinumber ning omaniku 
perekonnanimi
* Kui registrimärgi viimane number on 5, siis teata, et ülevaatuse kuu on juuli
* Teata iga registrinumbri puhul, millises kuus auto ülevaatusele peab minema.
* Kui perekonnanimes sisaldub täht x, siis teata, et tegemist on võõrnimega.
* Muul juhul teata, et tegemist pole võõrnimega.


Kordused

Kui samatüübilisi andmeid on palju, siis tulevad appi kordused. Nii ka XSLi 
juures. Tsükli loomiseks sobib käsklus xsl:for-each, select-parameetrina antakse 
ette elemendid mille kontekstis ploki sisu korrata. Et tööd alustatakse 
juurelemendile vastavast mallist 

    <xsl:template match="/">

ning sealt seest küsitakse kõiki elemente, mis vastavad mustrile 
inimesed/inimene, siis saadakse kätte algsest failist kõik viis inimest, kes on 
pöördutavad kujul /inimesed/inimene.

Tsükli sees on igal korral jooksvaks elemendiks juba konkreetne inimene. 
Esimesel korral siis näiteks

    <inimene>
        <eesnimi>Juku</eesnimi>
        <perenimi>Juurikas</perenimi>
        <synd>1963</synd>
    </inimene>

Seal saab juba otse pöörduda alamelementide poole. Ehk siis 

            <xsl:value-of select="eesnimi" />

annab vastuseks Juku. Ning iga järgmise ringi juures juba järgmise inimese 
eesnime. 



<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <xsl:for-each select="inimesed/inimene">
            <xsl:value-of select="eesnimi" />
        </xsl:for-each>
    </xsl:template>
</xsl:stylesheet>


Käivitades XSL-lehe koos andmefailiga saame tulemuse arvatavasti kujul

JukuJukuKalleMariOskar

Tahtes nimede vahele tühikuid saada, sobib abielemendina xsl:text, mis lubab 
elemendi alguse ja lõpu vahele kirjutatud teksti otse väljundisse saata. 

        <xsl:for-each select="inimesed/inimene">
            <xsl:value-of select="eesnimi" />
            <xsl:text> </xsl:text>
        </xsl:for-each>

Annab siis tulemuseks

  Juku Juku Kalle Mari Oskar


Kui aga juba HTMLi sisse andmete kirjutamiseks läheb, siis pole otsesed tühikud 
ja reavahetused kuigi tähtsad - loeb lihtsalt nende olemasolu või puudumine, 
mitte kogus. Kujundamiseks on aga seal juba omad käsud. Näiteks loetelu jaoks 
tavapärane komplekt <ul> kogu loetelu tähistamiseks ning <li> üksiku elemendi 
tarbeks. Need saab rahumeeli XSLi faili sisse panna. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="eesnimi" /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>

Tulemusena võib ilusti vormindatud tulemust imetleda.

      <ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li>Mari</li>
  <li>Oskar</li>
</ul>


Sama tulemuse saab programmide puhul ikka mitmel moel kätte. Eelnenud näites 
öeldi xsl:for-eachi juures, et läbi tuleb käia kõik elemendid nimega inimene 
ning xsl:value-ofi juures määrati, et näha soovitakse inimese seest eesnime.

Järgnevas näites saadakse sama tulemus nõnda, et juba xsl:for-eachi juures 
käiakse läbi kõikide inimeste eesnimed. Ning xsl:value-ofi juures pole muud vaja 
öelda, kui et tuleb kuvada jooksva elemendi (mida tähistatakse punktiga) 
väärtus.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene/eesnimi">
            <li><xsl:value-of select="." /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


	Ehkki XSL pole mõeldud suuremamahulisteks arvutusteks ja tekstitöötluseks, 
õnnestub lihtsamad võrdlused ja kokkuvõtted siin täiesti teha. Järgnevalt siis 
loetelu nende inimeste perekonnanimedest, kelle eesnimi algab J-iga. Algandmete 
peale vaadates leiame sealt kaks Jukut: üks Juurikas ning teine Kaalikas. 
Vastavad perekonnanimed saadakse jätte järgneva avaldise abil.

  <xsl:for-each select="/inimesed/inimene[starts-with(eesnimi, 'J')]/perenimi" >

	Kandiliste sulgude sees määratakse ära, millistele tingimustele vastavaid 
inimesi loetellu võetakse. Siin juhul siis kontrolliks XSLi funktsioon nimega 
starts-with, parameetriteks kontrollitav tekst ning otsitav algustekst. Ning 
nagu muud tõeväärtusfunktsioonid, nii ka siin on väärtuseks jah või ei. Ning 
loetellu jäävad need inimesed, kel avaldise puhul väärtuseks jah. Ning nõnda 
saab tsükli sees otsitud tulemused välja kirjutada.


<?xml version="1.0"?>
<xsl:stylesheet 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output encoding="UTF-8" method="html" />

<xsl:template match="/">
  <xsl:for-each select="/inimesed/inimene[starts-with(eesnimi, 'J')]/perenimi" >
     <xsl:value-of select="." />;
  </xsl:for-each>
</xsl:template>
</xsl:stylesheet>

Käivitamine nii nagu eelnenud näite puhul


E:\kasutaja\jaagup\xml>java XSLMuundur inimesed.xml inimesed4.xsl inimesed4.txt

Ning faili sisu piiludes võime just soovitud read selle seest avastada.

E:\kasutaja\jaagup\xml>more inimesed4.txt
Juurikas;
  Kaalikas;


Plokifunktsioone

Kui tsükli abil plokis liikuda, siis tuleb vahel kasuks teada, mitmendal ringil 
parajasti ollakse ning mitu ringi kokku on. Vastavad abiks olevad funktsioonid 
on järgnevad:

last()        viimase järjekorranumber
position()    jooksva järjekorranumber

Ehk siis järgnevas näites trükitakse iga eesnime ette tema järjekorranumber. 

            <xsl:value-of select="concat(position(),' - ',eesnimi)" />

Käsklus position() annab järjekorranumbri, concat seob ühte ritta kokku selle 
numbri, sidekriipsu ning vastava inimese eesnime, kelle juures ollakse. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="concat(position(),' - ',eesnimi)" /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


Väljund paistab välja järgnev:

      <ul>

  <li>1 - Juku</li>
  <li>2 - Juku</li>
  <li>3 - Kalle</li>
  <li>4 - Mari</li>
  <li>5 - Oskar</li>
</ul>


Kui tahta juurde määrata, et mitmes nimi mitmest, siis tuleb lisaks viimase 
järjekorranumbrit näitav last().

        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="concat(position(),'/',last(),' - 
',eesnimi)" /></li>
        </xsl:for-each>
        </ul>
 
Ning tulemus veebilehel järgmine:


    * 1/5 - Juku
    * 2/5 - Juku
    * 3/5 - Kalle
    * 4/5 - Mari
    * 5/5 - Oskar


Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku 
perekonnanimed
* Trüki välja kõik perekonnanimed
* Lisa iga perekonnanime ette tema järjekorranumber
* Need read, kus registrinumbri viimane number lõppeb ühe või kahega trüki 
rasvaselt.



Kujundus korduse sees

Lisaks nimede/andmete ettelugemisele on küllalt sageli vajalik/kasulik neid ka 
vastavalt juurdekuuluvatele omadustele kujundada, et sobivaid ridu oleks kergem 
üles leida. Tingimuslauseid, arvutusi ja muid käsklusi saab rahumeeli kasutada 
ka korduse või korduste sees. Järgnevalt värvitakse hiljem kui 1980ndal aastal 
sündinud inimeste eesnimed roheliseks. Tehakse eesnimele ümber span-plokk ning 
sealse stiiliga määratakse nime värv. Ja kui tahta ka ülejäänud nimesid näidata, 
ainult et tavaliste mustadena, siis üks moodus on loodud plokk lihtsalt 
kopeerida, tingimusele ümberpöörav not-käsklus ümber panna ning nimele sobiv 
värv määrata. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li>
                <xsl:if test="synd &gt; 1980">
                    <span style="color:green">
                        <xsl:value-of select="eesnimi" />
                    </span>
                </xsl:if>
                <xsl:if test="not(synd &gt; 1980)">
                    <span style="color:black">
                        <xsl:value-of select="eesnimi" />
                    </span>
                </xsl:if>
            </li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>

Tulemusena siis loetelu, kus iga nime juures märgitud värv.

      <ul>
  <li>
    <span style="color:black">Juku</span>
  </li>
  <li>
    <span style="color:black">Juku</span>
  </li>
  <li>
    <span style="color:black">Kalle</span>

  </li>
  <li>
    <span style="color:green">Mari</span>
  </li>
  <li>
    <span style="color:black">Oskar</span>
  </li>
</ul>


Sama saab aga ka märgatavalt lühemalt kirja panna. Iseenesest pole ju nime 
värvimiseks talle vaja eraldi span-elementi ümber panna. Piisab, kui nime 
näitava elemendi - praegusel juhul li - stiilis on sobiv värv määratud. Käsklus 
xsl:attribute võimaldabki juba alanud elemendi sisse atribuute lisada. Järgnevas 
näites siis näha, et noorematele kui 1980ndal sündinutele pannakse 
loeteluelemendile rohelise värvi atribuut külge.



        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li>
                <xsl:if test="synd &gt; 1980">
                    <xsl:attribute name="style">color:green</xsl:attribute>
                </xsl:if>
                <xsl:value-of select="eesnimi" />
            </li>
        </xsl:for-each>
        </ul>


Ning pärast käivitamist on see ilusti näha ka tulemuse juures.

<ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li style="color:green">Mari</li>
  <li>Oskar</li>
</ul>


Pikemate ridade puhul on heaks tavaks mõned read ära värvida, et oleks parem 
andmeid lugeda ja näpuga järge ajada. Reanumbri saame kätte käsuga position(). 
Nüüd, kui on tahtmine kindla arvu ridade tagant erivärviline rida luua, siis on 
heaks abivahendiks jagamise jääk, modulus, ehk siin tehe nimega mod. Näitab, et 
kui vasakul pool olev kogus jagada paremal pool olevaks arvuks võrdseteks 
osadeks, mitu siis jääb üle. Kui näiteks kaksteist õuna jagada võrdselt neljale 
lapsele, siis saab igaüks kolm õuna, ühtegi üle ei jää ehk jääk on null. Kui aga 
on õunu kolmteist, siis üks õun jääb üle ehk jääk on üks. Neljateistkümne puhul 
kaks, viieteistkümne puhul kolm ning kuusteist jagub taas neljaga, siis jääk 
jälle null. Nii et kui tahaks iga neljanda rea teistsuguseks teha, siis piisaks 
kontrollida, et kas jääk jagamisel neljaga on mingi kindel arv nendest 
võimalikest jääkidest. Ühe puhul oleks värvitud kohe esimene rida, kahe puhul 
teine, kolme puhul kolmas. Ning kõigepealt neljanda värvimiseks piisab 
kontrollimast, kas jääk on null. Iga teise rea värvimiseks näiteks sobib järgnev 
kood:

            <li>
                <xsl:if test="position() mod 2 =0">
                    <xsl:attribute name="style">background-
color:lightgray</xsl:attribute>
                </xsl:if>
                <xsl:value-of select="eesnimi" />
            </li>

Ning tulemus veebilehe koodis on selline.

<ul>
  <li>Juku</li>
  <li style="background-color:lightgray">Juku</li>
  <li>Kalle</li>
  <li style="background-color:lightgray">Mari</li>
  <li>Oskar</li>
</ul>


Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku 
perekonnanimed
* Väljasta andmed tabelina: registrinumbrid ühes ning perekonnanimed teises 
tulbas.
* Värvi ridade taustad üle ühe halliks.
* Värvi taustad nõnda, et järjestikku oleksid värvitu, hall ja kollane.


Mitu kordust samade andmetega

Tavaliselt käiakse andmed ühe korra läbi, näidatakse mis tarvis ja kogu lugu. 
Aga vahel võib olla põhjust ka mitu korda samu andmeid läbi käia ning elementide 
vahel seoseid leida ja välja märkida. Järgnevas näites luuakse tabel, kus nii 
veergudes kui ridades on samad inimesed. Veergude ja ridade ristumiskohal aga 
nende sünniaastate vahe - siis kohe näha, kes kui palju kellest vanem on. Kui 
kordus määratakse juurelemendist alates, siis on selline sättimine lihtne - 
piisab kaks for-each tsüklit üksteise sisse panna ning mõlemale määrata, et 
tuleb läbi käia elemendid mustriga /inimesed/inimene. Veidi mõtlemist vajab 
aastate vahe arvutus, sest sisemise inimese sünniaasta varjestab välimise oma 
ära. Aitab aga, kui välimine element jätta eraldi muutujasse meelde. Siis saab 
selle andmed ka sisemises plokis kätte ning võib nendega rahus toimetada. 


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <table>
            <tr>
                <th>Inimeste vanuste vahe</th>
              <xsl:for-each select="/inimesed/inimene">
                  <th>
                      <xsl:value-of select="concat(eesnimi, ', ', 
synd)"></xsl:value-of>
                  </th>
              </xsl:for-each>
            </tr>
            <xsl:for-each select="/inimesed/inimene">
                <tr>
                    <xsl:variable name="v2limine" select="." />
                    <td>
                        <xsl:value-of select="eesnimi" />
                    </td>
                 <xsl:for-each select="/inimesed/inimene">
                     <td>
                         <xsl:value-of select="number(synd)-
number($v2limine/synd)" />
                     </td>
                 </xsl:for-each>
                </tr>
            </xsl:for-each>
        </table>
    </xsl:template>
</xsl:stylesheet>


Veebilehel väljund näha järgmine:


Inimeste vanuste vahe  	Juku, 1963  	Juku, 1961  	Kalle, 1975  
	Mari, 1981  	Oskar, 1971
Juku 	0 	-2 	12 	18 	8
Juku 	2 	0 	14 	20 	10
Kalle 	-12 	-14 	0 	6 	-4
Mari 	-18 	-20 	-6 	0 	-10
Oskar 	-8 	-10 	4 	10 	0

Ülesandeid

* Pane näide käima
* Vähem kui viieaastase vanusevahega lahtrid näita teise värviga

* Kirjuta lahtritesse vastavate inimeste perekonnanimed. Nt. Kalle ja Mari 
ristumiskohale tuleb "Kaalikas ja Maasikas"
* Võrreldes eelmisega jäta tühjaks need lahtrid, kus inimene kohtub iseenesega 
(kõige viisakam kindlaks teha positsiooni järgi).


XSL eri struktuuriga andmefailidele

Eelnevad näited olid loodud kindlate elemendinimedega andmefaili seest väärtuste 
kogumiseks ja esitamiseks. Vahel aga võivad andmefailid olla küll mõneti 
sarnased, aga sugugi mitte samade elemendinimedega ja -kogustega. Tüüpiliseks 
näiteks on mitmed algselt tabeli kujul olevad andmed, mis XML-i kujule viidud 
ning mida hiljem sealt soov taas HTML- või mõne muu tabeli kujul esitada. 
Sellisel juhul osutub kasulikuks käsklus name, mille abil saab etteantud ploki 
nime küsida. Samuti on kasulik metamärk * (tärn), mis tähistab kõiki vastavas 
kohas asuvaid alamelemente. Või kui küsida sellise alamelementide ploki nime, 
siis antakse neist esimese nimi. Siin on allikaks sama inimeste fail. Käsklus 
name(*) annab vastuseks "inimesed", kuna ollakse  juure juures. Käsklus 
name(*/*) väljastab "inimene", sest see on eelneva alamelement. Tegelikult 
mustrile vastavad kõik elemendid "inimene", aga kuna küsitakse nime ainult ühe 
kohta, siis väljastatakse esimese oma. Tahtes läbi käia esimese inimese kõik 
alamelemendid, sobib tsükliks

        <xsl:for-each select="*/*[1]/*">

Lahtiseletatult siis esimene tärn tähendab juures asuvat elementi "inimesed". 
Järgmine *[1] on esimene inimene. Ning viimase tärni alt tulevad välja esimese 
inimese eesnimi, perenimi ja synd. Tahtes saada elementide nimesid ja mitte 
väärtusi, siis aitab taas käsklus name, sedakorda kujul

                <xsl:value-of select="name(.)" />

kus trükitakse välja parasjagu jooksva elemendi nimi. Kogu XSLi kood:


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <h1>
            Juurelement: <xsl:value-of select="name(*)" />
        </h1>
        <h2>
            Esimene alamelement: <xsl:value-of select="name(*/*)" />
        </h2>
        <h3>Alamelemendi järglased: </h3>
        <ul>
        <xsl:for-each select="*/*[1]/*">
            <li>
                <xsl:value-of select="name(.)" />
            </li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


Ning tulemuseks saadi siis järgnev HTML, kus võib veenduda, et kõik elemendid 
õigesti kätte saadi.

      <h1>Juurelement: inimesed</h1>
<h2>Esimene alamelement: inimene</h2>
<h3>Alamelemendi järglased: </h3>
<ul>
  <li>eesnimi</li>
  <li>perenimi</li>
  <li>synd</li>
</ul>


Edasi tasub mõelda, et millisel kujul on soov andmeid esitada. Kui veebilehel ja 
tabelina, siis on tabeli HTML-käsud igati asjakohased. Eelneva loetelu saab 
vormistada tabeli tulpade pealkirjadena.


        <h1><xsl:value-of select="name(*)" /></h1>
        <table>
         <tr>
          <xsl:for-each select="*/*[1]/*">
            <th>
                <xsl:value-of select="name(.)" />
            </th>
          </xsl:for-each>
         </tr>
        </table>

Ning väljund veebilehel on järgnev.


      <h1>inimesed</h1>
<table>
  <tr>
    <th>eesnimi</th>
    <th>perenimi</th>
    <th>synd</th>
  </tr>
</table>


Soovides lisaks pealkirjadele ka tegelikke andmeid sisse panna, tuleb lihtsalt 
kaks tsüklit juurde panna. Pealkirjad ja lahtrite sisud tuleb eraldi tsüklitesse 
paigutada lihtsalt HTMLi loogka tõttu, kus tuleb vasakult paremale oma andmeid 
väljastada. Ehkki vajaduse ja tahtmise korral oleks võimalik ehk ka 
pealkirjaplokk ja andmete läbikäigu plokk ühendada ning lihtsalt if-iga 
kontrollida, kas ollakse andmetega esimese rea juures. Kui jah, siis oleks paras 
aeg lisaks muule ka pealkirjalahtrid kirjutada. Siin näites aga pealkirjaosa ja 
andmete osa eraldi kirjutatud. Andmete tsüklis siis kõigepealt 

            <xsl:for-each select="*/*">

käib läbi kõik elemendid "inimene". Sealt seest 

                    <xsl:for-each select="*">

võtab kõik, mis ühe inimese seest võtta on. Ning viimaks

                            <xsl:value-of select="." />

annab selle elemendi väärtuse, kus sees parajasti oma läbikäiguga ollakse. 

        <h1><xsl:value-of select="name(*)" /></h1>
        <table>
         <tr>
          <xsl:for-each select="*/*[1]/*">
            <th>
                <xsl:value-of select="name(.)" />
            </th>
          </xsl:for-each>
         </tr>
            <xsl:for-each select="*/*">
                <tr>
                    <xsl:for-each select="*">
                        <td>
                            <xsl:value-of select="." />
                        </td>
                    </xsl:for-each>
                </tr>
            </xsl:for-each>
        </table>


Tulemuseks on viisakas HTML-i tabel. 

      <h1>inimesed</h1>

<table>
  <tr>
    <th>eesnimi</th>
    <th>perenimi</th>
    <th>synd</th>
  </tr>
  <tr>
    <td>Juku</td>
    <td>Juurikas</td>
    <td>1963</td>
  </tr>
  <tr>
    <td>Juku</td>
    <td>Kaalikas</td>
    <td>1961</td>
  </tr>
  <tr>
    <td>Kalle</td>
    <td>Kaalikas</td>
    <td>1975</td>
  </tr>
  <tr>
    <td>Mari</td>
    <td>Maasikas</td>
    <td>1981</td>
  </tr>
  <tr>
    <td>Oskar</td>
    <td>Ohakas</td>
    <td>1971</td>
  </tr>
</table>


Ülesandeid

* Tee näited läbi. Lisa inimesele tunnuseks mass. Veendu, et andmed 
väljastatakse ka siis tabelina.
* Muuda näidet nõnda, et tabeli asemel genereeritaks loetelu, kus on näha iga 
elemendi vaid kaks esimest väärtust.
  Näiteks esimese puhul Juku Juurikas
* Muuda näidet nõnda, et tabeli asemel genereeritaks komadega eraldatud loetelu. 
Nt
  <li>Juku,Juurikas,1963</li>
* Muuda näidet nõnda, et tabeli asemel genereeritaks laused, mille abil 
vastavaid andmeid SQL-baasi sisestada. Inimeste puhul näeks siis lause välja:
  INSERT INTO inimesed (eesnimi, perenimi, synd) VALUES ('Juku', 'Juurikas', 
'1963');
* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku 
perekonnanimed
* Veendu, et eelnevalt koostatud XSL-lehed töötavad ka uue andmefailiga.


 Parameetrid

	Kui samade algandmete põhjal tahetakse kokku panna märgatavalt erinevaid 
tulemusi, siis tuleb üldjuhul igaks muundamiseks valmis kirjutada omaette XSL-
leht. Näiteks HTML- ja WAP-väljund näevad nõnda erinevad välja, et ühist 
muundajat kirjutada oleks raske. Kui aga valida lihtsalt eri resolutsioonidele 
arvestatud HTML-i vahel, siis võib XSLi parameetri abil kord rohkem, kord vähem 
lähteandmeid sisse võtta. Samuti, kui näiteks soovitakse näidata lehel inimeste 
vanuseid, salvestatud on aga sünniaastad, siis parameetrina antud praeguse 
aastaarvu järgi saab vähemalt ligikaudugi tulemuse parajaks sättida.
	Parameetri väärtus tuleb määrata eraldi elemendina enne mallikirjelduste 
algust. Nagu näha, tuleb parameetri nimi atribuudina, väärtus aga elemendi 
väärtusena. 
<xsl:param name="pikkus">5</xsl:param>

	Hiljem atribuudi väärtust küsides tuleb avaldises selle nimele dollarimärk 
ette panna. Ilma dollarita tähendaks see vastavanimelist XML-elementi. 

<xsl:value-of select="$pikkus" />

	Andmete sortimiseks tuleb tsükli sisse paigutada alamelement nimega 
xsl:sort ning parameetrina määrata, millise elemendi väärtuse järgi 
sorteeritakse. Nagu mujal, nii ka siin oleks võimalik parameetriks koostada 
avaldis, mis järjestamise peenemalt ette määraks. 

    <xsl:sort select="eesnimi" order="descending" />

	Soovides väljatrüki abil tühikuga eraldatud ees- ja perekonnanime, aitab 
funktsioon concat. Muul juhul tuleks sama tulemuse saavutamiseks xsl:value-of 
element mitmel korral välja kutsuda. 

     <xsl:value-of select="concat(eesnimi, ' ', perenimi)" />;

	Ning näide tervikuna.

<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output encoding="UTF-8" method="html" />

<xsl:param name="otsing">ar</xsl:param>
<xsl:param name="pikkus">5</xsl:param>

<xsl:template match="/">
  Nimed, mis sisaldavad kombinatsiooni <xsl:value-of select="$otsing" />:
  <xsl:for-each select="/inimesed/inimene[contains(eesnimi, $otsing)]">
    <xsl:sort select="eesnimi" order="descending" />
     <xsl:value-of select="concat(eesnimi, ' ', perenimi)" />;
  </xsl:for-each>

  Nimed pikkusega <xsl:value-of select="$pikkus" /> ja rohkem:
  <xsl:for-each select="/inimesed/inimene[string-length(eesnimi)>=$pikkus]" >
     <xsl:value-of select="concat(eesnimi, ' ', perenimi, 
          ' varuks ', string-length(eesnimi)-$pikkus)" />;
  </xsl:for-each>
</xsl:template>
</xsl:stylesheet>

Käivitus

E:\kasutaja\jaagup\xml>java XSLMuundur inimesed.xml inimesed4a.xsl 
inimesed4a.txt

ja tulemus

E:\kasutaja\jaagup\xml>more inimesed4a.txt

  Nimed, mis sisaldavad kombinatsiooni ar:
  Oskar Ohakas;
  Mari Maasikas;


  Nimed pikkusega 5 ja rohkem:
  Kalle Kaalikas varuks 0;
  Oskar Ohakas varuks 0;

	Parameetrite väärtuste muutmiseks ei pea alati tekstiredaktoriga muutma 
XSLi faili sisu. Neid saab sättida ka otse XMLi ja XSLi kokkusiduvas koodis ning 
ka ühendava programmi väljakutsel. Nõnda on ka siin näha, kus pikkusele antakse 
väärtuseks neli.

    tolkija.setParameter("pikkus", "4");

	Muus osas näeb faile ühendav käivitusprogramm eelnenuga sarnane välja.

import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import java.io.*;
public class XSLParameetrid{
  public static void main(String argumendid[]) throws Exception{
    Transformer tolkija=TransformerFactory.newInstance().
      newTransformer(new StreamSource("inimesed4a.xsl"));
    tolkija.setParameter("pikkus", "4");
    tolkija.transform(
      new StreamSource("inimesed.xml"), 
      new StreamResult(new FileOutputStream("inimesed4a.txt"))    
    );    
  }
}

Ka käivitamine sarnane

E:\kasutaja\jaagup\xml>java XSLParameetrid

	Ning tulemusena näeb siis nelja tähe pikkusi ja pikemaid nimesid.

E:\kasutaja\jaagup\xml>more inimesed4a.txt

  Nimed, mis sisaldavad kombinatsiooni ar:
  Oskar Ohakas;
  Mari Maasikas;


  Nimed pikkusega 4 ja rohkem:
  Juku Juurikas varuks 0;
  Juku Kaalikas varuks 0;
  Kalle Kaalikas varuks 1;
  Mari Maasikas varuks 0;
  Oskar Ohakas varuks 1;


ASP.NET vahenditega sama XSL-lehte käivitades on põhjust veebilehele luua kohad 
parameetrite väärtuste sisestamiseks. Siinses näites kasutatakse selle tarbeks 
tekstivälju. Pöörates tähelepanu lehekülje päisele näeb, et sedakorda on põhjust 
eraldi koodifaili loomiseks, millest siis veebileht päritakse. 


<%@ Page Language="C#" AutoEventWireup="true" CodeFile="parameetrid.aspx.cs" 
Inherits="parameetrid" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Parameetritega leht</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
      <pre>
        <asp:Xml ID="xml1" runat="server" DocumentSource="~/inimesed1.xml" 
TransformSource="~/inimesed4a.xslt" />
       </pre>
        <br />
        Otsitav tekst: <asp:TextBox ID="kast1" runat="server" /><br />
        Miinimumpikkus: <asp:TextBox ID="kast2" runat="server" /><br />
        <asp:Button runat="server" text="Sisesta"  />
    </div>
    </form>
</body>
</html>


Eraldi koodifailis, lehe laadimisel käivituvas meetodis nimega Page_Load on 
kirjas, et millised parameetrite väärtused tuleb XSL-failile edasi anda. 
Eelnevast XSL-failis on näha, et selle algusosas on defineeritud kaks 
parameetrit. Parameeter nimega otsing vaikeväärtusega "ar" ning parameeter 
pikkus väärtusega 5. Siinses näites kirjutatakse otsinguparameeter alati üle 
tekstiväljast tuleva väärtusega. Pikkus asendatakse aga vaid juhul, kui selle 
jaoks mõeldud tekstiväljas nimega kast2 oli väärtus, mida on võimalik arvuks 
teisendada. XsltArgumentList-tüüpi muutujasse kogutakse parameetrid ja nende 
väärtused kokku ning siis pannakse vastav parameetrite loetelu transformatsiooni 
eest hoolitseva elemendi külge. 



using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Xml.Xsl;

public partial class parameetrid : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        XsltArgumentList p = new XsltArgumentList();
        p.AddParam("otsing", "", kast1.Text);
        int abi;
        if(int.TryParse(kast2.Text, out abi)){
            p.AddParam("pikkus", "", kast2.Text);
        }
        xml1.TransformArgumentList = p;
    }
}

Nulemusena võib siis näha sisestatud andmetele vastavat tulemust veebilehel. 
Element pre aitas tekstina tulnud andmed viisakalt eraldi ridadele joondada.

        
        Nimed, mis sisaldavad kombinatsiooni M:
        Mari Maasikas;
        

        Nimed pikkusega 2 ja rohkem:
        Juku Juurikas varuks 2;
        Juku Kaalikas varuks 2;
        Kalle Kaalikas varuks 3;
        Mari Maasikas varuks 2;
        Oskar Ohakas varuks 3;
        
      

Otsitav tekst:M
Miinimumpikkus:2

Ülesandeid

* Koosta tervitav XSL-leht, mille pealkiri antakse ette parameetriga
* Anna parameetrina ette praeguse aasta number. Väljasta iga inimese vanus selle 
aasta lõpuks.
* Lase kasutajal tekstiväljast anda ette vähim ja suurim sünniaasta, mille vahel 
olevate inimeste andmeid näidatakse.



Mallid, alamprogrammid

Enamikes enesest lugu pidavates programmeerimiskeeltes on eraldiseisvate ning 
korduvalt ettevõetavate toimingute tarbeks olemas alamprogrammid või midagi 
sarnast. XSLis on selleks tarbeks mallid. Kirjeldatakse ära, kuidas mingeid 
andmeid väljundis näidata ning hiljem saab selle malli sobivas kohas välja 
kutsuda. Järgnevas näiteks on omaette malliks tehtud saatja aadress. Et kui seda 
vaja kuhugi kirjale lisada, siis piisab vaid vastavast väljakutsest. 
Defineerimise kohal siis

       <xsl:template name="saatjaaadress">

ning väljakutsel

       <xsl:call-template name="saatjaaadress" />

Kogu kood tervikuna:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="saatjaaadress">
      Tallinna Ülikooli Informaatika Instituut, Narva maantee 25-419, 10120, 
Tallinn
    </xsl:template>

    <xsl:template match="/">
       Lugupeetud vilistlane, kutsume teid taas vana kooli vaatama!
       <br />
       <xsl:call-template name="saatjaaadress" />
    </xsl:template>
</xsl:stylesheet>

Ja nagu koodi lugedes aimata võib, tulemuseks on teade koos sinna lõppu lisatud 
saatja aadressiga.


Lugupeetud vilistlane, kutsume teid taas vana kooli vaatama!
Tallinna Ülikooli Informaatika Instituut, Narva maantee 25-419, 10120, Tallinn


Et malli töö tulemust vastavalt andmetele muuta saaks, selleks tuleb ette anda 
parameetrid. Malli enese algusesse tuleb kirjutada, et millise nimega parameeter 
on.

        <xsl:param name="enimi" />

Koodis parameetri väärtuse kasutamiseks tuleb sinna dollarimärk ette panna. 

        Tere, <xsl:value-of select="$enimi" />


Väljakutsel saab temale ette anda tavalise väärtuse. Et Siim on etteantud 
tekstikonstant, teda ei võeta XML-faili seest, selleks on nimele ülakomad ümber 
pandud. 

        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="'Siim'" />
        </xsl:call-template>

XSLi kood tervikuna

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="tervitus">
        <xsl:param name="enimi" />
        Tere, <xsl:value-of select="$enimi" />
    </xsl:template>

    <xsl:template match="/">
        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="'Siim'" />
        </xsl:call-template>
    </xsl:template>
</xsl:stylesheet>


Ning tekkinud väljund:

Tere, Siim

Kui nimi võetakse XMList, siis tuleb määrata asukoht, kust see leida. Praegusel 
juhul antakse alamprogrammile parameetrina kaasa esimese inimese eesnimi.

    <xsl:template match="/">
        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="inimesed/inimene[1]/eesnimi" />
        </xsl:call-template>
    </xsl:template>

Käivitamisel tervitatakse teda rõõmsasti.

Tere, Juku


Malli parameetriks ei pruugi olla üksiks väärtus. Selleks võib olla ka etteantud 
kohast algav andmepuu (nt. terve inimene kõikide tema juurde kuuluvate 
andmetega) või siis andmekogum (massiiv). Järgnevas näites pruugitaksegi viimast 
varianti. Loetelu saamiseks käiakse xsl:for-each tsükliga läbi kõik etteantud 
andmestiku elemendid. Ning malli väljakutsel olev inimesed/inimene/eesnimi 
annabki kõikide vastavas XML-failis olevate inimeste eesnimed parameetrina 
kaasa.


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="loetelu">
        <xsl:param name="andmestik" />
        <ul>
            <xsl:for-each select="$andmestik">
                <li>
                    <xsl:value-of select="." />
                </li>
            </xsl:for-each>
        </ul>
    </xsl:template>

    <xsl:template match="/">
        <h1>Inimeste eesnimede loetelu</h1>
        <xsl:call-template name="loetelu">
            <xsl:with-param name="andmestik" select="inimesed/inimene/eesnimi" /
>
        </xsl:call-template>
    </xsl:template>
</xsl:stylesheet>


 
Tulemuseks on viisakas loetelu.

      <h1>Inimeste eesnimede loetelu</h1>

<ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li>Mari</li>
  <li>Oskar</li>
</ul>

Ülesandeid

* Koosta mall, mis väljastaks tärnidest rea. Katseta.
* Koosta mall, mis trükiks etteantud teksti välja punaselt.
* Võrreldes eelmisega saab ka värvi anda ette malli väljakutsel

* Koosta mall, mis trükib etteantud elemendist loeteluna välja kõikide 
alamelementide nimed ja nende väärtused.
* Koosta mall, mis saab etta sarnase struktuuriga elementide (näiteks inimeste) 
massiivi ning väljastab nende alamelementide tulemused tabelina. Katseta 
mitmesuguste sisendandmete korral.