# Programmation XML/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Programmation_XML

# Introduction
## Présentation

XML est l'acronyme d'eXtended Markup Language, soit « langage de balise étendu » en français. XML permet la structuration et la manipulation de toutes sortes de données dans un format se voulant le plus indépendant possible des plates-formes et des logiciels. Sa principale alternative est JSON.
La technologie XML vise à devenir le standard d'échange principal entre systèmes hétérogènes. XML hérite de SGML et à ce titre est un cousin de HTML. C'est un langage de balises comme HTML mais extensible et strict.
À partir de XML, il est possible de dériver des langages spécialisés comme XHTML ou MathML, ou tout autre langage, et ceci grâce au fait que les noms des balises peuvent être réinventés (étendus) en fonction des besoins.

## Histoire de XML

* Juillet 1997 : Création du groupe de travail XML par le W3C
* 10 février 1998 : Publication de la spécification XML 1.0
* 4 février 2004 : XML (3eme édition) 1.0
* 4 février 2004 : spécification XML 1.1 (français)

# Structure d'un document XML

Un document XML est fondamentalement de type texte, par opposition à d'autres structures informatiques qui peuvent être de type binaire (programmes exécutables, base de données). Ce texte est généralement un texte Unicode, souvent au format UTF-8. Un simple éditeur de texte compatible Unicode/UTF8, est donc capable de créer, d'ouvrir ou de modifier un document XML stocké sur disque.
Mais un document XML n'existe pas uniquement sous forme de fichier. Il peut exister aussi temporairement en mémoire comme format de transfert de données entre deux applications logicielles (par exemple sous forme de requête HTML POST pour transmettre un formulaire fraîchement tapé par l'internaute).
Donc, le document XML est un format dont nous allons décrire la structure :

## Éléments d'un document XML
### Balisage

Un document XML est constitué de balises. Une balise est une chaîne de caractères constituant un identificateur et placé entre un caractère < et un caractère >.
Il existe différentes sortes de balises :
* Les balises ouvrantes <item>
* Les balises fermantes </item>
* Les balises vides <nop/>
* Les instructions de traitement <?xml-stylesheet ... ?>
* Les commentaires <!-- J'explique -->
* Les sections CDATA (Character DATA) <![CDATA[ Contenu de la section ]]>

#### Conventions de nommage des balises

* Les noms ne peuvent pas commencer par la chaîne de caractères « xml », dans n'importe quelle combinaison de casse (ou Xml, ou XML…) ;
* les noms sont sensibles à la casse (différentiation minuscules/majuscules) ;
* les noms ne peuvent pas débuter par un nombre ou un signe de ponctuation ;
* les noms ne peuvent pas contenir d'espaces ;
* éviter les caractères accentués et les opérateurs, virgules, point-virgules…

#### Les balises ouvrantes

Une balise ouvrante est un élément délimitant une section. La section se termine ensuite par une balise fermante.
Une balise ouvrante est une chaîne composée de chiffres, de lettres et des caractères - et _. Cette chaîne est comprise entre un < et un >.
Exemple :

#### Les balises fermantes

Une balise fermante reprend l'identificateur de la balise ouvrante, en le précédent d'un caractère « barre de fraction » (slash). Exemple :

#### Les balises vides

Une balise « vide » est le résultat de la contraction d'une balise ouvrante et d'une balise fermante ne contenant pas de données.

### Les attributs

Les balises ouvrantes et les balises vides peuvent être enrichies avec des attributs.
Dans l'exemple ci-dessus, la balise ouvrante item est munie de deux attributs, id et date. La balise vide break est munie de l'attribut mode.
Leurs valeurs doivent obligatoirement être entre guillemets ou apostrophes dactylographiques.

### Les instructions de traitement

Une instruction de traitement est destinée à être lue et comprise par un programme spécifique, afin de permettre le traitement du document XML.
Une instruction de traitement commence par un point d'interrogation « ? ».
Exemple :

### Les commentaires

Les commentaires sont des balises qui ne sont pas interprétées par l'application qui traite le document XML.
Un commentaire est une balise commençant par <!-- et terminant par -->.
Exemple :

### Les entités

XML 1.0 définit un petit nombre d'entités utilisables dans le document sans nécessiter de déclaration dans le doctype.
Ces entités sont :
| Entité | Caractère | Description |
| &lt; | < | Symbole « inférieur » |
| &gt; | > | Symbole « supérieur » |
| &amp; | & | Esperluette, « et » commercial |
| &apos; | ' | guillemet simple |
| &quot; | " | guillemet double |
Toujours sans déclaration de doctype spécial, on peut écrire une entité avec « & », « # », une référence Unicode et un « ; ».
| Entité | Caractère | Description |
| &#960; | π | pi |
| &#946; | β | bêta |
Exemple

## Structure d'un document XML
### En-tête

Les trois constituants de l'en-tête que nous allons décrire ne sont pas obligatoires. Ils sont employés en cas de besoin pour fixer l'encodage, définir le doctype et/ou associer une feuille de style.

#### Version, encodage

Il est souhaitable que le document XML commence par l'indication de la version du langage et le jeu de caractères utilisé. C'est souvent utf-8. Il est également souhaitable, si le document est stocké sur disque, que l'encodage du fichier soit le même que celui mentionné par l'attribut encoding…

#### Référence au DTD

La deuxième information utile est la mention du doctype. Certains documents XML en ont impérativement besoin, d'autres peuvent s'en passer.
En analysant ce doctype, l'analyseur syntaxique (le parser, p.ex. : via Cooktop ou encore XML tools pour Notepad++) est en mesure de considérer le document XML comme valide.

#### Mention d'une feuille de style

Il est possible d'associer un document XML à une feuille de style CSS ou XSL. Si la fonctionnalité fait réfléchir, au début, il y a fort à parier que vous en abandonnerez la pratique par la suite. En effet, la philosophie XML va à l'opposé.

### Une seule racine

Une balise a un statut spécial, c'est la racine du document XML. C'est à partir de cette balise que se développe l'arborescence du document.

### Règles de mise en œuvre des balises

* Toute balise ouverte doit être fermée.
* Les balises doivent être correctement imbriquées.
* Les balises sont imbriquables hiérarchiquement sans limitation mais il ne doit y avoir qu'un seul élément à la racine.
Le corps d'un document XML est une arborescence d'éléments (balises) imbriqués, avec un élément racine unique.
Quand toutes ces règles sont respectées, on obtient un document XML « bien formé ». Dans ce cas, un navigateur comme Internet explorer ou Firefox peut l'ouvrir. Dans le cas contraire, le navigateur affiche un message d'erreur.

## Éditer un XML dans un tableur

Microsoft Excel propose un système de mappage XML permettant d'éditer un fichier un tableau, par exemple en triant ou supprimant des lignes ou des colonnes.

## Références

* 1 2 3 Unicode est un standard qui permet une représentation abstraite et universelle du texte. Pour découvrir ce sujet, on pourra lire le wikilivre: À la découverte d'Unicode.
* ↑ http://www.w3schools.com/xml/xml_attributes.asp
* ↑ « Le point sur les instructions de traitement », sur yoyodesign.org
* Traduction française de la spécification XML1.1

# Espace de nom

Les espaces de noms (ou namespace) sont destinés à lever les ambiguïtés éventuelles des intitulés de balise, au moyen d'un identifiant de ressource unique (URI).

## Syntaxe

L'exemple ci-dessous contient deux déclarations, la première par défaut et la seconde associant le préfixe « ip » à l'URI des adresses IP, pour les distinguer des adresses postales :

# Définition de Type Document
## Introduction

