Ceci est la version imprimable de Programmation XML.

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.

Programmation XML

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

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la Licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans Texte de dernière page de couverture. Une copie de cette licence est incluse dans l'annexe nommée « Licence de documentation libre GNU ».

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^[1], 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 
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 :

<balise>

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 :

</balise>

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.

<div></div> donne <div />

Les attributs

Les balises ouvrantes et les balises vides peuvent être enrichies avec des attributs.

<root>
     <item id="67af65c75b" date="22/01/2006">Contenu de l'élément</item>
     <break mode="immediat"/>
</root>

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^[2].

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^[3].

Une instruction de traitement commence par un point d'interrogation « ? ».

Exemple :

<?php echo date("d/m/Y") ?>

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 .

Exemple :

<!-- Ceci est un commentaire utilisé dans les langages web  -->

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
<	<	Symbole « inférieur »
>	>	Symbole « supérieur »
&	&	Esperluette, « et » commercial
'	'	guillemet simple
"	"	guillemet double

Toujours sans déclaration de doctype spécial, on peut écrire une entité avec « & », « # », une référence Unicode^[1] et un « ; ».

Entité	Caractère	Description
π	π	pi
β	β	bêta

Exemple

<balise>Étudions la balise &amp;lt;p&amp;gt;</balise> Étudions la balise &lt;p&gt;

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^[1]. 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…

<?xml version="1.0"?> <!-- minimal -->

     <!-- ou -->

<?xml version="1.0" encoding="utf-8"?>

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.

