Source: lib/util/xml_utils.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.XmlUtils');
  20. goog.require('shaka.log');
  23. /**
  24.  * @namespace shaka.util.XmlUtils
  25.  * @summary A set of XML utility functions.
  26.  */
  29. /**
  30.  * Finds a child XML element.
  31.  * @param {!Node} elem The parent XML element.
  32.  * @param {string} name The child XML element's tag name.
  33.  * @return {Element} The child XML element, or null if a child XML element does
  34.  *   not exist with the given tag name OR if there exists more than one
  35.  *   child XML element with the given tag name.
  36.  */
  37. shaka.util.XmlUtils.findChild = function(elem, name) {
  38.   let children = shaka.util.XmlUtils.findChildren(elem, name);
  39.   if (children.length != 1) {
  40.     return null;
  41.   }
  42.   return children[0];
  43. };
  46. /**
  47.  * Finds child XML elements.
  48.  * @param {!Node} elem The parent XML element.
  49.  * @param {string} name The child XML element's tag name.
  50.  * @return {!Array.<!Element>} The child XML elements.
  51.  */
  52. shaka.util.XmlUtils.findChildren = function(elem, name) {
  53.   return Array.prototype.filter.call(elem.childNodes, function(child) {
  54.     return child instanceof Element && child.tagName == name;
  55.   });
  56. };
  59. /**
  60.  * Finds namespace-qualified child XML elements.
  61.  * @param {!Node} elem The parent XML element.
  62.  * @param {string} ns The child XML element's namespace URI.
  63.  * @param {string} name The child XML element's local name.
  64.  * @return {!Array.<!Element>} The child XML elements.
  65.  */
  66. shaka.util.XmlUtils.findChildrenNS = function(elem, ns, name) {
  67.   return Array.prototype.filter.call(elem.childNodes, function(child) {
  68.     return child instanceof Element && child.localName == name &&
  69.         child.namespaceURI == ns;
  70.   });
  71. };
  74. /**
  75.  * Gets a namespace-qualified attribute.
  76.  * @param {!Element} elem The element to get from.
  77.  * @param {string} ns The namespace URI.
  78.  * @param {string} name The local name of the attribute.
  79.  * @return {?string} The attribute's value, or null if not present.
  80.  */
  81. shaka.util.XmlUtils.getAttributeNS = function(elem, ns, name) {
  82.   // Some browsers return the empty string when the attribute is missing,
  83.   // so check if it exists first.  See: https://mzl.la/2L7F0UK
  84.   return elem.hasAttributeNS(ns, name) ? elem.getAttributeNS(ns, name) : null;
  85. };
  88. /**
  89.  * Gets the text contents of a node.
  90.  * @param {!Node} elem The XML element.
  91.  * @return {?string} The text contents, or null if there are none.
  92.  */
  93. shaka.util.XmlUtils.getContents = function(elem) {
  94.   let isText = (child) => {
  95.     return child.nodeType == Node.TEXT_NODE ||
  96.         child.nodeType == Node.CDATA_SECTION_NODE;
  97.   };
  98.   if (!Array.prototype.every.call(elem.childNodes, isText)) {
  99.     return null;
  100.   }
  102.   // Read merged text content from all text nodes.
  103.   return elem.textContent.trim();
  104. };
  107. /**
  108.  * Parses an attribute by its name.
  109.  * @param {!Element} elem The XML element.
  110.  * @param {string} name The attribute name.
  111.  * @param {function(string): (T|null)} parseFunction A function that parses
  112.  *   the attribute.
  113.  * @param {(T|null)=} opt_defaultValue The attribute's default value, if not
  114.  *   specified, the attibute's default value is null.
  115.  * @return {(T|null)} The parsed attribute on success, or the attribute's
  116.  *   default value if the attribute does not exist or could not be parsed.
  117.  * @template T
  118.  */
  119. shaka.util.XmlUtils.parseAttr = function(
  120.     elem, name, parseFunction, opt_defaultValue) {
  121.   let parsedValue = null;
  123.   let value = elem.getAttribute(name);
  124.   if (value != null) {
  125.     parsedValue = parseFunction(value);
  126.   }
  128.   if (parsedValue == null) {
  129.     return opt_defaultValue != undefined ? opt_defaultValue : null;
  130.   }
  132.   return parsedValue;
  133. };
  136. /**
  137.  * Parses an XML date string.
  138.  * @param {string} dateString
  139.  * @return {?number} The parsed date in seconds on success; otherwise, return
  140.  *   null.
  141.  */
  142. shaka.util.XmlUtils.parseDate = function(dateString) {
  143.   if (!dateString) {
  144.     return null;
  145.   }
  147.   // Times in the manifest should be in UTC.  If they don't specify a timezone,
  148.   // Date.parse() will use the local timezone instead of UTC.  So manually add
  149.   // the timezone if missing ('Z' indicates the UTC timezone).
  150.   // Format: YYYY-MM-DDThh:mm:ss.ssssss
  151.   if (/^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/.test(dateString)) {
  152.     dateString += 'Z';
  153.   }
  155.   let result = Date.parse(dateString);
  156.   return (!isNaN(result) ? Math.floor(result / 1000.0) : null);
  157. };
  160. /**
  161.  * Parses an XML duration string.
  162.  * Negative values are not supported. Years and months are treated as exactly
  163.  * 365 and 30 days respectively.
  164.  * @param {string} durationString The duration string, e.g., "PT1H3M43.2S",
  165.  *   which means 1 hour, 3 minutes, and 43.2 seconds.
  166.  * @return {?number} The parsed duration in seconds on success; otherwise,
  167.  *   return null.
  168.  * @see {@link http://www.datypic.com/sc/xsd/t-xsd_duration.html}
  169.  */
  170. shaka.util.XmlUtils.parseDuration = function(durationString) {
  171.   if (!durationString) {
  172.     return null;
  173.   }
  175.   let re = '^P(?:([0-9]*)Y)?(?:([0-9]*)M)?(?:([0-9]*)D)?' +
  176.            '(?:T(?:([0-9]*)H)?(?:([0-9]*)M)?(?:([0-9.]*)S)?)?$';
  177.   let matches = new RegExp(re).exec(durationString);
  179.   if (!matches) {
  180.     shaka.log.warning('Invalid duration string:', durationString);
  181.     return null;
  182.   }
  184.   // Note: Number(null) == 0 but Number(undefined) == NaN.
  185.   let years = Number(matches[1] || null);
  186.   let months = Number(matches[2] || null);
  187.   let days = Number(matches[3] || null);
  188.   let hours = Number(matches[4] || null);
  189.   let minutes = Number(matches[5] || null);
  190.   let seconds = Number(matches[6] || null);
  192.   // Assume a year always has 365 days and a month always has 30 days.
  193.   let d = (60 * 60 * 24 * 365) * years +
  194.           (60 * 60 * 24 * 30) * months +
  195.           (60 * 60 * 24) * days +
  196.           (60 * 60) * hours +
  197.           60 * minutes +
  198.           seconds;
  199.   return isFinite(d) ? d : null;
  200. };
  203. /**
  204.  * Parses a range string.
  205.  * @param {string} rangeString The range string, e.g., "101-9213".
  206.  * @return {?{start: number, end: number}} The parsed range on success;
  207.  *   otherwise, return null.
  208.  */
  209. shaka.util.XmlUtils.parseRange = function(rangeString) {
  210.   let matches = /([0-9]+)-([0-9]+)/.exec(rangeString);
  212.   if (!matches) {
  213.     return null;
  214.   }
  216.   let start = Number(matches[1]);
  217.   if (!isFinite(start)) {
  218.     return null;
  219.   }
  221.   let end = Number(matches[2]);
  222.   if (!isFinite(end)) {
  223.     return null;
  224.   }
  226.   return {start: start, end: end};
  227. };
  230. /**
  231.  * Parses an integer.
  232.  * @param {string} intString The integer string.
  233.  * @return {?number} The parsed integer on success; otherwise, return null.
  234.  */
  235. shaka.util.XmlUtils.parseInt = function(intString) {
  236.   let n = Number(intString);
  237.   return (n % 1 === 0) ? n : null;
  238. };
  241. /**
  242.  * Parses a positive integer.
  243.  * @param {string} intString The integer string.
  244.  * @return {?number} The parsed positive integer on success; otherwise,
  245.  *   return null.
  246.  */
  247. shaka.util.XmlUtils.parsePositiveInt = function(intString) {
  248.   let n = Number(intString);
  249.   return (n % 1 === 0) && (n > 0) ? n : null;
  250. };
  253. /**
  254.  * Parses a non-negative integer.
  255.  * @param {string} intString The integer string.
  256.  * @return {?number} The parsed non-negative integer on success; otherwise,
  257.  *   return null.
  258.  */
  259. shaka.util.XmlUtils.parseNonNegativeInt = function(intString) {
  260.   let n = Number(intString);
  261.   return (n % 1 === 0) && (n >= 0) ? n : null;
  262. };
  265. /**
  266.  * Parses a floating point number.
  267.  * @param {string} floatString The floating point number string.
  268.  * @return {?number} The parsed floating point number on success; otherwise,
  269.  *   return null. May return -Infinity or Infinity.
  270.  */
  271. shaka.util.XmlUtils.parseFloat = function(floatString) {
  272.   let n = Number(floatString);
  273.   return !isNaN(n) ? n : null;
  274. };
  277. /**
  278.  * Evaluate a division expressed as a string.
  279.  * @param {string} exprString
  280.  *   The expression to evaluate, e.g. "200/2". Can also be a single number.
  281.  * @return {?number} The evaluated expression as floating point number on
  282.  *   success; otherwise return null.
  283.  */
  284. shaka.util.XmlUtils.evalDivision = function(exprString) {
  285.   let res;
  286.   let n;
  287.   if ((res = exprString.match(/^(\d+)\/(\d+)$/))) {
  288.     n = Number(res[1] / res[2]);
  289.   } else {
  290.     n = Number(exprString);
  291.   }
  292.   return !isNaN(n) ? n : null;
  293. };