Introducere si caracterizare l9v19vp
Interfete si implementari
DOM Core - nivelul 1
DOM nivelul 1 pentru HTML
DOM nivelul 2
XML prin SAX
Concluzii

--------------------------------------------------------------------------------

1. Introducere si caracterizare
Modelul orientat-obiect pentru documente (DOM) reprezinta o interfata de programare a aplicatiilor destinate sa prelucreze documentele HTML si XML, independenta de platforma si de limbaj, definind structura logica a documentelor si modalitatile de accesare si de modificare a lor.

Aceasta structura logica este una arborescenta, orientata-obiect: documentele sint modelate utilizind obiecte, iar modelul nu ofera doar o vizualizare structurata a documentului, ci si o maniera de specificare a comportamentului lui si a obiectelor componente. Fiecare element al unui document poate fi privit, deci, ca un obiect, fiecare obiect avind identitate si propriile sale functii. Exact ca si in modelul obiect din cadrul metodologiei orientate-obiect, DOM identifica:

interfetele si obiectele utilizate sa reprezinte si sa manipuleze un document;

semantica acestor interfete si obiecte (inclusiv comportamentul si atributele lor);

relatiile si dependentele intre aceste interfete si obiecte.

Structura documentelor SGML (Standard Generalized Markup Language) era in mod traditional reprezentata de un model de date abstracte, nu printr-unul orientat-obiect. Astfel, modelul vechi era centrat asupra datelor, pe cind in modelul obiect datele sint incapsulate in obiecte, ascunse si/sau protejate de prelucrarea externa directa. Functiile (metodele) asociate acestor obiecte determina modul in care obiectele pot fi manipulate.

Modelul avut in discutie in continuare consta din doua parti:

nucleul DOM utilizat sa reprezinte functionalitatea documentelor XML generale (denumit si DOM Core);

DOM HTML, bazat pe DOM Core, defineste o extindere a modelului obiect pentru documentele HTML.

O implementare a modelului trebuie sa aiba in vedere implementarea obligatorie a tuturor interfetelor fundamentale definite de DOM Core, conform semanticii DOM. Mai mult, trebuie sa implementeze cel putin una dintre interfetele HTML si XML, impreuna cu semanticile aferente.

Cercetarile intreprinse de Consortiul Web in ultimii ani vizeaza mai multe nivele (stadii) de specificare a modelului. Nivelul 0 (pentru HTML) a fost nivelul de functionalitate a versiunilor 3 ale navigatoarelor Netscape si Internet Explorer. Nivelul 1 de care ne vom ocupa in detaliu deja este recomandare standardizata incepind cu octombrie 1998, in prezent lucrindu-se la standardizarea nivelului 2.

Nivelul 1 nu defineste in nici un fel raspunsul la evenimente, cu toate ca a fost influientat major de HTML Dinamic, lasind in responsabilitatea nivelului 2 specificarea acestora. DOM nu este o specificare binara si nu defineste nici o forma de interoperabilitate la nivel binar, in contrast cu alte tehnologii.

DOM reprezinta un model obiectual ce specifica interfete si nu este un set de structuri de date (abstracte). De asemeni, nu defineste semantica detaliata pentru HTML sau XML. Tehnologia COM, ca si CORBA, reprezinta o modalitate, independenta de limbaj, de a specifica interfete si obiecte, iar DOM are vedere numai documentele HTML si XML, putind fi implementat, fie folosind COM sau CORBA, fie limbaje ca Java sau ECMAScript.

2. Interfete si implementari
In cadrul modelului sint specificate interfete ce pot fi ulterior utilizate in prelucrarea documentelor XML/HTML. Aceste interfete sint abstractizari, similare claselor abstracte de baza din C++, oferind o modalitate de accesare si de modificare a reprezentarii interne a unui document in cadrul unei aplicatii. Interfetele nu implica o implementare concreta, particulara, a functiilor pe care le definesc, fiecare aplicatie DOM putind stoca documentele in oricare reprezentare interna convenabila, atita timp cit interfetele DOM sint suportate. DOM este conceput sa evite dependenta de implementare.

In cadrul nivelului 1 al modelului intentionat s-au limitat anumite functionalitati. Nivelele ulterioare, bazate pe DOM Core, vor oferi:

un model structural pentru submultimile elementelor interne si externe ale documentelor;

validare prin intermediul schemelor (eventual prin XML Schema);

controlul reprezentarii documentelor prin foi de stiluri (CSS sau XSL);

controlul accesului;

siguranta in executie;

evenimente.

3. DOM Core - nivelul 1
Nucleul modelului defineste multimea minimala, de baza, a obiectelor si interfetelor pentru accesarea si modificarea continutului obiectelor document.

3.1 Structura
DOM reprezinta documentele ca o ierarhie de obiecte-nod care la rindul lor pot implementa alte interfete, eventual mai specializate. Anumite tipuri de noduri pot avea noduri copii (descendenti) de diverse tipuri, desigur. Altele pot fi noduri frunza, lipsite de descendenti.

Tipurile fundamentale ale nodurilor DOM sint cele din urmatorul tabel:

Tip Descendenti
Document Element, ProcessingInstruction, Comment, DocumentType
DocumentFragment Element, ProcessingIntruction, Comment,
Text, CDATASection, EntityReference
DocumentType -
EntityReference Element, ProcessingIntruction, Comment, Text,
CDATASection, EntityReference
Element Element, Text, Comment, ProcessingIntruction,
CDATASection, EntityReference
Attr Text, EntityReference
ProcessingIntruction -
Comment -
Text -
CDATASection -
Notation -
Entity Element, ProcessingIntruction, Comment,
Text, CDATASection, EntityReference