Le DTD permettent de décrire la forme que doit avoir un document XML pour être valide. Les DTD ont été remplacées par XML Schema qui est bien plus puissant et expressif, aussi nous vous encourageons, pour tout nouveau projet de favoriser systématiquement l'utilisation de Schema aux DTD.
Nous abordons toutefois les DTD ici, afin que vous puissiez en comprendre une si besoin. Notamment, vous pourriez être amener à transformer une DTD en un Schema pour utiliser cette nouvelle technologie.

## Spécification d'une DTD

Contrairement aux Schema, la DTD n'est pas un dialecte XML, c'est un langage spécifique.
La DTD n'est pas obligatoire. Elle peut être interne au document XML ou bien externe (dans un fichier à l'extension « .dtd »). On utilise une DTD externe lorsque l'on veut la partager entre plusieurs fichiers XML.
Exemple de déclaration d'une DTD externe dans un fichier XML :
La DTD commence par la balise :
et se termine par :
La DTD doit être placée après la déclaration initiale XML.
Les commentaires, comme en XML sont utilisés de la manière suivante :

## Éléments

Chaque élément de la DTD est défini de la manière suivante :
Les qualificateurs possibles sont :
* ANY : la structure de l'élément est libre
* EMPTY : l'élément est vide
* #PCDATA(Parsed Character Data) : donnée textuelle analysable
On peut préciser ces qualificateurs grâce aux éléments suivants :
* un et un seul sous-élément :
(un seul téléphone par personne)
* 0 ou plusieurs sous-éléments :
(une personne peut avoir 0, 1 ou plusieurs téléphones)
* 1 ou plusieurs éléments :
(une personne doit avoir au moins un téléphone)
* 0 ou 1 seul élément :
(une personne a au maximum 1 téléphone, elle peut ne pas en avoir)
* Plusieurs sous-éléments différents :
(une personne a un nom et un téléphone)
* Des sous-éléments identiques ou non :
(une personne a un nom et deux numéros de téléphone)
* Un sous-élément OU (exclusif) un autre :
(un ou deux téléphone par personne)
Exemple du stockage d'un répertoire de services. Chaque service a un nom et peut avoir un ou plusieurs téléphone(s) :

## Attributs

Ils sont déclarés avec ATTLIST. Par exemple, on définit un type de paiement par défaut en liquide :

### Valeurs des attributs

Les valeurs d'attributs (attribute-value) sont :
| Valeur | Explication |
| value | valeur par défaut de l'attribut |
| #REQUIRED | attribut requis |
| #IMPLIED | attribut optionnel |
| #FIXED value | attribut de valeur fixe |

### Types des attributs

| Type | Description |
| CDATA | valeur de la donnée |
| (en1|en2|..) | valeur dans la liste énumérée |
| ID | identifiant unique |
| IDREF | identifiant d'un autre élément |
| IDREFS | liste d'autres identifiants |
| NMTOKEN | nom d'un XML valide |
| NMTOKENS | liste de noms d'XML |
| ENTITY | entité |
| ENTITIES | liste d'entités |
| NOTATION | nom d'une notation |
| xml: | valeur d'un xml prédéfini |

## Entités

Déclarer une entité permet de l'intégrer ensuite en appelant son nom précédé d'un et commercial, pourcentage ou guillemet ('&', '%' ou ' " ') et suivi d'un point virgule (';'). Ex :

## Exemple

Extrait du cahier des charges XHTML concernant les hyperliens :

## Références

* ↑ http://www.w3schools.com/dtd/dtd_elements.asp
* ↑ http://www.w3schools.com/dtd/dtd_attributes.asp
* ↑ http://xmlwriter.net/xml_guide/entity_declaration.shtml
* ↑ http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd

# Interprétation du XML

Il existe de nombreuses API permettant d'interpréter un document XML. La plupart sont conçues pour un langage particulier :
* Dom4J (Java)
* JDOM (Java)
* SimpleXML (PHP)
* PyXML (Python)
Tous ces interpréteurs peuvent être de deux types normalisés :
* DOM (créé par le W3C) : un arbre de nœuds complet est construit à partir du document XML.
* SAX (créé par David Megginson) : l'interpréteur appelle certaines fonctions de l'application en fonction de chacun des éléments de base rencontrés dans le document XML (ouvertures de balise, fermetures, données, commentaires, ...).

## Références

* ↑ http://pyxml.sourceforge.net/topics/

## Voir aussi

* Programmation Python/XML
* Programmation Java/XML

# SAX

La méthode SAX (Simple API for XML) analyse les éléments XML au fur et à mesure, par opposition au DOM. Ce qui est plus pratique pour des fichiers de grande taille par exemple, car au lieu de construire toute une structure qui prend de la place en mémoire, l'API notifie l'application qui peut effectuer des traitements au fil de la lecture du document XML.

## Voir aussi

* Programmation Python/XML#La méthode SAX
* Programmation Java/XML#La méthode SAX

# DOM

La méthode DOM (Document Object Model) analyse les éléments XML en construisant une arborescence de la structure d'un document et de ses éléments. Cela nécessite donc de le lire en entier ce qui peut poser un problème de saturation quand il est de grande taille.

## Exemple
# XPath
## Syntaxe

Le XPath est un langage de sélection de différents types d'objets XML, appelés « nœuds ». Un ensemble de nœuds est appelé « contexte ».
Le XPath se présente sous la forme de chemins composés de :
| Sélecteur | Notes |
| nom du nœud | Sélectionne ce qui est compris dans le nœud nommé. |
| / | Sélectionne en partant du nœud racine (chemin absolu). |
| // | Sélectionne en partant du nœud courant, peu importe le reste de l'emplacement. |
| . | Sélectionne à partir du nœud courant (chemin relatif). = self::node |
| .. | Sélectionne à partir du parent du nœud courant. = parent::node |
| @ | Sélectionne les attributs. = attribute:: |
| | | Opérateur de sélection multiple. |
Ces expressions sont appelées « chemin de localisation », composés d'un ou plusieurs « pas de localisation » (ou « étapes ») séparés par des « / ». Les pas de localisation ont chacun trois composants :
* Un axe (parent, descendant…).
* Un test de nœud (nom ou fonction désignant les nœuds).
* Des prédicats (entre crochets).

## Axes

Pour décrire les relations entre les nœuds, XPath utilise le vocabulaire suivant :
| Axe | Abréviation | Notes |
| ancestor | | ancêtre |
| ancestor-or-self | | ancêtre ou soi |
| attribute | @ | attribut, @abc signifie attribute::abc |
| child | | enfant, xyz signifie child::xyz |
| descendant | | |
| descendant-or-self | // | // signifie /descendant-or-self::node/ |
| following | | suivant |
| following-sibling | | frère suivant |
| namespace | | espace de noms |
| parent | .. | .. signifie parent::node |
| preceding | | précédent |
| preceding-sibling | | |
| self | . | soi, . signifie self::node |

## Tests de nœuds