<!DOCTYPE root[
<!ELEMENT root (premier,deuxieme+)>
<!ELEMENT premier (#PCDATA)>
<!ELEMENT deuxieme (#PCDATA)>
]>

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é.

<?xml-stylesheet type="text/xsl" href="../../style.xsl"?>
	<!-- ou -->
<?xml-stylesheet type="text/css" href="../../style.css"?>

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.

<root>
    <balise1>
         <balise2>
         </balise2>
    </balise1>
</root>

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.

Exemple de structure simple

<?xml version="1.0" ?>
<root>
     <items>
         <item no="1">Premier élément</item>
         <item no="2">Autre chose</item>      
         <item no="3">Troisième élément</item>
         <item no="4">Quatrième élément</item>
     </items>
</root>

É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,0 ^1,1 et ^1,2 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 :

<adresse
 xmlns="http://www.example.com/adresses_postales"
 xmlns:ip="http://www.example.com/adresses_ip">

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 :

<!DOCTYPE repertoire SYSTEM "repertoire.dtd">

La DTD commence par la balise :

<!DOCTYPE nom-element-racine [

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 :

<!-- commentaires -->

Éléments

Chaque élément de la DTD est défini de la manière suivante^[1] :

<!ELEMENT nom-element qualificateur>

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)

<!ELEMENT personne(telephone)>

0 ou plusieurs sous-éléments :

(une personne peut avoir 0, 1 ou plusieurs téléphones)

<!ELEMENT personne(telephone*)>

1 ou plusieurs éléments :

(une personne doit avoir au moins un téléphone)

<!ELEMENT personne(telephone+)>

0 ou 1 seul élément :

(une personne a au maximum 1 téléphone, elle peut ne pas en avoir)

<!ELEMENT personne(telephone?)>

Plusieurs sous-éléments différents :

(une personne a un nom et un téléphone)

<!ELEMENT personne(nom, telephone)>

Des sous-éléments identiques ou non :

(une personne a un nom et deux numéros de téléphone)

<!ELEMENT personne(nom, telephone, telephone)>

Un sous-élément OU (exclusif) un autre :

(un ou deux téléphone par personne)

<!ELEMENT personne(telephone|(telephone, telephone))>

Exemple du stockage d'un répertoire de services. Chaque service a un nom et peut avoir un ou plusieurs téléphone(s) :

<?xml version="1.0" standalone="yes"?>
<!DOCTYPE repertoire [
	<!ELEMENT repertoire (service)*>
	<!ELEMENT service (nom, tel*)>
	<!ELEMENT nom (#PCDATA)>
	<!ELEMENT tel (#PCDATA)>
]>
<repertoire>
   <service>
      <nom>pompiers</nom>
      <tel>18</tel>
   </service>
   <service>
      <nom>police</nom>
      <tel>17</tel>
      <tel>22</tel>
   </service>
   <service>
      <nom>samu</nom>
      <tel>15</tel>
   </service>
</repertoire>

Attributs

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

<!ATTLIST paiement type CDATA (chèque|liquide) "liquide" >

Valeurs des attributs

Les valeurs d'attributs (attribute-value^[2]) 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 ' " '^[3]) et suivi d'un point virgule (';'). Ex :

<!ENTITY intro! SYSTEM "https://fr.wikibooks.org/wiki/Programmation_XML/Introduction.xml">!

<b>
 &intro;
</b>

Exemple

Extrait du cahier des charges XHTML^[4] concernant les hyperliens :

<!ENTITY % attrs "%coreattrs; %i18n; %events;">
...
<!ELEMENT link EMPTY>
<!ATTLIST link
  %attrs;
  charset     %Charset;      #IMPLIED
  href        %URI;          #IMPLIED
  hreflang    %LanguageCode; #IMPLIED
  type        %ContentType;  #IMPLIED
  rel         %LinkTypes;    #IMPLIED
  rev         %LinkTypes;    #IMPLIED
  media       %MediaDesc;    #IMPLIED
  target      %FrameTarget;  #IMPLIED
  >

Références

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)^[1]

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

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

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

Cette section est vide, pas assez détaillée ou incomplète. Votre aide est la bienvenue !

XPath

Syntaxe

Le XPath est un langage de sélection de différents types d'objets XML, appelés « nœuds »^[1]. Un ensemble de nœuds est appelé « contexte ».

Le XPath se présente sous la forme de chemins composés de^[2] :

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.

Il existe un interpréteur en ligne pour réaliser les exemples décrits ci-dessous : http://www.xpathtester.com/.
La classe http://www.php.net/manual/fr/domxpath.query.php permet de les programmer.

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^[3] :

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) :

//branche[2]
//branche[@nom="branche2"]
/tronc/branche[last()]
/tronc/branche[position()=2]

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 :

<?xml version="1.0" encoding="UTF-8"?>
<tronc nom="tronc1"> 
	<!-- commentaire 1 --> 
	<branche nom="branche1" epaisseur="gros"> 
		<brindille nom="brindille1"> 
			<!-- commentaire 2 --> 
			<feuille nom="feuille1" couleur="marron" />
			<feuille nom="feuille2" poids="50" />
			<feuille nom="feuille3" /> 
		</brindille> 
		<brindille nom="brindille2">
			<feuille nom="feuille4" poids="90" /> 
			<feuille nom="feuille5" couleur="violet" />   
		</brindille>
	</branche> 
	<branche nom="branche2">
		<brindille nom="brindille3"> 
			<feuille nom="feuille6" /> 
		</brindille> 
		<brindille nom="brindille4">	
			<feuille nom="feuille7" /> 
			<feuille nom="feuille8" /> 
			<feuille nom="feuille9" couleur="noir" /> 
			<feuille nom="feuille10" poids="100" />	 
		</brindille>
	</branche> 
	<branche nom="branche3">
		<brindille nom="brindille5"> 
		</brindille> 
	</branche> 
</tronc>

Abréviations

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

PHP

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

<?php
  $file = 'tronc.xml';
  $xpath = "/tronc/branche/brindille/feuille[last()]";
  if(file_exists($file)) {
    $xml = simplexml_load_file($file);
    if($result = $xml->xpath($xpath)) {
		print 'Résultats :';
		var_dump($result);
    } else {
      echo 'Syntaxe invalide.';
	}
  }
  else
    exit("Le fichier $file n'existe pas.");
?>

eXist ou BaseX

Pour plus de détails voir : XQuery.

Références

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.

Les exemples ci-dessous sont vérifiables avec l'outil http://www.w3schools.com/xsl/tryxslt.asp?xmlfile=cdcatalog&xsltfile=cdcatalog

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^[1] dans le fichier PHP.ini :

extension=php_xsl.dll

Il n'y a donc rien a installer pour charger les deux fichiers publiés ci-dessus :

<?php
$XML = new DOMDocument();
$XML->load('note.xml');

$XSL = new DOMDocument();
$XSL->load('note.xsl', LIBXML_NOCDATA);

$xslt = new XSLTProcessor();
$xslt->importStylesheet($XSL);

print $xslt->transformToXML($XML);
?>

Syntaxe avancée

Éléments

Éléments XSL^[2]^[3]	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^[4]	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^[5]	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

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).

Exemple

<xsd:complexType name="Type_de_genre">
  <xsd:sequence>
    <xsd:element name="nom" type="xsd:string"/>
    <xsd:element name="description" type="xsd:string"/>
    <xsd:element name="film" type="Type_de_film" minOccurs="1" maxOccurs="unbounded"/>
  </xsd:sequence>
</xsd:complexType>
<!-- Type_de_film est un enfant de Type_de_genre qui l'appelle par son nom -->
<xsd:complexType name="Type_de_film">
  <xsd:sequence>
    <xsd:element name="nom" type="xsd:string"/>       
    <xsd:element name="acteur" type="Type_d_acteur" minOccurs="1" maxOccurs="unbounded"/>
  </xsd:sequence>
</xsd:complexType>
<!-- Exemple de restriction en regex -->
<xsd:simpleType name="Type_d_adresse_email">
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="[^@]+@[^\.]+\..+"/>
  </xsd:restriction>
</xsd:simpleType>

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 :

Article encyclopédique sur Wikipédia.

XQuery est une recommandation W3C de sélection de données depuis des documents et bases de données basée sur XML.

Sommaire

Exemples basiques

Exemples intermédiaires

Recherche

Interaction

Vues personnalisées

Transformation de documents XML complexes

Rapports paginés

Publication de contenu

Comparaison et fusion de XML

Requêtes basées sur le temps

Documents

XML Schemas

Liens avec d'autres langages

Virtualisation

Google

Page Scraping

Mapping

Timelines

Web sémantique

Outils de développent

Validation

Path Analysis

Securité

Unit Testing Tools

Études de cas

Modules eXistdb

Annexes

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

Processus de création d'un document de présentation.

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^[1] :

<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">

 <fo:layout-master-set>
  <fo:simple-page-master master-name="A4">
    <fo:region-body />
  </fo:simple-page-master>
 </fo:layout-master-set>

 <fo:page-sequence master-reference="A4">
  <fo:flow flow-name="xsl-region-body">
    <fo:block>Hello world</fo:block>
  </fo:flow>
 </fo:page-sequence>

</fo:root>

Le modèle des aires

Modèle d'une page simple

Format du tableau :

 ------------------------------------      -- 
 |                                  |       1
 |    ------------------------      |      --
 |    |                      |      |       2
 |    ------------------------      |      --
 |    |    |            |    |      |       3
 |    |    |    ------- |    |      |      --
 |    |    |    |     | |    |      |       4
 |    |    |    |     | |    |      |        
 |    |    |    |     | |    |      |       
 |    |    |    |     | |    |      |       
 |    |    |    ------- |    |      |      --
 |    |    |            |    |      |       5
 |    ------------------------      |      --
 |    |                      |      |       6
 |    ------------------------      |      --
 |                                  |       7
 ------------------------------------      -- 

 | 1  | 2 |   3 | 4  |5|  6  |  7   |

Page viewport area			I margin-top
	region-before region viewport area

___		Region-body region viewport area		___

	region-after region viewport area
			I margin-bottom

L'affinage et la résolution des propriétés

Cette section est vide, pas assez détaillée ou incomplète. Votre aide est la bienvenue !

Les objets de mise en forme

Cette section est vide, pas assez détaillée ou incomplète. Votre aide est la bienvenue !

Les propriétés de mise en forme

Cette section est vide, pas assez détaillée ou incomplète. Votre aide est la bienvenue !

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

Client                     Serveur
 |---------next=1------------>|        next client = 1
 |
 |
 |
 |

Fin de synchro : last=1, next=2

Session 2 : Une interruption se produit lors de cette synchro

Client                        Serveur
 |--------last=1, next=2------>|          last = next stocké (1). next client devient 2
 |                             |
 |
Interruption

Comme la session va pas au bout, le client update pas ses ancres

Session 3 Après l'interruption on essaye de repartir

Client                      Serveur
 |------last=1, next=2------>|          CA MATCH PAS : 1!= 2 La dernière synchro s'est mal passée ! Le serveur peut demander une slow sync
 |

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é

<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 :

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^[1], 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

Ébauche (Liste complète des ébauches)

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 « modifier »).

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 [1].

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 [2] :