Tipurile de noduri si descendentii lor
In plus, DOM specifica o interfata numita NodeList pentru a procesa liste ordonate de noduri (precum descendenti ai unui nod sau elemente returnate de metoda Element.getElementByTagName()) si o interfata NamedNodeMap pentru liste neordonate de noduri referite de nume de atribute (numele de atribute sint numele atributelor unui element (marcator) HTML sau XML; e.g. align este atribut al tag-ului <p>).

In cadrul modelului, NodeList si NamedNodeMap sint dinamice, in sensul ca orice modificare a structurii unui document implica automat si reactualizarea tuturor instantelor NodeList si NamedNodeMap, respectiv. Orice schimbari ale unui nod al arborelui de noduri sint reflectate in toate referintele la acel nod in NodeList-ele si MapNodeMap-ele asociate.

3.2 Tipuri de interfete
DOM Core prezinta doua tipuri seturi diferite de interfete pentru un document XML/HTML, una prezentindu-l dintr-o perspectiva "orientata obiect" (ierarhie de mosteniri de obiecte) si cealalta "simplificata" (permitind ca toate operatiunile sa se execute prin intermediul interfetei Node).

3.3 Tipul fundamental DOMString
Se defineste tipul fundamental DOMString ca fiind o secventa de coduri pe 16 biti (folosind codificarea UTF-16):

typedef sequence<unsigned short> DOMString;
3.4 Interfete fundamentale
Interfetele denumite fundamentale trebuiesc implementate in intregime conform specificatiilor DOM. Ele sint urmatoarele:

DOMException defineste mecanismul de raspuns la aparitia exceptiilor. Exceptiile apar in circumstante speciale, de exemplu cind o operatiune este imposibil de executat (pierdere de date, implementare devenita instabila etc.). Anumite limbaje de programare nu au implementat conceptul de exceptie. Pentru implementarile DOM in astfel de limbaje, raportarea exceptiilor se va realiza folosind mecanismele native de semnalare a erorilor.

Definitia conform standardului IDL (Interface Definition Language, folosit in specificatiile CORBA 2.2 si adoptat de DOM) este:

exception DOMException A unsigned short code;
S;

Codurile de exceptie sint numere intregi indicind ce tip de eroare a aparut. Pot fi folosite o serie de constante predefinite:

Constante predefinite Semnificatie
INDEX_SIZE_ERR Valoare de index invalida
DOMSTRING_SIZE_ERR Lungime invalida a unui sir de caractere
HIERARCHY_REQUEST_ERR Inserare incorecta a unui nod
WRONG_DOCUMENT_ERR Utilizare de noduri intr-un alt document deferit de cel la care apartineau
INVALID_CHARACTER_ERR Aparitia unui caracter invalid (de exemplu, in componenta unui nume de marcator)
NOT_FOUND_ERR Incercare de creare a unei referinte a unui nod intr-un context eronat
NOT_SUPPORTED_ERR Implementarea nu suporta facilitatea ceruta de aplicatie

Coduri de eroare folosite de DOMException
DOMImplementation este o interfata oferind metodele pentru executarea operatiunilor independente de orice instanta particulara a unui document. In fapt, nivelul 1 nu specifica vreo modalitate de creare a unei instante document, lasind implementatorilor aceasta responsabilitate:

interface DOMImplementation A boolean hasFeature(in DOMString feature, in DOMString version);
S;

Metoda hasFeature testeaza daca implementarea poate furniza o anumita operatiune. Pentru DOM nivelul 1, parametrii de intrare pot avea valorile "HTML" sau "XML" pentru feature si "1.0" pentru version, respectiv.

DocumentFragment este un obiect document minimal. In multe situatii nu trebuie lucrat cu intregul document, ci doar cu diverse fragmente ale sale. Arborele de noduri ale unui fragment de document este un sub-arbore al structurii de noduri a documentului luat in intregul lui. In functie de implementare DocumentFragment poate reprezenta o entitate XML, un element HTML sau chiar un grup de elemente:

interface DocumentFragment : Node A
S;

Dupa cum se remarca, DocumentFragment are ca interfata de baza interfata Node pe care o vom prezenta mai jos.

Document reprezinta un document XML/HTML, conceptual fiind radacina arborelui de noduri-obiecte ale documentului si oferind accesul la informatiile continute de acesta. Din moment ce elementele (marcatorii), nodurile de tip text, comentariile, instructiunile de procesare (ce pot apare mai ales in cadrul documentelor XML) nu pot exista in afara contextului unui document, interfata Document contine de asemeni metodele de baza necesare pentru a crea aceste obiecte. Obiectele de tip Node instantiate vor avea un atribut numit ownerDocument care le va asocia documentului in al carui context au fost create.

Interfata Document are ca membri trei atribute:

doctype de tip DocumentType reprezinta declaratia tipului de document (DTD) asociata unui document particular. Pentru HTML, DTD este definita de Consortiul Web in specificatiile limbajului si nu se asociaza niciodata documentelor deoarece nu poate fi modificata. Documentele XML pot avea sau nu definite DTD-urile aferente, fiecare DTD in parte specificind un tip de document XML. In DOM nivelul 1, doctype este declarat read-only, deci nu poate fi alterat.

implementation de tip DOMImplementation specifica implementarea sau implementarile disponibile pentru procesarea documentului.