Soit l'espace de nom ns :
* //ns:* sélectionne tous les éléments du namespace.
* //ns:nom récupère tous les éléments du namespace nommés "nom".
| Tests | Notes |
| comment | trouve tous les commentaires (ex : <!-- commentaire 1 -->) |
| text | trouve un nœud texte, (ex : hello world dans <k>hello<m> world</m></k>) |
| processing-instruction | trouve les instructions de traitement (ex : //processing-instruction('php') trouve <?php echo $a; ?>) |
| node | trouve tous les nœuds. |

## Prédicats

Les prédicats sont des fonctions filtrant les nœuds évalués à false, qui se placent à la fin des sélections :
Par exemple, les quatre requêtes ci-dessous renvoie le même résultat (si la branche 2 est la dernière comme dans l'exemple en bas de cette page) :
| Prédicats | Notes |
| last | renvoie le dernier nœud de la sélection |
| position | renvoie le nœud situé à la position précisée |
| count(contexte) | renvoie le nombre de nœuds en paramètre |
| starts-with(chaine1, sous-chaine2) | renvoie true si le premier argument commence avec le second |
| contains(botte_de_foin, aiguille) | renvoie true si le premier argument contient le second |
| sum(contexte) | renvoie la somme des valeurs numériques des nœuds en paramètre |
| floor(nombre) | renvoie le nombre arrondi à l'entier inférieur |
| ceiling(nombre) | renvoie le nombre arrondi à l'entier supérieur |
| round(nombre) | renvoie le nombre arrondi à l'entier le plus proche |

## Exemples

Soit l'arborescence suivante :

### Abréviations

* Sélection 1 : toutes les <feuille> d'une <brindille> contenue dans une <branche>, descendant du <tronc>, issu de la racine.
** Abrégé : /tronc/branche/brindille/feuille
** Non abrégé : /child::tronc/child::branche/child::brindille/child::feuille
* Sélection 2 : la <branche> dont l'attribut "nom" est "branche3", enfant du <tronc>, inclue dans la racine.
** Abrégé : /tronc/branche[@nom='branche3']
** Non abrégé : /child::tronc/child::branche[attribute::nom='branche3']
* Sélection 3 : toutes les brindilles ont au moins une feuille.
** //brindille[feuille]
* Sélection 4 : dernière branche du tronc.
** //tronc/branche[last]
* Sélection 5 : tous les noms des brindilles qui n'ont pas de feuille.
** //brindille[not(feuille)]/@nom

### PHP

Créer le .php suivant à côté du tronc.xml publié ci-dessus.

### eXist ou BaseX

    Pour plus de détails voir : XQuery.

## Références

* ↑ http://www.w3schools.com/dom/dom_nodetype.asp
* ↑ http://www.w3schools.com/xpath/xpath_syntax.asp
* ↑ http://www.w3.org/TR/xpath#corelib

## Voir aussi

* http://b3d.bdpedia.fr/query.html#s1-xpath-trouver-son-chemin-xml : explications avec vidéo en français

# XSLT
## Syntaxe de base

XSLT signifie Extended Stylesheet Language Transformations. Il s'agit d'un langage qui permet de transformer un document XML en un autre format en s'appuyant sur XPath. On peut par exemple créer une page HTML, un fichier PDF ou autre à partir d'un fichier XML.
Le langage XSLT se base sur la notion de règles de transformation. Pour chaque balise XML, on définit comment son contenu doit apparaître dans le document produit. Ces règles sont dans des balises <xsl: et on les enregistre dans des documents .xsl.

### Attributs

| Attributs | Note |
| match | désigne le nœud auquel s'applique le code. |
| select | ce qu'il faut trier dans le résultat. |
| order | classe les résultats (ascending ou descending) |
| case-order | classe les résultats en distinguant les lettres capitales (upper-first ou lower-first) |
| data-types | convertit le type des données (ex : string, number, boolean) |

### Exemple

| <?xml version="1.0" ?> <persons> <person username="JS1"> <name>John</name> <family-name>Smith</family-name> </person> <person username="MI1"> <name>Morka</name> <family-name>Ismincius</family-name> </person> </persons> | + | <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:output method="xml" indent="yes"/> <xsl:template match="/persons"> <root> <xsl:apply-templates select="person"/> </root> </xsl:template> <xsl:template match="person"> <name username="{@username}"> <xsl:value-of select="name" /> </name> </xsl:template> </xsl:stylesheet> |
| <?xml version="1.0" encoding="UTF-8"?> <root> <name username="JS1">John</name> <name username="MI1">Morka</name> </root> |||

### PHP

Depuis PHP5 l'extension est déjà inclue dans le fichier PHP.ini :
Il n'y a donc rien a installer pour charger les deux fichiers publiés ci-dessus :

## Syntaxe avancée
### Éléments

| Éléments XSL | Description | Catégorie |
| apply-imports | Applies a template rule from an imported stylesheet | instruction |
| apply-templates | Applies a template rule to the current element or to the current element's child nodes | instruction |
| attribute | Adds an attribute | instruction |
| attribute-set | Defines a named set of attributes | top-level-element |
| call-template | Calls a named template | instruction |
| choose | Used in conjunction with <when> and <otherwise> to express multiple conditional tests | instruction |
| comment | Creates a comment node in the result tree | instruction |
| copy | Creates a copy of the current node (without child nodes and attributes) | instruction |
| copy-of | Creates a copy of the current node (with child nodes and attributes) | instruction |
| decimal-format | Defines the characters and symbols to be used when converting numbers into strings, with the format-number function | top-level-element |
| element | Creates an element node in the output document | instruction |
| fallback | Specifies an alternate code to run if the processor does not support an XSLT element | instruction |
| for-each | Loops through each node in a specified node set | instruction |
| if | Contains a template that will be applied only if a specified condition is true | instruction |
| import | Imports the contents of one stylesheet into another. Note: An imported stylesheet has lower precedence than the importing stylesheet | top-level-element |
| include | Includes the contents of one stylesheet into another. Note: An included stylesheet has the same precedence as the including stylesheet | top-level-element |
| key | Declares a named key that can be used in the stylesheet with the key function | top-level-element |
| message | Writes a message to the output (used to report errors) | instruction |
| namespace-alias | Replaces a namespace in the stylesheet to a different namespace in the output | top-level-element |
| number | Determines the integer position of the current node and formats a number | instruction |
| otherwise | Specifies a default action for the <choose> element | instruction |
| output | Defines the format of the output document | top-level-element |
| param | Declares a local or global parameter | top-level-element |
| preserve-space | Defines the elements for which white space should be preserved | top-level-element |
| processing-instruction | Writes a processing instruction to the output | instruction |
| sort | Sorts the output | instruction |
| strip-space | Defines the elements for which white space should be removed | top-level-element |
| stylesheet | Defines the root element of a stylesheet | top-level-element |
| template | Rules to apply when a specified node is matched | top-level-element |
| text | Writes literal text to the output | instruction |
| transform | Defines the root element of a stylesheet | top-level-element |
| value-of | Extracts the value of a selected node | instruction |
| variable | Declares a local or global variable | top-level-element or instruction |
| when | Specifies an action for the <choose> element | instruction |
| with-param | Defines the value of a parameter to be passed into a template | instruction |

### Fonctions

| Nom | Description |
| current | Returns the current node |
| document | Used to access the nodes in an external XML document |
| element-available | Tests whether the element specified is supported by the XSLT processor |
| format-number | Converts a number into a string |
| function-available | Tests whether the element specified is supported by the XSLT processor |
| generate-id | Returns a string value that uniquely identifies a specified node |
| key | Returns a node-set using the index specified by an <xsl:key> element |
| system-property | Returns the value of the system properties |
| unparsed-entity-uri | Returns the URI of an unparsed entity |

### Fonctions héritées de XPath

| Nom | Description | Syntaxe |
| count | Returns the number of nodes in a node-set | number=count(node-set) |
| id | Selects elements by their unique ID | node-set=id(value) |
| last | Returns the position number of the last node in the processed node list | number=last |
| local-name | Returns the local part of a node. A node usually consists of a prefix, a colon, followed by the local name | string=local-name(node) |
| name | Returns the name of a node | string=name(node) |
| namespace-uri | Returns the namespace URI of a specified node | uri=namespace-uri(node) |
| position | Returns the position in the node list of the node that is currently being processed | number=position |

### Fonctions chaines

| Nom | Description | Exemple |
| Concat | Returns the concatenation of all its arguments | string=concat(val1, val2, ..) Example: concat('The',' ','XML') Result: 'The XML' |
| contains | Returns true if the second string is contained within the first string, otherwise it returns false | bool=contains(val,substr) Example: contains('XML','X') Result: true |
| normalize-space | Removes leading and trailing spaces from a string | string=normalize-space(string) Example: normalize-space(' The XML ') Result: 'The XML' |
| starts-with | Returns true if the first string starts with the second string, otherwise it returns false | bool=starts-with(string,substr) Example: starts-with('XML','X') Result: true |
| string | Converts the value argument to a string | string(value) Example: string(314) Result: '314' |
| string-length | Returns the number of characters in a string | number=string-length(string) Example: string-length('Beatles') Result: 7 |
| substring | Returns a part of the string in the string argument | string=substring(string,start,length) Example: substring('Beatles',1,4) Result: 'Beat' |
| substring-after | Returns the part of the string in the string argument that occurs after the substring in the substr argument | string=substring-after(string,substr) Example: substring-after('12/10','/') Result: '10' |
| substring-before | Returns the part of the string in the string argument that occurs before the substring in the substr argument | string=substring-before(string,substr) Example: substring-before('12/10','/') Result: '12' |
| translate | Takes the value argument and replaces all occurrences of string1 with string2 and returns the modified string | string=translate(value,string1,string2) Example: translate('12:30',':','!') Result: '12!30' |

### Fonctions nombres

| Nom | Description | Exemple |
| ceiling | Returns the smallest integer that is not less than the number argument | number=ceiling(number) Example: ceiling(3.14) Result: 4 |
| floor | Returns the largest integer that is not greater than the number argument | number=floor(number) Example: floor(3.14) Result: 3 |
| number | Converts the value argument to a number | number=number(value) Example: number('100') Result: 100 |
| round | Rounds the number argument to the nearest integer | integer=round(number) Example: round(3.14) Result: 3 |
| sum | Returns the total value of a set of numeric values in a node-set | number=sum(nodeset) Example: sum(/cd/price) |

### Fonctions booléennes

| Nom | Description | Exemple |
| boolean | Converts the value argument to Boolean and returns true or false | bool=boolean(value) |
| false | Returns false | false Example: number(false) Result: 0 |
| lang | Returns true if the language argument matches the language of the xsl:lang element, otherwise it returns false | bool=lang(language) |
| not | Returns true if the condition argument is false, and false if the condition argument is true | bool=not(condition) Example: not(false) |
| true | Returns true | true Example: number(true) Result: 1 |

## Références

* ↑ http://www.php.net/manual/fr/book.xsl.php
* ↑ http://www.w3schools.com/xsl/xsl_w3celementref.asp
* ↑ http://www.w3.org/TR/xslt#element-syntax-summary)
* ↑ http://www.w3schools.com/xsl/xsl_functions.asp
* ↑ http://www.w3schools.com/xsl/xsl_functions.asp

## Voir aussi

* CSS

# XML Schema
## Syntaxe

XML Schema est un langage de description de format, permettant de définir la structure et le type de contenu d'un document XML (comme pour créer une base de données).
Ces règles sont dans des balises <xs: ou <xsd: et on les enregistre dans des documents .xsd (XML Schema Definition).

## Voir aussi

* Catégorie:Expressions rationnelles

# XQuery

* La lecture préalable de Programmation XML est nécessaire.
Consultez également ces pages dans d’autres projets Wikimedia :
XQuery est une recommandation W3C de sélection de données depuis des documents et bases de données basée sur XML.

## Sommaire

* Introduction
* Installation
Exemples basiques
* HelloWorld
* Chargement de données
* Expression FLWOR
* Séquences
* Analyse syntaxique CSV
* Exemples XPath
* Expressions rationnelles
* Searching multiple collections
* Getting URL Parameters
* Getting POST Data
* Checking for Required Parameters
* Displaying Lists
* Extracting data from XHTML files
* Displaying data in HTML Tables
* Limiting Result Sets
* Filtering Words
* Saving and Updating Data
* Quantified Expressions
* Dates and Time
* Chaining Web Forms
Exemples intermédiaires
* Using XQuery Functions
* Creating XQuery Functions
* Returning the Longest String
* Net Working Days
* Tag Cloud
* String Analysis
* Manipulating URIs
* Parsing Query Strings
* Splitting Files
* Filling Portlets
* Filtering Nodes
* Limiting Child Trees
* Higher Order Functions
* Timing Fibonacci algorithms
* Using Intermediate Documents
* Formatting Numbers
* Uploading Files
* TEI Concordance
* Queries on Tables
* Namespace Constructors
Recherche
* Introduction to XML Search
* Basic Search
* Searching,Paging and Sorting
* Keyword Search
* Employee Search
* Incremental Search of the Chemical Elements
* Lucene Search
* Incremental Searching
* Advanced Search
* Open Search
* Auto-generation of Index Config Files
Interaction
* Adder
* Simple XForms Examples
* Navigating Collections
* Envoyer des e-mails

### Vues personnalisées

* HTML Table View
* Tree View
* Grouping Items
Transformation de documents XML complexes
* Transformation Styles
* Typeswitch Transformations
* Transformation idioms
* Generating Skeleton Typeswitch Transformation Modules
* Web XML Viewer
Rapports paginés
* Installing_the_XSL-FO_module
* Generating PDF from XSL-FO files
* XSL-FO Tables
* Converting HTML tables to XSL-FO tables
* XSL-FO Images

### Publication de contenu

* Publishing Overview
* Publishing to Subversion
Comparaison et fusion de XML
* Compare two XML files
* XML Differences
* Compare with XQuery
* Time Comparison with XQuery
* Synchronizing Remote Collections
* Finding Duplicate Documents

### Requêtes basées sur le temps

* Time Based Queries
* Timing a Query
Documents
* TEI Concordance
* TEI Document Timeline
* DocBook to HTML
* DocBook to PDF
* DocBook to ePub
* DocBook to Microsoft Word
* OpenOffice to HTML
* Office Open XML
XML Schemas
* XML Schema to Instance
* XML Schema to XForms
* XML Schema to SVG
* Caractères spéciaux
Liens avec d'autres langages
* Using intermediate MusicXML documents
* MusicXML to Arduino
* XQuery et Python
* XQuery SQL Module
* XQuery depuis SQL
* List OWL Classes
* Excel et XML
* AJAX Navigating Collections
* AJAX Employee Search
* AJAX Incremental Search of the Chemical Elements
* AJAX DOJO data
* XML vers SQL
* Simple RSS reader
* XHTML et Voice
* XQuery et XSLT
* Basic Authentication
* Digest Authentication
* OAuth
* Wikipedia Page scraping
* Wikipedia Lookup
* Wikipedia Events RSS
* Wiki weapons page
* Wikibook index page
* Wikibook list of code links
* Freebase
* Google Docs
Virtualisation
* Graph Visualization
* Graphing from RDF
* Dataflow diagrams
* Sequence Diagrams
* Example Sequencer
Google
* Google Charts
* Google Chart Sparkline
* Google Chart Bullet Bar
* Histogram of File Sizes
Page Scraping
* Overview of Page Scraping Techniques
* Page scraping and Yahoo Weather
* UK shipping forecast
* BBC Weather Forecast
* Page scraping and Mashup
* Simple RSS reader
* Multiple page scraping and Voting behaviour
* Link gathering
* REST interface definition
* Caching and indexes
Mapping
* Google Geocoding
* String Analysis#Location_Mapping
* Flickr GoogleEarth
* Nationalgrid and Google Maps
* SMS tracker

### Timelines

* Creating a Timeline
* Timelines of Resource
* TEI Document Timeline
Web sémantique
* DBpedia with SPARQL - Football teams
* DBpedia with SPARQL and Simile Timeline - Album Chronology
* DBpedia with SPARQL - Stadium locations
* The Emp-Dept case study
** XML to RDF
** SPARQL Tutorial
** SPARQL interface
* Graphing Triples
* SPARQLing Country Calling Codes
* Southampton Pubs
* Alphabet Poster
* Simile Exhibit
* Latent Semantic Indexing
Outils de développent
* Sitemap for Content Management System
* Uptime monitor
* XQuery IDE
* Image Library
* XML Schema to Instance
* Lorum Ipsum text
* XQuery and XML Schema
* Generating XQDocs
* Call Graphs
* System Properties
* Environment Variables
Validation
* Validating a document
* Validation using a Catalog
* Validating a hierarchy
* Validation with Schematron

### Path Analysis

* All Paths
* All Leaf Paths
Securité
* Login and Logout
* URL Driven Authorization
* Digital Signatures
* Changing Permissions on Collections and Resources

### Unit Testing Tools

* XUnit Testing
* XUnit Annotations
Études de cas
* Fizzbuzz
* Project Euler
* Topological Sort
* Slideshow
* Sudoku
* Pachube feed
* World Temperature records
* UWE StudentsOnline
Modules eXistdb
* Installing the XSL-FO module
* Setting HTTP Headers
* Database Utilities
* Get zipped XML file
* Unzipping an Office Open XML docx file
* Installing eXgit
* File Transfer Client
* FTP Client
* Digest Authentication
* UK shipping forecast
* Convert XML to JSON
* Lucene_Search
* Sending E-mail
* Basic Feedback Form
* Using the Math Module
* Using the Memcached Module
* Execute External Process
* Getting URL Parameters
* Getting POST Data
* Checking for Required Parameters
* Manipulating URIs
* Parsing Query Strings
* Adder
* XQuery Batch Jobs
* Sequences Module
* Basic Session Management
* Subversion
* String_Analysis
* Registered Modules
* Registered Functions
* Dynamic Module Loading
* Higher Order Functions
* Timing Fibonacci algorithms
* XMP data
* Basic Authentication
* Validating a document
* Saving_and_Updating_Data
* Splitting_Files
* Generating xqDoc-based XQuery Documentation
* Installing the XSL-FO module
* Generating PDF from XSL-FO files
* XSL-FO Tables
* XSL-FO Images
* XSL-FO SVG
* Using Triggers to Log Events
* Using Triggers to assign identifiers
* Sending E-mail
* Inserting and Updating Attributes
* Updates and Namespaces
* URL Rewriting Basics
* Reindex a Collection
* eXist Replication
* eXist Crib sheet
Annexes
* DataDirect XQuery
* Microsoft SQL Server 2005
* NetKernel
* Oracle Berkeley DB XML
* Stylus Studio
* XQilla
* Gotchas
* Ah-has

## Références

* FunctX XQuery Function Library by Priscilla Walmsley
* Web data management

## Voir aussi

* https://pear.php.net/pepr/pepr-proposal-show.php?id=303

# XSL-FO
## Introduction à XSL-FO

XSL-FO (eXtensible Stylesheet Language - Formatting Objects) dans la recommandation XSL du W3C est le vocabulaire qui décrit les mises en forme de documents XML quel que soit le support : écran, papier mais aussi dispositifs mobiles ou audio...
XSL-FO est un langage d'une haute technicité qui s'adresse principalement aux typographes afin de fournir avec les outils de gestion de documents, un outil typographique du niveau attendu par les publications imprimées.
L'objectif de XSL-FO est de créer un arbre d'aires où une aire est une zone d'affichage (visuelle ou auditive).
Les aires sont de deux types :
* Les aires de blocs s'empilent les unes sur les autres,
* Les aires en-ligne s'empilent les unes à côté des autres.
XSL-FO fournit l'ensemble des commandes de contrôle de chaque aire : présentation du contenu, direction de l'empilement (écriture de gauche à droite ou inversement, de haut en bas...).
Ces commandes sont dans des balises <fo: et on les enregistre dans des documents .xfo, .fo ou .fob.

## Un document "Bonjour le monde"

Le résultat du code suivant est Hello world :

## Le modèle des aires
### Modèle d'une page simple

| Page viewport area | Page viewport area | Page viewport area | Page viewport area | I margin-top | I margin-top | I margin-top |
| | region-before region viewport area | region-before region viewport area | region-before region viewport area | region-before region viewport area | region-before region viewport area | |
| ___ | | | Region-body region viewport area | | | ___ |
| | region-after region viewport area | region-after region viewport area | region-after region viewport area | region-after region viewport area | region-after region viewport area | |
| | | | | I margin-bottom | I margin-bottom | I margin-bottom |

## Références

* ↑ http://www.w3schools.com/xslfo/xslfo_output.asp

## Liens externes

La dernière vérification concernant les liens externes a été effectuée le le 25 janvier 2006.
* (anglais) w3.org Recommandation du W3C.
* (français) yoyodesign.org Traduction de la recommandation du W3C version 1.0 du 15 octobre 2001.
* (anglais) w3schools.com Apprendre XSL-FO avec w3schools (tutoriel, documentation...)
* (anglais) xml.apache.org FOP, le moteur XSL-FO d'Apache
       FOP est une application Java qui accepte un document FO et génère une page dans différents formats : PDF, PCL, PS, SVG, XML, Print, AWT, MIF and TXT. Le principal format de sortie étant le PDF.

# SVG

Le format d'image vectorielle SVG (Scalable Vector Graphics) est une utilisation concrète du format XML pour décrire les images vectorielles comme un ensemble d'éléments graphiques organisé en un arbre d'éléments XML. Les navigateurs internet supportent l'intégration de graphiques SVG dans le contenu de la page HTML.
Voir le livre Découvrir le SVG pour plus de détails.

# SyncML
## Objectifs

Après avoir lu ce chapitre, vous serez capable de :
* Comprendre les bases de SyncML et la syntaxe générale ;
* Comprendre comment et pourquoi SyncML est mis en œuvre ;
* Trouver rapidement et utiliser les spécifications techniques de SyncML.

## Introduction

Les terminaux mobiles comme les PDA, les pagers, les téléphones mobiles et les ordinateurs portables ne sont par nature pas connectés en permanence à un réseau. Cependant, ces appareils contiennent des applications qui ont besoin d'informations provenant d'un réseau afin d'être utilisables. La plupart des PDA et mobiles possèdent des applications comme des calendriers, des listes de taches, des répertoires pour stocker des informations qui deviennent moins utiles à partir du moment où elles sont statiques, uniquement disponibles sur l'appareil. Par exemple, des copies statiques d'informations seront différentes de l'original dès qu'une modification est apportée d'un côté ou de l'autre. La synchronisation offre la possibilité à un terminal de se connecter à un réseau afin de mettre à jour à la fois l'information de l'appareil et l'information du réseau pour que les deux soient identiques et à jour.
Devant la prolifération d'appareils mobiles et de protocoles propriétaires ainsi que la demande croissante d'accès à de l'information en situation de mobilité, les sociétés leader sur le domaine ont compris l'intérêt de créer un langage standard et universel décrivant les actions de synchronisation entre les terminaux et les applications. Elles ont formé un consortium pour sponsoriser cette initiative et pour créer ce langage.
Actuellement, le consortium SyncML a été adopté et incorporé à l'Open Mobile Alliance, un regroupement de plus de 300 sociétés qui supporte plusieurs projets collaboratifs portant sur les technologies et les protocoles.

## Qu'est-ce que SyncML ?

SyncML ou Synchronization Markup Language est le protocole standard basé sur XML de synchronisation de données au travers d'une multitude de réseaux, de plates-formes et de terminaux. SyncML a été démarré en tant qu'initiative en 2000 par de grandes sociétés comme Ericsson, IBM, Palm Inc., Lotus, Matsushita Ltd. (Panasonic), Motorola, Nokia, Openwave, Starfish Software, Psion et Symbian. Leur but était la création d'un langage universel à partir de la myriade de protocoles de synchronisation propriétaires utilisés par les appareils mobiles et de fournir un ensemble complet de fonctionnalités de synchronisation pour les futurs terminaux. Le consortium a sorti la version 1.0 en décembre 2000. Ils ont développé des nouvelles fonctionnalités et résolu les problèmes découverts avec cette version, finalisant le protocole avec la version 1.1 en février 2002.
Le protocole SyncML a été conçu en gardant ces objectifs à l'esprit :
* Garder en cohérence deux ensembles de données
* Être indépendant du transport
* Être indépendant des données synchronisées (PIM, email, fichier, ....)
SyncML comprend des commandes client et serveur définies par des DTD...

## Principes de SyncML
### Vocabulaire

Commençons avec un peu de vocabulaire :
* Client - le terminal mobile, son application et sa base de données locale.
* Serveur - un système distant communiquant avec la base de données du système ou de l'application.
* Modifications - les données dans les champs d'une base de données qui sont modifiées.
* Synchronisation - le client et le serveur échangent des messages SyncML avec des commandes.
* Package - Balises XML conformes à la DTD de SyncML décrivant les requêtes ou actions qui doivent être effectuées par un client ou un serveur SyncML. Un package est un ensemble d'actions à effectuer.
* Message - La plus petite unité de balise SyncML. Les grands packages sont découpés en messages séparés.
* Mapping - Utilisation d'un identifiant intermédiaire pour lier deux informations. Exemple : Disons que 'vert' c'est '5', et '5' c'est bien. Qu'est-ce qui est bien ? Si vous répondez 'vert', vous êtes tombé juste. vous avez réalisé un mapping !
Abréviations :
| IMEI | International Mobile Equipment Identifier - numéro d'identification des terminaux mobiles |
| GUID | Global Unique Identifier - identifiant global unique |
| LUID | Local Unique Identifier - identifiant local unique |

### Messages et Packages

Un message est un ensemble de commandes SyncML transmises (en une seule fois) vers le client ou le serveur. La taille maximale d'un message est définie par la Meta données MaxMessageSize. Si un message à transmettre dépasse cette taille on le découpe en plusieurs messages. On parle alors de Multiple Message in Package. Un package correspond à un ensemble de messages pour effectuer une des étapes de la synchronisation. Les packages sont les suivants: pkg1 = initialisation du client (authentification, échange des devinf, des informations sur les bases à synchroniser), pkg2 = initialisation du serveur, pkg3 = modification côté client, pkg4 = modification côté serveur, pkg5 = mise à jour des données et statuts, pkg6 = mapping des id client et serveur.

### Structure d'un message SyncML

Comme SOAP, il y a deux parties dans un message SyncML, un en-tête <SyncHdr> et un corps <SyncBody>. L'en-tête contient des meta-informations sur la requête comme la base de données cible <Target> et la base de données source <Source>, les informations d'authentification <Cred>, l'identifiant de session <SessionID>, l'identifiant du message <MsgID>, et la déclaration de la version de SyncML <VerDTD>. Le corps contient les commandes SyncML (les statuts des commandes du message précédent, et toutes les autres commandes prévues par SyncML).

### Adressage

L'adressage est réalisé au travers des balises <Source> et <DocURI>. Un serveur aura une URI du genre http://www.chris.syncml.org/sync et le terminal mobile client aura un numéro d'identification IMEA comme ceci 30400495959596904.

### Mapping ou Correspondance

SyncML est basé sur l'idée que les clients et les serveurs peuvent avoir leur propre méthode pour faire correspondre les informations dans leur base de données. Aussi, les clients et les serveurs doivent avoir leur propre ensemble d'identifiants uniques.
En effet, par gain de place, certain terminaux mobile ne peuvent accepter des id trop longs, ils vont alors définir leur propres id, et envoyer au serveur le mapping à effectuer à l'aide de la balise <map>. De cette manière, le mobile ne stocke que l'id qu'il a choisi (généralement assez court) et le serveur, lui, stocke les deux, ce qui lui permet de s'adresser au mobile avec l'id que le mobile connait. Le serveur conserve l'ensemble des id indéfiniment.
Dans les futurs échanges, le mobile utilisera seulement l'id qu'il connait, et le serveur se chargera d'effectuer les mappings correspondants.
* Les identifiants locaux uniques (LUID - Locally Unique Identifiers) sont des nombres assignés par le client à une donnée dans la base de données locale (comme un champ ou une ligne). Ce sont des nombres non réutilisables assignés à ces objets par le client SyncML.
* Les identifiants globaux uniques (GUID - Globally Unique Identifiers) sont des nombres assignés à une donnée utilisés dans une base de données distante. Cet identifiant est assigné par le serveur.
Le serveur va créer une table de correspondance pour lier les LUID et GUID ensemble.
Données côté client
| LUID ---- 5 | Data ---- Green |
Données côté serveur
| GUID ---- 5050505 | Data ---- Green |
Correspondance sur le serveur
| GUID ---- 5050505 | LUID ---- 5 |

### Journaux de modification (change logs)

Les change logs sont une manière pour un device (client ou serveur) de déterminer la liste des modifications dans la base depuis la dernière synchro.

### Les ancres

Les ancres servent à savoir si la dernière synchro s'est bien passée. Au début de session, le client envoie ses ancres (last et next). Le serveur stock la next du client. À la fin de la session (s'il n'y a pas eu d'interruption), le client met à jour ses ancres (last = next et il incrémente next). Lors de la prochaine session, le client envoie son next et last. Le serveur vérifie que le last du client vaut le next qu'il a stocké précédemment. Si c'est le cas, c'est OK, on continue. Sinon, cela ne va pas du tout et le serveur PEUT forcer une slow sync.
Session 1 : C'est une slow sync : le client envoie juste son next. La synchro se passe nickel
Fin de synchro : last=1, next=2
Session 2 : Une interruption se produit lors de cette synchro
Comme la session va pas au bout, le client update pas ses ancres
Session 3 Après l'interruption on essaye de repartir
En comparant les ancres envoyées et celles stockées avec le type de synchronisation demandé, le serveur peut déterminer quel est l'information la plus récente. Par exemple, il est possible de réécrire une information 'nouvelle'- c'est l'information pour laquelle l'empreinte temporelle est la plus récente dans les logs- avec une information plus ancienne. Cela peut être fait en choisissant une synchronisation dans laquelle le client dit au serveur d'effacer ses informations avec les données client. Cette opération est appelée 'refresh sync from client'. Les différents types de synchronisation sont décris ci-dessous.

### Synchronisations (Syncs)

Dans sa version 1.1, le langage SyncML définit 7 types de synchronisation. La section ci-dessous définit ces différents types :
* Two-way Sync (Synchronisation bi-directionnelle) - Le client et le serveur s'échangent des informations relatives aux données modifiées. Le client transmet les modifications en premier.
* Slow sync (Synchronisation lente) - Le client renvoie l'intégralité de ses données. Le serveur calcule le delta (avec les siennes) et le renvoie au client. Ce type de synchronisation est généralement utilisé lors d'une première synchro, lors d'une interruption, ou lorsque l'une des deux parties le demande.
* One-way sync, client only (Synchronisation uni-directionnelle, Client uniquement) - Le client transmet ses modifications. Le serveur les accepte puis met à jour les données sans transmettre en retour ses modifications.
* Refresh sync from client (Synchronisation de mise à jour avec les donnés du client) - Le client transmet sa base de données entièrement au serveur. Le serveur remplace la base de données cible par celle transmise par le client.
* One-way sync, server only (Synchronisation uni-directionnelle, Serveur uniquement) - Le serveur transmet ses modifications au client. celui ci les accepte puis met à jour ses données locales sans transmettre en retour ses modifications.
* Refresh sync from server (Synchronisation de mise à jour avec les donnée du serveur) - Le serveur transmet l'intégralité des informations de sa base de données. La base de données du client est entièrement remplacée.
* Server alerted sync - Le serveur télé-commande au client d'initier un des modes de synchronisation présentés ci-dessus. De cette façon, le client est contrôlé à distance par le serveur.

### Initialisation de la synchronisation

L'initialisation de la synchronisation est un passage obligatoire pour le client et le serveur avant d’entamer une synchronisation. La première étape est que le client et serveur parlent le même langage, en s'échangeant l'un et l’autre leur capacité (définies par le matériel, comme la quantité de mémoire, et le protocole définit par la DTD). La seconde étape est l'identification des bases de données à synchroniser. Ensuite, les deux doivent décider du type de synchronisation. La troisième et dernière partie est l'authentification. Une fois que cette étape à été complétée avec succès, la synchronisation à proprement parler peut commencer.

### Authentification

Le serveur SyncML peut envoyer au client un message contenant la balise <Chal> qui représente une demande d'authentification (Challenge en anglais) pour les informations auxquelles le client tente d'accéder. Le client doit alors répondre et donner le login et mot de passe dans une balise <Cred> (Credential en anglais).
SyncML peut utiliser l'accès authentifié par le hachage md5. Le client et le serveur échangent leurs identifiants durant la phase d'authentification, retournant un code d'erreur si le processus s'arrête quelque part. La balise <Cred> est utilisée dans le <SyncHdr> pour fixer le type d'authentification qui sera utilisé dans la phase d'authentification. (Il y a le hashage md5, mais aussi l'encodage base64 et d'autres... Il faut donc que le serveur informe le client du type d'authentification utilisée).

## Common SyncML implementations

Nokia a été la première entreprise à commercialiser un téléphone mobile pouvant utiliser SyncML pour la synchronisation de la base de données du calendrier du téléphone. SyncML permet de synchroniser des listes de choses à faire, des calendriers, des carnets d'adresses, des carnets de numéros de téléphone, bien plus que ce qu'un organiseur peut faire. SyncML est capable de faire beaucoup plus de choses.
En fait, il serait même approprié d'utiliser SyncML à chaque fois que deux applications distantes différentes partagent les mêmes données.

## Syntaxe SyncML
### Exemple SyncML

Exemple de SyncML abrégé
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | <SyncML> <SyncHdr> <VerDTD>1.1</VerDTD> <VerProto>SyncML/1.1</VerProto> <SessionID>104050403</SessionID> <MsgID>5</MsgID> <Cred>...</Cred> </SyncHdr> <SyncBody> <Status>...</Status> <Sync> <Target>target database URI</Target> <Source>source database URI</Source> <Add>datafield and data</Add> <Replace>an existing data field with some data</Replace> </Sync> </SyncBody> </SyncML> |
Notez que la ligne {1} et {18} débutent le fichier SyncML par la balise racine. Ensuite, le SyncHdr est défini par les lignes {2} et {8}. Puis les ligne {3,4} qui définissent des informations concernant la version de SyncML utilisée, la ligne {5} définit l'identifiant de session (sessionID) qui permet d'identifier de façon unique le dialogue qui est en cours entre le client et le serveur, la ligne {6} représente l'identifiant du message (MsgID) qui permet d'identifier de façon unique cet ensemble de requêtes (toutes ces balises) qui vont être exécutées par l'application réceptrice. À la ligne {7}, on trouve la balise Cred (demande d'authentification, non détaillée ici) qui fait également partie de l'entête. La ligne {8} est la fermeture du SyncHdr (entête).
Le SyncBody (Corps du message) commence à la ligne {9}. Dans cette partie du message SyncML, on trouve : le status de l'application/l'appareil {10}, la source et cible de la requête (source/target) {12,13}, et les actions demandées comme la synchronisation elle-même entre les ligne {11,16}. Aux lignes {14,15}, on peut voir les commandes Add et Replace qui commandent respectivement l'ajout et le remplacement de données dans la base de donnée cible.

### WBXML et SyncML

WAP Binary XML (WBXML) est une forme de XML dans laquelle les tags sont abrégés dans le but de raccourcir les balises pour la transmission vers des périphériques mobiles. En effet, ces périphériques ont en général une bande passante et une mémoire limitées. Les tags XML sont encodés en binaire pour économiser de la place. Regardons l'exemple suivant, cela aura plus de sens.
Ce qui suit est du code binaire WBXML représentant un message SyncML. Notez que sur la première ligne il y a le définition du type de document, représentée ici en hexadécimal. Regardez ce qui est arrivé à la chaine suivante "//SYNCML//DTD SYNCML 1.1//EN"
Immédiatement après cette chaîne, on trouve les caractères '6D 6C 71'. Chacun d'entre eux représente un tag SyncML
Abréviations wbxml
| 6D 6C 71 | = "<SyncML>" = "<SyncHdr>" = "<VerDTD>" |
Abréviations wbxml (cont.)
| C3 03 "1" "." "1" 01 | = représente le début des données opaques = ceci représente la longueur de ces données opaques = le caractère "1" suivit d'un "." et de "1" = représente "</VerDTD>" |
le code snippet WBXML 6D6C71C303"1.1"01 représente :
Extrait d'une entête SyncML header snippet
| 1 2 3 | <SyncML> <SyncHdr> <VerDTD>1.1</VerDTD> |
Donc on peut voir que la syntaxe WBXML este plus compacte que XML, économisant du réseau pour les appareils mobiles.
Pour plus d'information, voir les articles de Ed Dumbill's sur syncML avec WBXML :
* Have Data, Will Travel
* WBXML and SyncML

## Spécifications de SyncML

La meilleure source d'informations sur SyncML c'est le protocole lui-même. Allez voir le site de l'Open Mobile Alliance pour obtenir les spécifications de SyncML.

### Open Mobile Alliance

Téléchargez les Spécifications et White Papers SyncML de l'OMA sur le site de l'Open Mobile Alliance. Ou regardez les articles sur SyncML sur le site de l'Open Mobile Alliance.

## Mises en œuvre de SyncML

Bien que les spécifications de SyncML soient utiles, vous devez toujours intégrer le protocole dans votre application. Il existe quelques boîtes à outils et transpositions que vous pouvez utiliser pour un démarrage rapide.

### Boîte à outils SyncML de référence

l'Open Mobile Alliance a publié une boîte à outils en C pour implémenter SyncML. Vous pouvez l'obtenir ici. Si vous comprenez l'allemand, vous pouvez obtenir un exemple d'application utilisant cette boîte à outils ici.

### Funambol

Si vous êtes intéressé par le développement d'application basée sur SyncML en Java, regardez le projet open source Funambol. Il propose une bibliothèque de classes Java mettant en œuvre le protocole de synchronisation de données SyncML, un framework Java pour construire des applications serveurs SyncML et un serveur SyncML indépendant.

## Conclusion sur SyncML

La technologie des appareils mobiles se développe très rapidement, et la 4G permet de nouveaux appareils puissants sur le marché. Ces derniers proposent du streaming multimédia, et auront pour valeur ajoutée leurs applications personnalisées et services synchronisés en SyncML.

## Exercice

Exercices
Visiter le site de l'Open Mobile Alliance, et télécharger le PDF du protocole SyncML v. 1.1 pour répondre à ces questions :
* Qu'est-ce qu'est le WBXML et où est-il utilisé ?
* Quelles sont les prévisions pour SyncML ?
* Nommer une situation problématique où SyncML est la meilleure solution.
Solution
* WBXML is Wap Binary XML, it is a form of XML whereby the XML tags are abbreviated in order to shorten the markup for transmission to mobile devices, which commonly have bandwidth and memory limitations.
* SyncML will likely be used as a general, standard synching mechanism for synchronizing data sets between systems, not just for mobile devices.
* A ticket-tracking system called TNT helpdesk is a web-based open work request management system. The staff funning this system would like to have live data from this system on their PDAs, listing open requests. Currently, the PDA database is synched via a docking synch station attached to the staff members' PCs. Staff members have to download the request list as a CSV file, convert it into a usable PDA database and upload it to the PDA, making it this process cumbersome, prone to error, and always out-of-date. Recommendation: Create a custom app to push live updates to the PDAs using SyncML over Bluetooth/Wireless

## Références

* ↑ http://technical.openmobilealliance.org/Technical/technical-information/release-program/current-releases/syncml-archive
* Dumbill, E.(2003, March 1). XML Watch: WBXML and basic SyncML server requirements. IBM.com. Retrieved April 6, 2004 from http://www-106.ibm.com/developerworks/xml/library/x-syncml2.html
* Open Mobile Alliance (2002, April 2). SyncML version 1.0, 1.1 specification, white paper, errata. Retrieved April 6, 2004 from http://www.openmobilealliance.org/tech/affiliates/syncml/syncmlindex.html
* SyncML Initiative, Ltd.(2000, December 7). SyncML Specification Protocol version 1.0. The Open Mobile Alliance. Retrieved April 6, 2004 from http://www.openmobilealliance.org/tech/affiliates/syncml/syncml_represent_v10_20001207.pdf
* SyncML Initiative, Ltd.(2002, February 15). SyncML Device Information DTD version 1.1. . Retrieved April 6, 2004 from http://www.openmobilealliance.org/tech/affiliates/syncml/syncml_devinf_v11_20020215.pdf
* Site de synchronisation (démo gratuite et webmaster très sympathique) http://www.memotoo.com/

# MathML

Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
MathML est l'utilisation du formalisme XML pour décrire des formules mathématiques.
Il s'agit bien de description de contenu et non pas de mise en forme ; cela permet de faire varier le rendu selon une feuille de style, et notamment selon des préférences nationales. Par exemple, le vecteur « V » sera noté <ci type="vector">V</ci>, et pourra être rendu V pour un anglo-saxon et ${\vec {V}}$ pour un français .

## Enjeu

La notation mathématique est complexe. Il existe déjà des langages permettant de représenter les mathématiques, comme LaTeX. L'enjeu ici est, outre de permettre un rendu correct à l'affichage et à l'impression, de permettre d'utiliser les données par d'autres programmes.
Ainsi, une équation écrite en MathML pourrait être reprise par un solveur qui en donnerait les solutions, ou bien par un traceur qui en dessinerait le graphe, ou encore par un navigateur vocal pour malvoyant.

## Format de fichier

Le fichier contenant le code MathML doit contenir la déclaration de type de document (DTD) suivante :
pour du MathML 2.0. Si le code est inclus dans du HTML, on peut utiliser une DTD HTML étendue au MathML :
Le code MathML est introduit par la balise <math> et est conclu par la balise </math>. Lorsque le code MathML est à l'intérieur d'un document XML contenant d'autres types de données, il faut s'assurer de la bonne gestion de l'espace des nom en utilisant la balise d'ouverture <math xmlns="http://www.w3.org/1998/Math/MathML">. Pour éviter les confusions de balises, on peut imposer un préfixe à toutes les balises MathML. Par exemple, si l'on veut imposer le préfixe m:, on utilise (exemple de HTML) :
ou bien

## Exemple élémentaire et balises de base

La formule
    $(a+b)^{2}$
s'écrit de deux manières avec MathML :

### Description de présentation

On a donc :
* les identifiants (par exemple les noms de variables, qui sont des textes et symboles devant être affichés tels quels), sont encadrés par les balises <mi>…</mi> (math identifier) ;
* les opérateurs sont encadrés par les balises <mo>…</mo> (math operator) ;
* les nombres sont encadrés par les balises <mn>…</mn> (math number) ;
* les expressions devant être considérées comme un groupe sont encadrées par <mrow>…</mrow> (math row) ;
* mfenced qui fournit un encadrement, des parenthèses en l'occurrence ;
* msup qui accepte contient deux sous-éléments : la base (ici, « (a + b) ») et l'exposant (ici « 2 »).
On peut représenter la structure de la formule sous la forme d'un arbre :

### Description de contenu

On remarque que l'on utilise ici la notation polonaise (notation préfixée), de type :
On a :
* les balises <apply>…</apply> qui signifient « applique l'opérateur (le premier élément) aux éléments suivants » ;
* les balises d'opérateur, qui sont des balises sans fermeture : <power /> pour l'élévation à la puissance et <plus /> pour l'addition ;
* les balises qui indiquent la fonction d'éléments : <ci>…</ci> pour les identifiants et <cn>…</cn> pour les nombres.
La description de présentation est plus proche des langages orientés impression comme LaTeX ; cela permet de transposer facilement les formules. La description de contenu permet une interprétation facile de la formule en tant que telle. Si nécessaire, on peut mélanger les deux types de description, à condition d'être rigoureux :
* dans une description de présentation, un élément de contenu devrait être un fragment ayant un sens pris isolément ;
* dans une description de contenu, un élément de présentation devrait être à l'intérieur d'un élément de caractère (un « jeton ») de type variable ou nom de fonction.

## Éléments

Comme en HTML, et en général en XML, ce qui est compris entre une balise d'ouverture et une balise de fermeture est appelé un « élément ». On distingue trois types d'éléments :
* les éléments de présentation, comme mrow, msup, mi, mo et mn ;
* les éléments de contenu, comme partialdiff, leq et tan ;
* les éléments d'interface.

## Voir aussi

* Wikipédia propose un article sur : « MathML ».

# XUL

XUL, pour XML-based User interface Language, est un langage de description d'interfaces graphiques fondé sur XML créé dans le cadre du projet Mozilla.

## Exemple Simple : Hello World

Voici une comparaison entre quelques lignes de code XUL et HTML qui affichent toutes deux le traditionnel « Hello World! » :
XUL
HTML

## Références

* (en) « Page officielle de la doc XUL de Mozilla »
* « Le wiki xulfr.org comporte des aides sur XUL »
* (en) par Alice Corbin, « Xul Periodic Table » (NB : ne fonctionne qu'avec un navigateur basé sur Gecko)