<!DOCTYPE math 
  PUBLIC "-//W3C//DTD MathML 2.0//EN"
  "http://www.w3.org/Math/DTD/mathml2/mathml2.dtd" >

pour du MathML 2.0. Si le code est inclus dans du HTML, on peut utiliser une DTD HTML étendue au MathML :

<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
  "http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd" >

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) :

<body xmlns:m="http://www.w3.org/1998/Math/MathML">
  <m:math>
    <m:mrow>…</m:mrow>
  </m:math>
</body>

ou bien

<math xmlns:m="http://www.w3.org/1998/Math/MathML">
  <m:mrow>…</m:mrow>
</math>

Exemple élémentaire et balises de base

La formule

(a+b)^{2}

s'écrit de deux manières avec MathML :

Description de présentation

<mrow>
  <msup>
    <mfenced>
      <mrow>
        <mi> a </mi>
        <mo> + </mo>
        <mi> b </mi>
      </mrow>
    </mfenced>
    <mn> 2 </mn>
  </msup>
</mrow>

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) [3] ;
les opérateurs sont encadrés par les balises <mo>…</mo> (math operator) [4] ;
les nombres sont encadrés par les balises <mn>…</mn> (math number) [5] ;
les expressions devant être considérées comme un groupe sont encadrées par <mrow>…</mrow> (math row) [6] ;
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