documentElement de tip Element specifica nodul radacina de accesare a structurii arborescente a documentului (pentru HTML este "HTML", evident).

Ca metode se pot mentiona:

createElement() creeaza un element de un anumit tip (astfel se pot insera noi tag-uri intr-un document HTML, asa cum se permite in JavaScript de exemplu);

createTextNode(), createComment(), createCDATASection(), createProcessingInstruction() vor genera noduri-obiect de tip text, comentariu, sectiune Character DATA, instructiune de procesare, respectiv;

createAttribute() creeaza un obiect atribut care va fi asociat unui element specificat;

getElementsByTagName() va returna o lista ordonata de noduri NodeList pentru toate elementele corespunzatoare unui tag, ordonarea nodurilor realizindu-se prin parcurgerea in preordine a arborelui.

Un exemplu:
Presupunem ca avem documentul HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head></head>
<body>
<ul>
<li>Sectiunea 1
<li>Sectiunea 2
<li>Sectiunea 3
</ul>
<hr>
<!-- Sfirsit -->
</body>
</html>

Arborele de noduri-obiect asociat documentului este ilustrat de figura urmatoare:

Arborele de obiecte-noduri asociat unui document HTML getElementByTagName("li") va returna o lista de tip NodeList cu trei obiecte corespunzatoare nodurilor 6, 7 si 8 (in aceasta ordine) figurate mai sus.

getElementByTagName("*") va furniza toate nodurile arborelui, in preordine.

Node este o interfata importanta care defineste un tip primar pentru intregul model DOM, reprezentind un singur nod in cadrul arborelui asociat unui document. Atributele nodeName, nodeValue si attributes sint introduse ca mecanism pentru furnizarea informatiilor despre noduri fara conversie de tipuri (vizualizare "simplificata", nu una "orientata-obiect"). Fiecare nod va avea asociata o lista ordonata continind descendentii sai, plus atribute specificind nodul parinte, primul si ultimul nod copil, daca exista. Ca metode importante se pot mentiona cele manipulind nodurile copil: insertBefore(), replaceChild(), removeChild(), appendChild(), cloneChild(), hasChildNodes() etc.

NodeList reprezinta o interfata care ofera un tip abstract de data pentru colectiile ordonate de noduri, fara a defini sau restrictiona cum aceasta colectie va fi implementata. Fiecare implementator va decide ce tipuri de date concrete vor fi utilizate. Membrii colectiei vor fi accesati prin intermediul unui index intreg, numerotarea incepind cu valoarea 0.

interface NodeList A

Node item(in unsigned long index); readonly attribute unsigned long lenght;
S;

NamedNodeMap este folosita pentru reprezentarea abstracta a colectiilor neordonate de noduri, accesate prin intermediul numelui. NamedNodeMap nu deriva din NodeList.

interface NamedNodeMap A
Node getNamedItem(in DOMString name);
Node setNamedItem(in Node arg) raises (DOMException);
Node removeNamedItem(in DOMString name) raises (DOMException);
Node item(in unsigned long index); readonly attribute unsigned long lenght;
S;

CharacterData este o interfata ce extinde Node cu un set de atribute si metode pentru accesarea datelor de tip caracter in cadrul DOM.

Attr reprezinta un atribut din cadrul unui obiect de tip Element. In mod tipic, valorile permise ale atributelor sint definite in DTD-ul corespunzator documentului. In DOM, Attr nu se considera ca apartine arborelui de noduri-obiect al documentului. Atributele de tip Attr sint vazute ca proprietati ale elementelor (marcatorilor), putind fi asociate nodurilor Element continute de obiecte de tip DocumentFragment.

interface Attr : Node A readonly attribute DOMString name; readonly attribute boolean specified; attribute DOMString value;
S;

Pentru documentele HTML/XML valorile atributelor nu sint doar siruri de caractere. Majoritatea valorilor atributelor in DOM vor fi considerate, insa, de tip caracter, conform tabelului:

Tipuri DTD Tipuri DOM
CDATA DOMString
Lista de valori
(left|right|center) DOMString
Valoare unica
(noshade) boolean
Numar long int

Corespondenta dintre tipurile DTD si tipurile DOM
Element este o interfata derivind din Node care ofera metode de accesare a obiectelor Attr, prin nume sau prin valoare: getAttribute(), setAttribute(), removeAttribute(), getAttributeNode(), setAttributeNode(), removeAttributeNode().

De exemplu, pentru fragmentul de document XML:

...
<section id="demo" version="draft">
...
</section>
...

vom avea un obiect Element pentru care tagName="section". Atunci, getAttribute("id") va returna sirul "demo", iar getAttribute("version") va da "draft".

Text este o interfata ce reprezinta continutul textual (date siuri de caractere) al unui nod de tip Element sau Attr. Daca intre tag-urile de inceput si de sfirsit nu exista alte tag-uri, textul va fi continut intr-un obiect implementind interfata Text.

Comment reprezinta continutul unui comentariu delimitat de <!-- si -->:

interface Comment : CharacterData A
S;

3.5 Interfete extinse
Modelul extinde interfetele definite de DOM Core, pentru a suporta implementari avind in vedere procesarea documentelor HTML. Interfetele extinse sint CDATASection, DocumentType, Notation, Entity, EntityReference si ProcessingInstruction prezentate in detaliu de specificatiile DOM.

4. DOM nivelul 1 pentru HTML
Modelul pentru HTML extinde functionalitatile descrise in DOM Core. Scopurile modelului DOM HTML sint urmatoarele:

