XMLTemplater

Pour chaque entité qui entre par le port Root, le modèle XML Root est évalué et le résultat est inséré dans le paramètre Attribut Résultat.

Les entités ressortent via ce port après avoir été traitées par le Transformer.

Grouper par sous entités, les sous entités groupées sont consécutives

Le paramètre Regrouper les sous-entités par permet un filtrage plus grossier des sous-éléments que les paramètres de la fonction fme:process-features. Lorsque ce paramètre est défini comme une liste de noms d'attributs, la fonction fme:process-features ne traitera que les sous-entités qui ont les mêmes valeurs pour ces attributs que l'entité en cours de traitement. Notez que ce paramètre n'a aucun effet sur les entités Root. Chaque entité Root sera traitée et produite par le Transformer. Lors du regroupement de sous-entités, si toutes les entités de chaque groupe sont consécutives, les performances du Transformer peuvent être améliorées en réglant le paramètre Les sous-entités groupées sont consécutives sur Oui. Lorsque cette valeur est définie, les entités Root seront traitées dès que toutes les sous-entités applicables seront arrivées au Transformer. Cela signifie que le Transformer fonctionnera de manière non-bloquante, plutôt que d'attendre que toutes les entités arrivent avant de commencer à traiter les modèles. Le comportement du Transformer est indéfini si les entités d'un groupe n'arrivent pas toutes consécutivement. Il est probable que certaines entités secondaires ne seront pas traitées si cela se produit.

Un modèle XML est simplement un document XML qui contient des fonctions XQuery. Essentiellement, ces fonctions sont des espaces réservés aux valeurs de données. Lorsque le modèle est traité, les fonctions sont évaluées et les résultats sont insérés dans le document. Le plus souvent, cette fonction est utilisée pour insérer des valeurs d'attributs d'entités dans le document. Les noms des attributs à insérer sont spécifiés à l'aide des mêmes fonctions XQuery utilisées dans plusieurs autres Transformers : XMLUpdater, XMLXQueryExtractor, XMLXQueryExploder, etc.

Dans le XMLTemplater, les fonctions fme:get-attribute, fme:get-list-attribute et fme:get-xml-attribute sont particulièrement utiles. Seules les fonctions qui ne modifient pas l'entité sont autorisées. Consultez la documentation sur les fonctions XQuery pour plus d'informations sur les fonctions disponibles.

Le modèle XML suivant remplit un élément XML avec la valeur d'attribut "id".

<road>

<id>{fme:get-attribute("id")}</id>

</road>

Les fonctions XQuery peuvent être utilisées pour remplir l'attribut XML.

<road id="{fme:get-attribute("id")}" />

Pour remplir une séquence d'éléments XML avec le contenu d'une liste, une boucle est utilisée pour itérer sur les éléments de la liste :

<roads>

{

for $road_id in fme:get-list-attribute("road_ids{}")

return <road id="{$road_id}"/>

}

</roads>

Un cas d'utilisation courant consiste à écrire un élément XML uniquement si un attribut d'entité a une valeur. Pour ce faire, on utilise une instruction if-then-else. L'exemple suivant écrit l'élément displayName uniquement si l'entité contient un attribut display_name et si la valeur de cet attribut n'est pas une chaîne vide.

<road>
{ if( fme:has-attribute("display_name") and 
      not(fme:get-attribute("display_name") eq "") )
then <displayName>{fme:get-attribute("display_name")}</displayName>
else ()
}
</road>

Lorsqu'un modèle est évalué, il ne peut accéder qu'aux attributs de l'entité en cours de traitement. Afin de permettre à un modèle d'accéder aux attributs de plusieurs entités, le concept de sous-modèles a été introduit. En utilisant la fonction fme:process-features, le Transformer peut évaluer un sous-modèle sur un ensemble d'entités, puis insérer les résultats dans le premier modèle. Dans l'interface du Transformer, un nom est attribué à chaque sous-modèle. Ce nom sera ensuite utilisé dans l'appel fme:process-features pour identifier le sous-modèle à évaluer. En outre, un port d'entrée de Transformer sera créé pour chaque sous-modèle. Le sous-modèle sera traité sur les entités qui entrent dans l'entrée du Transformer correspondant. Les entités qui entrent dans l'un de ces ports d'entrée seront appelées des sous-modèles.

Dans l'exemple suivant, le modèle Root construit un élément <village>, avec des informations provenant d'une seule entité. Il remplit ensuite l'élément <maisons>, en utilisant les valeurs d'attribut des entités qui sont entrées dans le port d'entrée HOUSE.

<village>

<name>{fme:get-attribute("name")}</name>

<population>{fme:get-attribute("population")}</population>

<houses>

{fme:process-features("HOUSE")}

</houses>

</village>

Le modèle associé au port d'entrée HOUSE créet un élément <house>.

<house>

<address>{fme:get-attribute("address")}</address>

<owner>{fme:get-attribute("owner")}</owner>

</house>