<mrow>
  <apply> <power/>
    <apply> <plus/>
      <ci> a </ci>
      <ci> b </ci>
    </apply>
    <cn> 2 </cn>
  </apply>
</mrow>

On remarque que l'on utilise ici la notation polonaise (notation préfixée), de type :

(^ (+ a b) 2)

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

  <window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
    <box>
      <description>Hello world!</description>
    </box>
  </window>

HTML

  <html>
    <body>
      <p>
        Hello World!
      </p>
    </body>
  </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)

GFDL

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans texte de dernière page de couverture.

[unicode-1] 1,0 ^1,1 et ^1,2 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.

[2] ttp://www.w3schools.com/xml/xml_attributes.asp

[3] « Le point sur les instructions de traitement », sur yoyodesign.org

[4] ttp://www.w3schools.com/dtd/dtd_elements.asp

[5] ttp://www.w3schools.com/dtd/dtd_attributes.asp

[6] ttp://xmlwriter.net/xml_guide/entity_declaration.shtml

[7] ttp://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd

[8] ttp://pyxml.sourceforge.net/topics/

[9] ttp://www.w3schools.com/dom/dom_nodetype.asp

[10] ttp://www.w3schools.com/xpath/xpath_syntax.asp

[11] ttp://www.w3.org/TR/xpath#corelib

[12] ttp://www.php.net/manual/fr/book.xsl.php

[13] ttp://www.w3schools.com/xsl/xsl_w3celementref.asp

[14] ttp://www.w3.org/TR/xslt#element-syntax-summary)

[15] ttp://www.w3schools.com/xsl/xsl_functions.asp

[16] ttp://www.w3schools.com/xsl/xsl_functions.asp

[17] ttp://www.w3schools.com/xslfo/xslfo_output.asp

[18] ttp://technical.openmobilealliance.org/Technical/technical-information/release-program/current-releases/syncml-archive

[1]

[2]

[3]

[1]

[2]

[3]

[4]

[1]

[1]

[2]

[3]

[1]

[2]

[3]

[4]

[5]

[1]

[1]