specializarea interfetelor si adaugarea de noi facilitati pentru specificarea orientata-obiect a documentelor HTML;

oferirea unor mecanisme convenabile pentru operatii comune si frecvente asupra documentelor HTML.

DOM pentru HTML defineste o interfata generica denumita HTMLCollection care reprezinta o lista abstracta de noduri. Un nod poate fi accesat fie printr-un index ordinal, fie prin nume, fie prin atributele de identificare:

interface HTMLCollection A readonly attribute unsigned long lenght;
Node item(in unsigned long index);
Node namedItem(in DOMString name);
S;

Pentru fiecare marcator definit de specificatiile HTML 4, se ofera o interfata, ca de exemplu:

Element HTML Interfata DOM
HTML HTMLDocument
HEAD HTMLHeadElement
META HTMLMetaElement
BODY HTMLBodyElement
FORM HTMLFormElement
UL HTMLUListElement
OL HTMLOListElement
DIV HTMLDivElement
... ...

Citeva elemente HTML si interfetele DOM corespunzatoare
Cu exceptia interfetei HTMLDocument, toate celelalte interfete HTMLXXXElement sint derivate din interfata generica HTMLElement a carei definitie IDL este:

interface HTMLElement : Element A attribute DOMString id; attribute DOMString title; attribute DOMString lang; attribute DOMString dir; attribute DOMString className;
S;

Atributele id, title, lang, dir, className au semantica prezentata in specificatiile HTML 4.

Astfel, pentru elementul PRE avem urmatoarea ierarhie de interfete:

Ierarhia de interfete pentru un element HTML
5. DOM nivelul 2
5.1 DOM Core pentru nivelul 2
Nivelul al doilea al modelului de baza defineste extensii ale interfetelor nivelului 1, oferind functionalitati noi ca posibilitatea de a crea un obiect Document sau de a copia un nod dintr-un document intr-altul.

O serie din interfetele noi:

DOMImplementation2 este extinsa cu metodele necesare pentru crearea unei instante a unui document XML:

interface DOMImplementation2 : DOMImplementation A
DocumentType createDocumentType(in DOMString name, in DOMString publicID, in DOMString systemID) raises(DOMException);
Document createDocument(in DOMString name, in DocumentType doctype) raises(DOMException);
S;

Metoda createDocumentType va crea un nod vid de tip DocumentType avind Node.ownerDocument setat null, iar createDocument va crea un obiect Document XML.

Document2 extinde interfata Document cu o metoda ce permite importarea nodurilor dintr-un alt document:

interface Document2 : Document A
Node importNode(in Node importedNode, in boolean deep);
S;

Nodul returnat nu are parinte (parentNode este vid). Se creeaza un obiect nod apartinind documentului care il importa cu valorile atributelor identice cu cele ale nodurilor sursa nodeName si nodeType. Nodul sursa nu va fi alterat. Nodurile de tip Entity, Document, DocumentType si Notation nu pot fi importate.

Parametrul importedNode desemneaza nodul de importat, iar deep daca este true se importa in mod recursiv subarborele avind ca nod radacina nodul importat.

5.2 Foi de stiluri descrise de DOM nivelul 2
In cadrul nivelului 2 se defineste un set de interfete de baza utilizate sa reprezinte orice tip de foi de stiluri:

StyleSheet este o interfata abstracta de baza pentru oricare tip de foi de stiluri, reprezentind o unica foaie de stiluri asociata unui document structurat. In HTML aceasta reprezinta fie o foaie de stiluri externa, inclusa prin marcatorul LINK, sau interna, prin STYLE. In XML, aceasta interfata reprezinta o foaie de stiluri externa, inclusa printr-o instructiune de procesare a foilor de stiluri.

interface StyleSheet A readonly attribute DOMString type; attribute boolean disabled; readonly attribute Node ownerNode; readonly attribute StyleSheet parentStyleSheet; readonly attribute DOMString href; readonly attribute DOMString title; readonly attribute MediaList media;
S;

StyleSheetList ofera o colectie ordonata, abstracta, de foi de stiluri:

interface StyleSheetList A readonly attribute unsigned long length;
StyleSheet item(in unsigned long index);
S;

MediaList ofera o abstractizare a unei colectii ordonate de tipuri de medii (cum ar fi text, audio sau video), fara a constringe implementarea acesteia.

interface MediaList A attribute DOMString cssText; readonly attribute unsigned long length;
DOMString item(in unsigned long index); void delete(in DOMString oldMedium) raises(DOMException); void append(in DOMString newMedium) raises(DOMException);
S;

DocumentStyle specifica un mecanism de accesare a foilor de stiluri asociate unui document:

interface DocumentStyle A readonly attribute StyleSheetList styleSheets;
S;

5.3 Evenimente
Scopurile modelului sint urmatoarele:

proiectarea unui sistem generic de evenimente care sa permita: definirea activitatilor ce vor fi executate la aparitia unui eveniment, descrierea fluxului de evenimente printr-o structura arborescenta si oferirea unor informatii contextuale pentru fiecare eveniment in parte. In plus se doresc: conceperea unui set standard de evenimente pentru controlul interfetei cu utilizatorul si notificarea modificarilor (de structura) ale documentelor.

oferirea unui subset comun al evenimentelor utilizate de navigatoarele actuale.

Cerintele de proiectare:

fluxul de evenimente

Modelul trebuie sa suporte mai multe proceduri de detectare a evenimentelor asociate unui nod si sa poata receptiona evenimente inainte si dupa ce o implementare DOM a procesat un eveniment.