Si une unique entité entre par le port Root et deux entités entrent par le port HOUSE, le document XML généré pourrait ressembler à cela :

<village>

<name>Anytown, USA</name>

<population>2568</population>

<houses>

<house>

<address>123 Main Street</address>

<owner>John Doe</owner>

</house>

<house>

<address>324 Main Street</address>

<owner>Jane Doe</owner>

</house>

</houses>

</village>

Un modèle peut appeler plusieurs sous-modèles. Par exemple, dans l'exemple ci-dessus, nous pourrions ajouter un autre sous-modèle nommé BUSINESS, puis utiliser la fonction process-features pour exécuter ce sous-modèle à partir du modèle Root. En outre, un sous-modèle peut exécuter un autre sous-modèle, avec la restriction qu'un sous-modèle ne peut pas directement ou indirectement s'exécuter lui-même.

Sélection des sous-entités à traiter

Les entités qui entrent dans le XMLTemplater présentent souvent une structure hiérarchique. Par exemple, chaque village aura un certain nombre de maisons, et chaque maison aura plusieurs pièces, etc. Si la fonction fme:process-features est utilisée comme décrit ci-dessus, le document résultant ne sera probablement pas correct. Supposons qu'il y ait deux villages, chacun avec cinq maisons. Chaque village et chaque maison sont représentés par une entité FME distincte. Les entités du village sont acheminées vers le port d'entrée Root, tandis que les entités de la maison sont acheminées vers le port d'entrée HOUSE.

Si le Transformer est exécuté avec les modèles ci-dessus, il y aura deux entités de sortie, comme prévu. Cependant, les deux éléments <village> comprendront les dix éléments <house>. Le comportement correct est d'évaluer le sous-modèle uniquement sur les éléments HOUSE qui correspondent à l'entité village actuelle.

La fonction fme:process-features permet de le faire. Des paramètres de fonction supplémentaires peuvent être utilisés pour filtrer les entités à traiter. Le deuxième paramètre est une liste de noms d'attributs, et le troisième est une liste de valeurs d'attributs. Seules les entités dont les attributs correspondent à la liste donnée de noms et de valeurs d'attributs seront traitées.

Cette fonction évaluera le sous-modèle HOUSE sur toutes les entités HOUSE dont l'attribut village_id correspondra à l'id de l'entité en cours.

fme:process-features("HOUSE", "village_id", fme:get-attribute("id"))

Il est possible de spécifier plus d'une paire attribut/valeur. Dans ce cas, les noms et les valeurs des attributs doivent être contenus entre parenthèses. L'appel de fonction suivant évalue le sous-modèle HOUSE sur toutes les entités HOUSE dont l'attribut village_id correspond à l'attribut id de l'entité actuelle et dont l'attribut num_floors est égal à 2.

fme:process-features("HOUSE", ("village_id","num_floors"), (fme:get-attribute("id"), 2) )

Exécuter plusieurs sous-modèles avec un unique appel de fonction

Il est possible d'évaluer plusieurs sous-modèles en utilisant un seul appel de fonction. Il suffit de passer une liste de noms de modèles à la fonction fme:process-features. Les sous-modèles seront évalués sur chacune des entités nommées dans la liste. Les entités seront traitées dans l'ordre dans lequel elles sont entrées dans le Transformer. L'appel de fonction suivant traite les sous-modèles HOUSE et BUSINESS :

fme:process-features( ("HOUSE","BUSINESS") )

Les paramètres de sélection de sous-entités peuvent encore être utilisés lorsque la fonction fme:process-features est utilisée pour évaluer plusieurs sous-modèles.

Exécuter un sous-modèle sur la même entité

Il est possible d'évaluer un sous-modèle en utilisant la même entité que celle qui est utilisée pour évaluer le modèle actuel. La fonction fme:process-template prend un nom, ou une liste de noms, de sous-modèles qui doivent être évalués. Ces modèles seront évalués et les résultats seront insérés dans le modèle actuel. Pour évaluer un modèle, il suffit d'entrer le nom du sous-modèle comme paramètre de la fonction. Par exemple, pendant le traitement d'une entité HOUSE, nous pouvons évaluer le modèle OWNER en utilisant l'appel de fonction suivant. Le modèle OWNER sera évalué en utilisant l'entité qui est entrée dans le port d'entrée HOUSE.

fme:process-template("OWNER")

Pour évaluer plusieurs modèles, insérer une liste de noms :

fme:process-template( ("OWNER","ADDRESS") )

Cette technique peut être utilisée pour modulariser les modèles XML, en déplaçant les structures de modèles répétées en un seul endroit. Par exemple, si les maisons et les entreprises ont une adresse, l'adresse pourrait être extraite dans un modèle ADDRESS, et les modèles HOUSE et BUSINESS pourraient alors utiliser la fonction fme:process-template pour insérer les valeurs d'adresse. De cette façon, il n'est pas nécessaire de dupliquer le modèle d'adresse dans les modèles de MAISON et de COMMERCE.

