319c8f87ef
most likely.) Don't depend on exceptions for parsing XML, then: instead, use an if/else. 3x speed up of WMC parsing in FF. r=ahocevar (Closes #1642) git-svn-id: http://svn.openlayers.org/trunk/openlayers@7870 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
390 lines
13 KiB
JavaScript
390 lines
13 KiB
JavaScript
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
|
|
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
|
|
* full text of the license. */
|
|
|
|
/**
|
|
* @requires OpenLayers/Format.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.Format.XML
|
|
* Read and write XML. For cross-browser XML generation, use methods on an
|
|
* instance of the XML format class instead of on <code>document<end>.
|
|
* The DOM creation and traversing methods exposed here all mimic the
|
|
* W3C XML DOM methods. Create a new parser with the
|
|
* <OpenLayers.Format.XML> constructor.
|
|
*
|
|
* Inherits from:
|
|
* - <OpenLayers.Format>
|
|
*/
|
|
OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, {
|
|
|
|
/**
|
|
* Property: xmldom
|
|
* {XMLDom} If this browser uses ActiveX, this will be set to a XMLDOM
|
|
* object. It is not intended to be a browser sniffing property.
|
|
* Instead, the xmldom property is used instead of <code>document<end>
|
|
* where namespaced node creation methods are not supported. In all
|
|
* other browsers, this remains null.
|
|
*/
|
|
xmldom: null,
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Format.XML
|
|
* Construct an XML parser. The parser is used to read and write XML.
|
|
* Reading XML from a string returns a DOM element. Writing XML from
|
|
* a DOM element returns a string.
|
|
*
|
|
* Parameters:
|
|
* options - {Object} Optional object whose properties will be set on
|
|
* the object.
|
|
*/
|
|
initialize: function(options) {
|
|
if(window.ActiveXObject) {
|
|
this.xmldom = new ActiveXObject("Microsoft.XMLDOM");
|
|
}
|
|
OpenLayers.Format.prototype.initialize.apply(this, [options]);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: read
|
|
* Deserialize a XML string and return a DOM node.
|
|
*
|
|
* Parameters:
|
|
* text - {String} A XML string
|
|
|
|
* Returns:
|
|
* {DOMElement} A DOM node
|
|
*/
|
|
read: function(text) {
|
|
var index = text.indexOf('<');
|
|
if(index > 0) {
|
|
text = text.substring(index);
|
|
}
|
|
var node = OpenLayers.Util.Try(
|
|
OpenLayers.Function.bind((
|
|
function() {
|
|
var xmldom;
|
|
/**
|
|
* Since we want to be able to call this method on the prototype
|
|
* itself, this.xmldom may not exist even if in IE.
|
|
*/
|
|
if(window.ActiveXObject && !this.xmldom) {
|
|
xmldom = new ActiveXObject("Microsoft.XMLDOM");
|
|
} else {
|
|
xmldom = this.xmldom;
|
|
|
|
}
|
|
xmldom.loadXML(text);
|
|
return xmldom;
|
|
}
|
|
), this),
|
|
function() {
|
|
return new DOMParser().parseFromString(text, 'text/xml');
|
|
},
|
|
function() {
|
|
var req = new XMLHttpRequest();
|
|
req.open("GET", "data:" + "text/xml" +
|
|
";charset=utf-8," + encodeURIComponent(text), false);
|
|
if(req.overrideMimeType) {
|
|
req.overrideMimeType("text/xml");
|
|
}
|
|
req.send(null);
|
|
return req.responseXML;
|
|
}
|
|
);
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: write
|
|
* Serialize a DOM node into a XML string.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement} A DOM node.
|
|
*
|
|
* Returns:
|
|
* {String} The XML string representation of the input node.
|
|
*/
|
|
write: function(node) {
|
|
var data;
|
|
if(this.xmldom) {
|
|
data = node.xml;
|
|
} else {
|
|
var serializer = new XMLSerializer();
|
|
if (node.nodeType == 1) {
|
|
// Add nodes to a document before serializing. Everything else
|
|
// is serialized as is. This may need more work. See #1218 .
|
|
var doc = document.implementation.createDocument("", "", null);
|
|
if (doc.importNode) {
|
|
node = doc.importNode(node, true);
|
|
}
|
|
doc.appendChild(node);
|
|
data = serializer.serializeToString(doc);
|
|
} else {
|
|
data = serializer.serializeToString(node);
|
|
}
|
|
}
|
|
return data;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: createElementNS
|
|
* Create a new element with namespace. This node can be appended to
|
|
* another node with the standard node.appendChild method. For
|
|
* cross-browser support, this method must be used instead of
|
|
* document.createElementNS.
|
|
*
|
|
* Parameters:
|
|
* uri - {String} Namespace URI for the element.
|
|
* name - {String} The qualified name of the element (prefix:localname).
|
|
*
|
|
* Returns:
|
|
* {Element} A DOM element with namespace.
|
|
*/
|
|
createElementNS: function(uri, name) {
|
|
var element;
|
|
if(this.xmldom) {
|
|
if(typeof uri == "string") {
|
|
element = this.xmldom.createNode(1, name, uri);
|
|
} else {
|
|
element = this.xmldom.createNode(1, name, "");
|
|
}
|
|
} else {
|
|
element = document.createElementNS(uri, name);
|
|
}
|
|
return element;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: createTextNode
|
|
* Create a text node. This node can be appended to another node with
|
|
* the standard node.appendChild method. For cross-browser support,
|
|
* this method must be used instead of document.createTextNode.
|
|
*
|
|
* Parameters:
|
|
* text - {String} The text of the node.
|
|
*
|
|
* Returns:
|
|
* {DOMElement} A DOM text node.
|
|
*/
|
|
createTextNode: function(text) {
|
|
var node;
|
|
if(this.xmldom) {
|
|
node = this.xmldom.createTextNode(text);
|
|
} else {
|
|
node = document.createTextNode(text);
|
|
}
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getElementsByTagNameNS
|
|
* Get a list of elements on a node given the namespace URI and local name.
|
|
* To return all nodes in a given namespace, use '*' for the name
|
|
* argument. To return all nodes of a given (local) name, regardless
|
|
* of namespace, use '*' for the uri argument.
|
|
*
|
|
* Parameters:
|
|
* node - {Element} Node on which to search for other nodes.
|
|
* uri - {String} Namespace URI.
|
|
* name - {String} Local name of the tag (without the prefix).
|
|
*
|
|
* Returns:
|
|
* {NodeList} A node list or array of elements.
|
|
*/
|
|
getElementsByTagNameNS: function(node, uri, name) {
|
|
var elements = [];
|
|
if(node.getElementsByTagNameNS) {
|
|
elements = node.getElementsByTagNameNS(uri, name);
|
|
} else {
|
|
// brute force method
|
|
var allNodes = node.getElementsByTagName("*");
|
|
var potentialNode, fullName;
|
|
for(var i=0, len=allNodes.length; i<len; ++i) {
|
|
potentialNode = allNodes[i];
|
|
fullName = (potentialNode.prefix) ?
|
|
(potentialNode.prefix + ":" + name) : name;
|
|
if((name == "*") || (fullName == potentialNode.nodeName)) {
|
|
if((uri == "*") || (uri == potentialNode.namespaceURI)) {
|
|
elements.push(potentialNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return elements;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getAttributeNodeNS
|
|
* Get an attribute node given the namespace URI and local name.
|
|
*
|
|
* Parameters:
|
|
* node - {Element} Node on which to search for attribute nodes.
|
|
* uri - {String} Namespace URI.
|
|
* name - {String} Local name of the attribute (without the prefix).
|
|
*
|
|
* Returns:
|
|
* {DOMElement} An attribute node or null if none found.
|
|
*/
|
|
getAttributeNodeNS: function(node, uri, name) {
|
|
var attributeNode = null;
|
|
if(node.getAttributeNodeNS) {
|
|
attributeNode = node.getAttributeNodeNS(uri, name);
|
|
} else {
|
|
var attributes = node.attributes;
|
|
var potentialNode, fullName;
|
|
for(var i=0, len=attributes.length; i<len; ++i) {
|
|
potentialNode = attributes[i];
|
|
if(potentialNode.namespaceURI == uri) {
|
|
fullName = (potentialNode.prefix) ?
|
|
(potentialNode.prefix + ":" + name) : name;
|
|
if(fullName == potentialNode.nodeName) {
|
|
attributeNode = potentialNode;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return attributeNode;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getAttributeNS
|
|
* Get an attribute value given the namespace URI and local name.
|
|
*
|
|
* Parameters:
|
|
* node - {Element} Node on which to search for an attribute.
|
|
* uri - {String} Namespace URI.
|
|
* name - {String} Local name of the attribute (without the prefix).
|
|
*
|
|
* Returns:
|
|
* {String} An attribute value or and empty string if none found.
|
|
*/
|
|
getAttributeNS: function(node, uri, name) {
|
|
var attributeValue = "";
|
|
if(node.getAttributeNS) {
|
|
attributeValue = node.getAttributeNS(uri, name) || "";
|
|
} else {
|
|
var attributeNode = this.getAttributeNodeNS(node, uri, name);
|
|
if(attributeNode) {
|
|
attributeValue = attributeNode.nodeValue;
|
|
}
|
|
}
|
|
return attributeValue;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getChildValue
|
|
* Get the value of the first child node if it exists, or return an
|
|
* optional default string. Returns an empty string if no first child
|
|
* exists and no default value is supplied.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement} The element used to look for a first child value.
|
|
* def - {String} Optional string to return in the event that no
|
|
* first child value exists.
|
|
*
|
|
* Returns:
|
|
* {String} The value of the first child of the given node.
|
|
*/
|
|
getChildValue: function(node, def) {
|
|
var value;
|
|
if (node && node.firstChild && node.firstChild.nodeValue) {
|
|
value = node.firstChild.nodeValue;
|
|
} else {
|
|
value = (def != undefined) ? def : "";
|
|
}
|
|
return value;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: concatChildValues
|
|
* Concatenate the value of all child nodes if any exist, or return an
|
|
* optional default string. Returns an empty string if no children
|
|
* exist and no default value is supplied. Not optimized for large
|
|
* numbers of child nodes.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement} The element used to look for child values.
|
|
* def - {String} Optional string to return in the event that no
|
|
* child exist.
|
|
*
|
|
* Returns:
|
|
* {String} The concatenated value of all child nodes of the given node.
|
|
*/
|
|
concatChildValues: function(node, def) {
|
|
var value = "";
|
|
var child = node.firstChild;
|
|
var childValue;
|
|
while(child) {
|
|
childValue = child.nodeValue;
|
|
if(childValue) {
|
|
value += childValue;
|
|
}
|
|
child = child.nextSibling;
|
|
}
|
|
if(value == "" && def != undefined) {
|
|
value = def;
|
|
}
|
|
return value;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: hasAttributeNS
|
|
* Determine whether a node has a particular attribute matching the given
|
|
* name and namespace.
|
|
*
|
|
* Parameters:
|
|
* node - {Element} Node on which to search for an attribute.
|
|
* uri - {String} Namespace URI.
|
|
* name - {String} Local name of the attribute (without the prefix).
|
|
*
|
|
* Returns:
|
|
* {Boolean} The node has an attribute matching the name and namespace.
|
|
*/
|
|
hasAttributeNS: function(node, uri, name) {
|
|
var found = false;
|
|
if(node.hasAttributeNS) {
|
|
found = node.hasAttributeNS(uri, name);
|
|
} else {
|
|
found = !!this.getAttributeNodeNS(node, uri, name);
|
|
}
|
|
return found;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: setAttributeNS
|
|
* Adds a new attribute or changes the value of an attribute with the given
|
|
* namespace and name.
|
|
*
|
|
* Parameters:
|
|
* node - {Element} Element node on which to set the attribute.
|
|
* uri - {String} Namespace URI for the attribute.
|
|
* name - {String} Qualified name (prefix:localname) for the attribute.
|
|
* value - {String} Attribute value.
|
|
*/
|
|
setAttributeNS: function(node, uri, name, value) {
|
|
if(node.setAttributeNS) {
|
|
node.setAttributeNS(uri, name, value);
|
|
} else {
|
|
if(this.xmldom) {
|
|
if(uri) {
|
|
var attribute = node.ownerDocument.createNode(
|
|
2, name, uri
|
|
);
|
|
attribute.nodeValue = value;
|
|
node.setAttributeNode(attribute);
|
|
} else {
|
|
node.setAttribute(name, value);
|
|
}
|
|
} else {
|
|
throw "setAttributeNS not implemented";
|
|
}
|
|
}
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Format.XML"
|
|
|
|
});
|