mecanismul de detectare a aparitiei evenimentelor

Modelul trebuie sa defineasca un mecanism programabil de specificare a modului de detectare a evenimentelor (sistem si definite de utilizator). Modelul trebuie, de asemeni, sa defineasca interactiunea intre acest mecanism si cel de specificare a evenimentelor din HTML 4. Modelul trebuie sa defineasca reguli de interactiune a evenimentelor definite fie la nivelul marcatorilor, fie prin stiluri sau prin intermediul script-urilor.

informarea contextuala

Este necesar sa se specifice un mecanism de accesare a informatiilor contextuale referitoare la orice eveniment survenit.

tipuri de evenimente

Modelul trebuie sa permita crearea unor multimi de evenimente, diferite de cele specificate in cadrul DOM. Modelul trebuie in plus sa suporte evenimente ale interfetei cu utilizatorul si sa defineasca un set de evenimente privind modificarea de structura sau de stil a unui document.

Modelul DOM nivelul 2 defineste urmatoarele tipuri de evenimente:

Evenimente trimise de interfata cu utilizatorul (navigator Web) sint: click, mousedown, mouseup, mouseover, mousemove, mouseout, keypress, keydown, keyup, resize, scroll.

Evenimente de modificare a structurii documentului: subtreeModified, nodeInserted, nodeRemoved, attrModified etc.

Evenimente HTML (definite de specificatiile HTML): load, unload, abort, error, select, submit, focus, blur si altele.

Interfetele din cadrul modelului sin urmatoarele:

EventTarget este implementata de toate nodurile:

interface EventTarget A void addEventListener(in DOMString type, in EventListener listener, in boolean useCapture); void removeEventListener(in DOMString type, in EventListener listener, in boolean useCapture);

S;

EventListener este mecanismul primar de manipulare a evenimentelor:

interface EventListener A void handleEvent(in Event event);
S;

Event este o interfata utilizata sa ofere informatii contextuale pentru un eveniment, informatii folosite de o procedura de tratare a acelui eveniment.

interface Event A attribute DOMString type; attribute Node target; attribute Node currentNode; attribute unsigned short eventPhase; void preventBubble(); void preventCapture(); void preventDefault();
S;

5.4 Filtre si iteratori
Interfetele Iterator, Filter si TreeWalker permit parcurgerea simpla si eficienta a subarborilor, listelor de noduri sau rezultatelor interogarilor efectuate asupra documentelor. Interogarile inca nu sint specificate in cadrul nivelului 2.

Iteratori
Un iterator permite ca nodurile dintr-o structura de date sa fie returnate in mod secvential. Dupa crearea unui iterator, prima apelare a metodei nextNode() va returna primul nod. Daca nu exista noduri, rezultatul va fi null. Un iterator poate fi activ si cind o structura de date este editata (dinamica). Stergerile si adaugarile de date nu vor invalida iteratorii niciodata.

Iteratorii se creeaza prin metoda createNodeIterator. Nodurile de tip iterator vor fi accesate prin intermediul interfetei NodeIterator prezentata in continuare:

interface NodeIterator A readonly attribute long whatToShow; readonly attribute NodeFilter filter;
Node nextNode();
Node previousNode();
S;

Atributul whatToShow stabileste tipul de noduri ce vor fi returnate de iterator: toate nodurile (SHOW_ALL), elementele (SHOW_ELEMENT), texte (SHOW_TEXT), noduri-document (SHOW_DOCUMENT) etc.

Filtre
Fiecare filtru contine o functie scrisa de utilizator care determina ca un nod sa fie filtrat (disponibil) sau nu. Un filtru este utilizat de un iterator care aplica filtrul fiecarui nod. Daca filtrul respinge nodul, iteratorul il ignora, trecind la urmatorul nod. Filtrele sint usor de scris din moment ce nu este necesar a se cunoaste structura de date asupra carora vor opera. Filtrele pot fi refolosite cu succes si in cadrul altor interatori.

interface NodeFilter A
// Constante returnate de acceptNode() const short FILTER_ACCEPT = 1; const short FILTER_REJECT = 2; const short FILTER_SKIP = 3;

short acceptNode(in Node n);
S;

Un exemplu
Vom considera un filtru care gaseste ancorele interne (definite de un tag <A NAME="....">) dintr-un document HTML. Implementarea este data mai jos:

class NamedAnchorFilter implements NodeFilter
A short acceptNode(Node n)
A if (n instanceof Element)
A // nodul n este un element (tag)
Element e = n; if (e.getNodeName() != "A") return FILTER_SKIP; if (e.getNodeNameAttributeNode("NAME") != NULL) return FILTER_ACCEPT;
S return FILTER_SKIP;
S
S

Pentru folosirea filtrului, utilizatorul va trebui sa-l instantieze si sa creeze un iterator:

NamedAnchorFilter myFilter;
NodeIterator iterator = document.createNodeIterator(node,
SHOW_ELEMENT, myFilter);

Interfata TreeWalker
Complementara interfetei Iterator, TreeWalker ofera o prezentare arborescenta a nodurilor dintr-un subarbore. Navigarea prin nodurile unui document folosind metode interfetei TreeWalker poate utiliza filtre.

interface TreeWalker A readonly attribute long whatToShow; readonly attribute NodeFilter filter;
Node current();
Node parentNode();
Node firstChild();
Node lastChild();

DOM nivelul 2 defineste si interfata DocumentIF continind metode pentru crearea iteratorilor meniti sa traverseze (prin metoda depth first search (DFS), pre-ordine) nodurile unui document XML/HTML.