Les modèles de géométrie peuvent être utilisés pour écrire une géométrie XML personnalisée. Il existe un grand nombre de fonctions permettant l'extraction de données géométriques et le traitement de sous-modèles sur des géométries. Pour plus d'informations, consultez la documentation sur les fonctions XQuery pour obtenir une liste de toutes les fonctions de géométrie et savoir comment écrire des données géométriques à l'aide de sous-modèles.

Les sous-modèles géométriques opèrent de la même manière que les sous-modèles classiques à l'exception qu'un sous-modèle géométrique ne crée pas un port d'entrée sur le Transformer.

Lorsqu'un modèle géométrique est traité, les fonctions qui accèdent aux attributs de l'entité (fme:get-attribute , etc) restent toujours utilisables.

Valider les noms attributs/modèles

Lors de la spécification d'un modèle XML via le paramètre Expression du modèle ou le paramètre Fichier du modèle, le Transformer vérifiera que tous les attributs des entités référencées sont présents dans une entité entrante. Si des attributs sont manquants (non exposés) dans les entités d'entrée, le Transformer sera surligné en rouge comme étant incomplet. Dans ce cas, l'annotation de résumé du Transformer indiquera les attributs manquants auxquels le modèle XML fait référence. De plus, quand des noms de sous-modèles sont passés aux fonctions fme:process-features et fme:process-template, les noms seront validés pour s'assurer qu'ils correspondent aux noms donnés dans l'interface du Transformer. Pour ne pas effectuer cette vérification, il suffit de passer le paramètre à Non.

Écrire l'en-tête XML

Spécifie si le document XML mis à jour doit commencer par une déclaration d'en-tête XML. Par défaut, la sortie contiendra un en-tête XML. Omettre l'en-tête peut être utile lorsque la sortie doit être concaténée avec d'autres valeurs dans un document XML plus important.

Résultat XML

Nomme l'attribut dans lequel le document XML mis à jour est écrit. La valeur par défaut est _result.

Définir les valeurs

Il existe plusieurs façons de définir une valeur à utiliser dans un Transformer. La plus simple consiste à saisir simplement une valeur ou une chaîne de caractères, qui peut inclure des fonctions de différents types telles que des références d'attributs, des fonctions mathématiques et de chaînes de caractères, et des paramètres traitement.

Utilisation de l'éditeur de texte

L'éditeur de texte fournit un moyen efficace de construire des chaînes de textes (dont les expressions régulières) à partir de données source diverses, telles que des attributs, des paramètres et des constantes, et le résultat est directement utilisé dans le paramètre.

Editeur de texte

Utilisation de l'éditeur arithmétique

L'éditeur arithmétique fournit un moyen simple de construire des expressions mathématiques à partir de plusieurs données source, telles que des attributs et des fonctions, et le résultat est directement utilisé dans un paramètre.

Éditeur arithmétique

Valeur conditionnelle

Définit des valeurs selon un ou plusieurs tests.

Fenêtre de définition de conditions

Contenu

Les expressions et chaînes de caractères peuvent inclure des fonctions, caractères, paramètres et plus.

Lors du paramétrage des valeurs - qu'elles soient entrées directement dans un paramètre ou construites en utilisant l'un des éditeurs - les chaînes de caractères et les expressions contenant des fonctions Chaîne de caractères, Math, Date et heure ou Entité FME auront ces fonctions évaluées. Par conséquent, les noms de ces fonctions (sous la forme @<nom_de_fonction>) ne doivent pas être utilisés comme valeurs littérales de chaîne de caractères.

Outils de tableau

Les Transformers avec des paramètres de style table possèdent des outils additionnels pour remplir et manipuler des valeurs.

Réordonner	Activé une fois que vous avez cliqué sur un élément de ligne. Les choix comprennent : Ajouter une ligne Supprimer une ligne Déplacer la ligne en cours au dessus Déplacer la ligne en cours en dessous Déplacer la ligne en cours en haut de liste Déplacer la ligne en cours en bas de liste
Couper, Copier et Coller	Activé une fois que vous avez cliqué sur un élément de ligne. Les choix comprennent : Couper une ligne - supprime et copie dans le presse-papiers. Copie une ligne dans le presse-papiers. Colle une ligne depuis le presse-papiers. Copier, copier et coller peuvent être utilisés au sein d'un Transformer ou entre Transfromers.
Filtre	Commencez à taper une chaîne de caractères, et la matrice n'affichera que les lignes correspondant à ces caractères. Recherche dans toutes les colonnes. Cela n'affecte que l'affichage des attributs dans le Transformer - cela ne change pas les attributs qui sont sortis.
Importer	Le bouton d'import remplit la table avec un jeu de nouveaux attributs lus depuis un jeu de données. L'application spécifique varie selon les Transformers.
Réinitialiser/Rafraîchir	Réinitialise la table à son état initial, et peut fournir des options additionnelles pour supprimer des entrées invalides. Le comportement varie d'un Transformer à l'autre.

Note : Tous les outils ne sont pas disponibles dans tous les Transformers.