Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 | 12x 12x 12x 12x 12x 12x 12x 3x 3x 3x 3x 2x 1x 1x 20x 20x 20x 1x 3x 3x 3x 19x 19x 19x 19x 19x 1x 18x 18x 19x 23x 23x 23x 19x 19x 19x 156x 156x 77x 77x 156x 142x 142x 142x 247x 247x 105x 142x 138x 138x 124x 14x 12x 12x 12x 14x 156x 77x 77x 77x 77x 148x 148x 77x | /* global require */
import Logger from "../Utils/LoggerByDefault";
// import __xmldom from "xmldom";
/**
* @classdesc
*
* Classe permettant d'écrire ou de lire du XML, sous forme de document DOM,
* éventuellement selon des clés de lecture (readers) ou d'écriture (writers) spécifiques.
*
* @constructor
* @alias Gp.Formats.XML
*
* @param {Object} [options] - options du format XML
*
* @param {Object} [options.reader] - Instance d'un Reader de service (AltiResponseReader, GeocodeRequestReader, etc.)
* utile pour interpréter le XML lorsque sa structure est connue.
* Ce reader doit comporter au moins une fonction statique read (root) permettant d'initialiser la lecture.
*
* @param {Object} [options.writers] - writers
*
* @param {String} [options.xmlString] - chaîne de caractère contenant du XML à interpréter.
*
* @private
*/
function XML (options) {
Iif (!(this instanceof XML)) {
throw new TypeError("XML constructor cannot be called as a function.");
}
// FIXME : notion de singleton
this.logger = Logger.getLogger();
this.logger.trace("[Constructeur XML ()]");
/**
* Chaîne de caractères contenant le texte XML
* @type {String}
*/
this.xmlString = null;
/**
* DOM Element correspondant à la structure du XML.
* @type {DOMElement}
*/
this.xmlDoc = null;
/**
* Objet contenant des fonctions de lecture des différentes balises XML.
* @type {Object}
*/
this.reader = null;
// traitement des paramètres d'options s'il y en a
if (options) {
Eif (options.xmlString && typeof options.xmlString === "string") {
this.xmlString = options.xmlString;
// Si une chaine de caractère a été passée en entrée : on la transforme aussi en XML document
this.xmlDoc = __getXMLDOC(options.xmlString);
}
if (options.reader) {
this.setReader(options.reader);
}
}
}
XML.prototype = {
/**
* @lends module:XML
*/
/*
* Constructeur (alias)
*/
constructor : XML,
/**
* Méthode permettant de récupérer la chaîne de caractères associée au format XML
*
* @returns {String} xmlString - la chaîne de caractères correspondant au format XML
*/
getXMLString : function () {
return this.xmlString;
},
/**
* Méthode permettant d'attribuer une chaîne de caractères au format XML (attribut xmlString).
* La méthode va aussi transformer cette chaîne de caractères en document XML,
* afin de remplir l'attribut xmlDoc.
*
* @param {String} xmlString - la chaîne de caractères correspondant au format XML
*/
setXMLString : function (xmlString) {
Eif (xmlString && typeof xmlString === "string") {
this.xmlString = xmlString;
this.xmlDoc = __getXMLDOC(xmlString);
}
},
/**
* Méthode permettant de récupérer les readers associés au format XML, s'ils ont été définis
*
* @return {Object} readers - les readers associés au format XML, s'ils existent,
* sous forme d'une collection de fonctions
*/
getReader : function () {
return this.reader;
},
/**
* Méthode permettant d'attribuer des readers, sous la forme d'un objet de fonctions (node, data),
* lorsqu'ils n'ont pas été définis lors de l'instanciation par exemple (new XML (options)).
*
* @param {Object} reader - Instance d'un Reader de service (AltiResponseReader, GeocodeRequestReader, etc.)
* utile pour interpréter le XML lorsque sa structure est connue.
* Ce reader doit comporter au moins une fonction statique read (root) permettant d'initialiser la lecture.
*/
setReader : function (reader) {
Eif (reader && reader.read && typeof reader.read === "function") {
this.reader = reader;
}
},
/**
* Méthode permettant de récupérer le document XML associé au format, s'il existe.
*
* @return {DOMElement} xmlDoc - le document XML (DOM document node) s'il existe
*/
getXMLDoc : function () {
return this.xmlDoc;
},
/**
* Setter
*/
setXMLDoc : function (doc) {
this.xmlDoc = doc;
},
/**
* Méthode initialisant la lecture du XML, à partir d'un XML Document :
* création d'un objet JavaScript contenant les informations du XML,
* sauf dans le cas où il n'existe pas de XML Document à interpréter (retourne un objet vide).
*
* @return {Object} [parserOutput] - un objet JavaScript contenant les informations du XML :
* - soit toutes les informations si aucun reader n'a été spécifié à la création du format
* - soit les informations spécifiées dans le reader.
*/
parse : function () {
// build xml document from xmlString
Iif (!this.xmlDoc && this.xmlString) {
this.xmlDoc = __getXMLDOC(this.xmlString);
}
Eif (this.xmlDoc) {
var root = __getRootNode(this.xmlDoc);
Eif (root) {
var parserOutput;
// call reader if exists
if (this.reader && this.reader.read) {
parserOutput = this.reader.read(root);
} else {
parserOutput = {};
parserOutput[root.nodeName] = __readDefault(root);
}
return parserOutput;
} else {
return {};
}
}
}
};
/**
* Méthode de la classe (privée) permettant de créer un XML Document à partir d'une chaîne de caractères XML,
* en utilisant DOMParser () lorsque c'est possible.
* For more information, see: https://dvcs.w3.org/hg/innerhtml/raw-file/tip/index.html#the-domparser-interface
*
* @private
* @memberof XML
* @method __getXMLDOC
* @param {String} xmlString - xml string to be converted into DOM element
* @return {DOMElement} - the corresponding XML Document
*/
function __getXMLDOC (xmlString) {
Eif (typeof window === "undefined") {
// env. nodejs
var DOMParser = require("@xmldom/xmldom").DOMParser; // __xmldom.DOMParser;
return new DOMParser().parseFromString(xmlString, "text/xml");
} else {
// env. browser
var parser;
var xmlDoc;
var errorMsg = "Erreur lors du parsing de la réponse du service : XML non conforme";
if (window.ActiveXObject) {
// Internet Explorer < 9
xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async = false;
xmlDoc.loadXML(xmlString);
var parseError = xmlDoc.parseError;
if (parseError.errorCode) {
if (parseError.line && parseError.linepos) {
errorMsg += "( ligne " + parseError.line + ", colonne " + parseError.linepos;
}
if (parseError.reason) {
errorMsg += ": " + parseError.reason + ")";
}
throw new Error(errorMsg);
}
return xmlDoc;
} else if (window.DOMParser) {
// les autres (Chrome, Mozilla, IE >= 9)
parser = new window.DOMParser();
try {
xmlDoc = parser.parseFromString(xmlString, "text/xml");
} catch (e) {
// Internet Explorer browser raises exception if xmlString is not valid XML
if (e.message === "SyntaxError") {
throw new Error(errorMsg);
} else {
throw new Error("Erreur lors du parsing de la réponse du service : " + e.message);
}
}
// look for parsing error in case no exception was raised
if (xmlDoc.getElementsByTagName("parsererror").length > 0) {
var parsererror = xmlDoc.getElementsByTagName("parsererror");
for (var i = 0; i < parsererror.length; i++) {
var content = parsererror[i].innerHTML;
// except in case parsererror is just because of huge xml, but parsing is done.
if (content.indexOf("Huge input lookup") === -1) {
errorMsg += "(" + content + ")";
throw new Error(errorMsg);
}
}
} else if (!xmlDoc.documentElement) { // may happen in chrome browser
throw new Error(errorMsg);
}
return xmlDoc;
} else {
// FIXME
throw new Error("Incompatible DOM Parser pour ce navigateur !");
}
}
}
/**
* Méthode de la classe (privée) permettant de récupérer le noeud racine du document,
* à partir d'un document node (nodeType=9), puis lecture de ce noeud (readNode)
*
* @private
* @memberof XML
* @method __getRootNode
* @param {DOMElement} [xmlDoc] - a Document Node
* @return {DOMElement} root - the document root node
*/
function __getRootNode (xmlDoc) {
var root;
Eif (xmlDoc.nodeType === 9) {
// INFO : nodeType 9 represents the entire document (the root-node of the DOM tree)
root = xmlDoc.documentElement;
} else if (xmlDoc.nodeType === 1) {
root = xmlDoc;
}
return root;
}
/**
* Méthode de la classe (privée) permettant de lire automatiquement un noeud XML,
* lorsqu'aucun reader spécifique n'a été spécifié (parser brut)
*
* @private
* @memberof XML
* @method readDefault
* @param {DOMElement} node - a DOM element node
* @example final data object looks like :
* data = {
* attributeName: attributeValue,
* childName: {
* attributeName: attributeValue,
* attributeName: attributeValue,
* childName: {
* "textContent": textContent
* },
* childName: {
* childName: {
* attributeName:attributeValue
* }
* }
* }
* }
*/
function __readDefault (node) {
var data = {};
// if element node has attributes, set their values to data
if (node.attributes.length > 0) {
var dataAttributes = __getAttributes(node);
data["attributes"] = dataAttributes;
}
// if element node has childNodes, read them and set them to data
if (node.hasChildNodes()) {
var childData = {};
var child;
var children = node.childNodes;
for (var i = 0; i < children.length; i++) {
child = children[i];
if (child.nodeType === 3) { // TEXT_NODE
data["textContent"] = child.nodeValue;
} else if (child.nodeType === 1) {
childData = __readDefault(child);
if (!data[child.nodeName]) {
// store childData in an object
data[child.nodeName] = childData;
} else {
// in case several childNodes has the same name : store them in an array.
// if data[nodeName] already exists but is not an array
if (!Array.isArray(data[child.nodeName])) {
var old = data[child.nodeName];
data[child.nodeName] = [];
data[child.nodeName].push(old);
}
data[child.nodeName].push(childData);
}
}
// TODO : manage other node types (4=CDATA, etc)
}
}
return data;
}
/**
* Méthode de la classe (privée) permettant de récupérer les attributs d'un noeud élément
*
* @private
* @memberof XML
* @method __getAttributes
* @param {DOMElement} node - noeud contenant l'attribut recherché
* @return {Object} nodeAttributes - objet contenant les noms et valeurs des différents attributs
*/
function __getAttributes (node) {
Eif (node.attributes.length > 0) {
var nodeAttributes = {};
var attributes = node.attributes;
for (var i = 0; i < attributes.length; i++) {
var attribute = attributes[i];
nodeAttributes[attribute.nodeName] = attribute.nodeValue;
}
return nodeAttributes;
}
}
export default XML;
|