interface DocumentIF A short createNodeIterator(in Node root, in short whatToShow, in NodeFilter filter);
S;

6. XML prin SAX
Am prezentat mai sus un model obiectual destinat procesarii documentelor XML, model denumit DOM (Document Object Model). In continuare vom ilustra concret cum, prin intermediul DOM, putem interveni in structura unui document XML, modificindu-l in mod dinamic. Analiza documentelor XML se poate realiza independent de navigator sau chiar in cadrul navigatorului Web.

6.1 Interfata SAX
Pentru implementarea DOM se pot utiliza mai multe metode, una dintre cele mai facile fiind SAX (Simple API for XML), o interfata simpla de programare destinata manipularii documentelor XML, insa nu atit de completa precum DOM. Majoritatea celor care se ocupa de XML vad structura unui document in forma arborescenta, iar modelul DOM ofera din plin posibilitatea de a manipula informatiile in aceasta maniera. Din punctul de vedere al implementatorilor aceasta abordare are numeroase deficiente (maniera de stocare interna a arborelui de obiecte, parcurgerea lui etc.). Unul dintre beneficiile utilizarii interfetei SAX este ca arborele nu mai trebuie construit, dindu-i-se programatorului o alta cale de manipulare a documentului XML. In plus, SAX poate ajuta la convertirea datelor din formatul arborescent DOM in alt format mai comod, iar pentru parsare nu este necesar a se memora intreaga informatie XML ci numai partile dorite.

In mod uzual, SAX are implementari in C sau Java.

SAX in Java
Implementarile Java pentru SAX sint incapsulate in pachetul de clase org.xml.sax care poate fi obtinut gratuit prin Internet. Ca drivere de parsare SAX se pot mentiona IBM XML for Java si XP (James Clark). Alternativele sint SAXDOM sau MSXML (Microsoft), iar daca se doreste o procesare mai elaborata a unui document XML se poate utiliza un servlet numit DOMit, dezvoltat de IBM. Drept aplicatii bazate pe SAX putem enumera: JUMBO (vizualizator de documente XML), FREE-DOM (implementare libera a unor biblioteci Java de analiza XML), SAXON (interfata de nivel ridicat bazata pe SAX), Alfred XML Parser si altele. Desigur, exista parsere XML si pentru Perl, Python, Delphi etc. disponibile pentru diverse platforme.

Vom ilustra succint pachetul de distributie SAX org.xml.sax care se compune din 11 clase si interfete de baza, la care se alatura 3 clase suplimentare si 4 clase demonstrative, totul divizindu-se in 5 grupuri:

interfete implementate de analizorul (parserul) documentelor XML: Parser si AttributeList (obligatorii), plus Locator (optionala); analizorul XML se mai denumeste si SAX Driver.

interfete implementate de aplicatia care doreste sa manipuleze documentele XML via driverul SAX: DocumentHandler, ErrorHandler, DTDHandler, EntityResolver pentru procesarea documentului, raportarea erorilor, analiza definitiei tipului de document (Document Type Definition) si rezolvarea entitatilor XML, respectiv. Toate aceste clase pot fi utilizate optional.

clase SAX standard (care pot fi folosite atit de parsere cit si de aplicatii): InputSource, SAXException, SAXParseException si HandlerBase, toate acestea fiind implementate in intregime de SAX.

clase aditionale specifice Java, complet implementate: ParserFactory, AttributeListImpl si LocatorImpl.

clase demonstrative a capabilitatilor SAX, in fapt aplicatii Java: SystemIdDemo, ByteStreamDemo, CharacterStreamDemo si DemoHandler. Aceaste clase nu fac parte din specificatiile de baza ale SAX si pot sa nu apara in implementari SAX in alte limbaje.

Interfata de baza a interfetei SAX este org.xml.sax.Parser care trebuie implementata de toate analizoarele XML, permitind aplicatiilor sa inregistreze metode de raspuns la diverse tipuri de evenimente si sa initializeze procesul de analiza a documentelor XML incarcate via URI sau printr-un flux de caractere.

Interfata org.xml.sax.DocumentHandler reprezinta interfata principala pe care trebuie s-o implementeze o aplicatie utilizind SAX. Daca aplicatia doreste sa fie informata asupra evenimentelor ce pot interveni in procesul de analiza, va implementa aceasta interfata si va folosi o instanta a ei prin intermediul metodei setDocumentHandler in cadrul parserului SAX. Parserul va utiliza instanta pentru a raporta diverse evenimente precum inceputul/sfirsitului unui element XML (startElement, endElement), a unei instructiuni de procesare etc. Ordinea evenimentelor va fi in fapt data de ordinea de aparitie fizica a diverselor elemente ale documentului XML care se doreste a fi analizat.

Pentru procesarea atributelor asociate elementelor XML se va folosi interfata org.xml.sax.AttributeList. Iata un exemplu de iterare a intregii liste de atribute asociate elementelor unui document XML:

public void startElement (String ename, AttributeList atts) A for (int i = 0; i < atts.getLength(); i++) A
String name = atts.getName(i);
String type = atts.getType(i);
String value = atts.getValue(i);
...
S
S

Daca elementul nu va avea atribute, atunci getLenght() va returna 0. Functiile getName(), getType() si getValue() furnizeaza numele, tipul (CDATA, ID, IDREF, NMTOKEN, ENTITY etc.) si valoarea atributului, respectiv.

Clasa org.xml.sax.Locator este folosita pentru localizarea documentelor XML prin intermediul unui URI (Uniform Resource Identifier). Daca o aplicatie are nevoie de redirectarea URI-urilor, atunci poate implementa EntityResolver.

Ca middleware intre un driver (parser) SAX si un client (aplicatie) SAX poate fi folosit procesorul arhitectural XAF conceput de Megginson.

SAX in C
O implementare gratuita in limbajul C pentru SAX este cea reprezentata de libxml (denumita si gnome-xml), o biblioteca de procesare a documentelor XML scrisa de Daniel Veillard de la Consortiul Web, fiind inclusa si in mediul de dezvoltare GNOME (GNU Network Object Model Environment) din distributia de Linux RedHat 6. In fapt, libxml implementeaza intreg modelul DOM pentru procesarea documentelor XML.

Interfata cu programatorul se concretizeaza in existenta a doua functii C utilizate la analiza unui document XML (aflat in memorie sau incarcat de pe disc):

#include <parser.h>

xmlDocPtr xmlParseMemory(char *buffer, int size); xmlDocPtr xmlParseFile(const char *filename);

Pentru crearea arborelui de obiecte-nod DOM, vom utiliza functii de manipulare arborescente al caror prototip se afla in tree.h. Un simplu exemplu, in care se adauga noduri-obiect prin xmlNewChild(), iar elementelor avind atribute li se asociaza acest valorile atributelor cu xmlSetProp():

xmlDocPtr doc; /* documentul XML */ xmlNodePtr tree, /* arborele asociat */ subtree; /* subarbore */ doc = xmlNewDoc("1.0"); /* creeaza o instanta de document */ doc->root = xmlNewDocNode(doc, NULL, "articol", NULL); xmlSetProp(doc->root, "vers", "draft"); xmlSetProp(doc->root, "author", "Sabin-Corneliu Buraga"); tree = xmlNewChild(doc->root, NULL, "head", NULL); subtree = xmlNewChild(tree, NULL, "title", "XML prin xml-lib"); tree = xmlNewChild(doc->root, NULL, "sect", NULL); subtree = xmlNewChild(tree, NULL, "title", "Prezentare XML"); subtree = xmlNewChild(tree, NULL, "p", "Un exemplu");

Se va creea astfel arborele asociat documentului XML urmator:

<?xml version="1.0"?>

<articol vers="draft" author="Sabin-Corneliu Buraga">
<head
<title>XML prin xml-lib</title>
</head>
<sect>
<title>Prezentare XML</title>
<p>Un exemplu</p>
</sect>
</articol>

Arborele creat mai sus poate fi salvat pe disc (o functie de salvare fiind void xmlDocDump(FILE *f, xmlDocPtr doc);), eventual compresat in format gzip. Aceasta maniera este folosita de aplicatia gnumeric care poate salva/incarca fisierele in format XML compresat cu GNUzip.

Un exemplu complet
Fie un document XML utilizat pentru stocarea datelor despre aplicatiile de laborator si despre studenti la disciplina "Tehnologii Web":

<?xml version="1.0"?>
<projects year="1999/2000">
<application name="WebTools in XML" id="2">
<category>software</category>
<status>
<update>Mon, 25 Oct 1999 12:27:45</update>
<version>0.23</version>
</status>
<authors>
<person>
<name>Ionut Gavrila</name>
<email>giangu@infoiasi.ro</email>
<wpage></wpage>
<address></address>
<year>master</year>
</person>
<person>
...
</person>
</authors>
</application>
...
</projects>

Functia C care analizeaza informatiile despre persoanele implicate in realizarea unor proiecte este urmatoarea:

/* structura cu datele despre o persoana */ typedef struct person A char *name; char *email; char *year; char *address; char *wpage;
S person, *person_ptr;

/* functia care analizeaza documentul si returneaza informatii despre un student */

person_ptr parse_person(xmlDocPtr doc, xmlNodePtr cnode) A person_ptr ret = NULL;

/* aloca structura, daca se poate */ ret = (person_ptr) malloc(sizeof(person)); if (ret == NULL) A fprintf(stderr,"out of memory\n"); return(NULL);
S memset(ret, 0, sizeof(person));

/* Nu ne intereseaza care e nodul radacina al documentului si vom viza doar elementele <name> si <email> */ cnode = cnode->childs;
while (cnode != NULL) A /* mai exista un nod? */ if (!strcmp(cnode->name, "name")) /* am gasit o persoana */ ret->name = xmlNodeListGetString(doc, cnode->childs, 1); if (!strcmp(cnode->name, "email")) /* memoram adresa e-mail */ ret->email = xmlNodeListGetString(doc, cnode->childs, 1); cnode = cnode->next; /* trece la urmatorul element... */
S

return (ret);
S

Desigur, parcurgerea documentului se putea realiza, mai elegant, in mod recursiv, exploatind informatiile din arborele DOM asociat. Biblioteca libxml permite si asocierea si procesarea spatiilor de nume XML, diverse reguli de validare a documentelor, oferind suport pentru RDF, XPath si XPointer si altele.

6.2 Manipularea documentelor XML prin navigatorul Web
Am vazut pina acum cum putem procesa documentele XML, via interfetelor Java sau C, independent de Web, putind concepe aplicatii de sine-statatoare. Mai atractiv ar fi probabil un mijloc dinamic de modificare si de manipulare a unui document XML in cadrul navigatorului Web, prin limbajul JavaScript. Odata cu aparitia versiunii 5 a browserului Internet Explorer acest lucru se poate realiza lejer. Se asteapta si replica de la Netscape, o serie din versiunile de test de la mozilla.org fiind deja disponibile. Netscape Gecko (cunoscut si sub numele de Netscape 6) reprezinta noua generatie de navigatoare incluzind suport pentru XML si DOM.

Arhitectura generala a unui navigator Web
Desigur, implementarea DOM din IE 5 este departe de a fi perfecta si nici macar nu se comformeaza 100% recomandarilor comitetului DOM din cadrul Consortiului Web, replica Microsoft la aceasta rezumindu-se la urmatorul proverb: "O camila este un cal proiectat de un comitet" (Anonim).

De unde putem sti ca IE 5 intelege documente XML? Pur si simplu putem incerca sa incarcam un document XML si sa vedem daca il putem vizualiza. Iata cum arata un fisier XML in IE 5 (observati culorile pentru elementele XML in comparatie cu vizualizarea aceluiasi document in Notepad):

Vizualizarea documentelor XML cu Internet Explorer 5
Putem incapsula informatiile XML in cadrul unei pagini HTML astfel:

<html>
<body>
<p align="center">Un exemplu XML intr-o pagina Web...</p>
<xml id="fragxml">
<doc>
<greetings>Hello, XML world!</greetings>
</doc>
</xml>

<script language="JavaScript"> alert(fragxml.innerHTML);
</script>

</body>
</html>

Marcatorul <xml> este un element HTML valid conform specificatiilor Consortiului Web. Identificatorul innerHTML reprezinta un fragment de document definit in varianta DOM pentru HTML. Pe ecran va apare:

Folosind metodele definite de interfetele DOM putem concepe un exemplu mai "complex". Dorim sa sortam o lista de carti, in functie de autorii lor. Aceasta lista o vom considera inclusa intr-un tabel HTML (putind la fel de bine fiind stocata si pe disc, intr-un document XML extern). Codul JavaScript inclus in pagina Web si folosit pentru ordonare este urmatorul:

function insertionSort(t, iRowStart, iRowEnd, fReverse)
A var iRowInsertRow, iRowWalkRow; for (iRowInsert = iRowStart + 1; iRowInsert <= iRowEnd; iRowInsert++)
A textRowInsert = t.childrenaiRowInserti.innerText; for (iRowWalk = iRowStart; iRowWalk <= iRowInsert; iRowWalk++)
A textRowCurrent = t.childrenaiRowWalki.innerText; if (((!fReverse && textRowInsert <= textRowCurrent)
|| (fReverse && textRowInsert >= textRowCurrent))
&& (iRowInsert != iRowWalk))
A eRowInsert = t.childrenaiRowInserti; eRowWalk = t.childrenaiRowWalki; t.insertBefore(eRowInsert, eRowWalk); iRowWalk = iRowInsert; // gata!
S
S
S
S

Dupa cum se observa modificarile de pozitie ale elementelor se realizeaza la nivelul arborelui de noduri-obiect asociate elementelor. Apelarea functiei insertionSort o vom realiza prin:

<input type="button" value="Sort" onclick="insertionSort(TBooks.childrena0i, 0,
TBooks.rows.length - 1, false)">

Tbooks este identificatorul tabelului cu lista cartilor. Acesta ar putea fi de exemplu:

<table id="TBooks" border="2">
<tr><td>Tanenbaum, A.</td><td>Retele de calculatoare</td><td>1998</td></tr>
<tr><td>Dufour, A.</td><td>Internet</td><td>1997</td></tr>
<tr><td>Rotariu, E.</td><td>Limbajul Java</td><td>1996</td></tr>
<tr><td>Athanasiu, I.</td><td>Limbajul Java</td><td>1998</td></tr>
</table>

Inainte de sortare, pagina Web arata astfel:

Lista de carti nesortata
Dupa ordonarea numelor de autori vom observa cele de mai jos. Ultima coloana a unui rind de tabel n-a fost sortata, ci doar primele doua. Lasam cititorului sarcina de a vedea de ce.

Lista de carti sortata
Folosind metodele definite de interfetele DOM se pot imagina diverse aplicatii pentru prelucrarea documentelor XML si HTML in cadrul paginilor WWW, in maniera dinamica, on-line. Astfel, se poate concepe un joc de tip puzzle, modificarea pieselor realizindu-se prin schimbarea ordinii nodurilor in arborele DOM asociat documentului.

7. Concluzii
Se asteapta sa apara specificatiile urmatoarelor nivele ale modelului DOM, in prezent DOM nivelul 2 fiind in lucru. DOM nivelul 1 este implementat deja de navigatoarele Web actuale, ca si de o serie de analizatoare XML scrise in Java. In plus, s-a dezvoltat un model DOM destinat prelucrarii documentelor SMIL.

Recomandarile DOM ofera in intregime interfetele standard proiectate in Java si ECMAScript, independente de platformele hardware si software, fiind utile programatorilor de aplicatii destinate procesarii avansate a documentelor XML sau HTML.

O alta directie complementara este data de specificarea unei scheme de limbaj (meta-gramatici) orientata-obiect destinata definirii structurii sintactice si a semanticii tipurilor de documente XML: Schema for Object-Oriented XML (SOX) aflata la versiunea 2.0 (ultima actualizare a variantei de lucru desfasurindu-se la sfirsitul lunii iulie 1999).

Avind in vedere dezvoltarea pronuntata a tehnologiilor bazate pe XML, modelul DOM devine, cu atit mai mult, atractiv pentru dezvoltatorii de aplicatii Internet.