Source: lib/util/config_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.ConfigUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.ObjectUtils');
  14. /** @export */
  15. shaka.util.ConfigUtils = class {
  16.   /**
  17.    * @param {!Object} destination
  18.    * @param {!Object} source
  19.    * @param {!Object} template supplies default values
  20.    * @param {!Object} overrides
  21.    *   Supplies override type checking.  When the current path matches
  22.    *   the key in this object, each sub-value must match the type in this
  23.    *   object. If this contains an Object, it is used as the template.
  24.    * @param {string} path to this part of the config
  25.    * @return {boolean}
  26.    * @export
  27.    */
  28.   static mergeConfigObjects(destination, source, template, overrides, path) {
  29.     goog.asserts.assert(destination, 'Destination config must not be null!');
  31.     /**
  32.      * @type {boolean}
  33.      * If true, don't validate the keys in the next level.
  34.      */
  35.     const ignoreKeys = path in overrides;
  37.     let isValid = true;
  39.     for (const k in source) {
  40.       const subPath = path + '.' + k;
  41.       const subTemplate = ignoreKeys ? overrides[path] : template[k];
  43.       // The order of these checks is important.
  44.       if (!ignoreKeys && !(k in template)) {
  45.         shaka.log.alwaysError('Invalid config, unrecognized key ' + subPath);
  46.         isValid = false;
  47.       } else if (source[k] === undefined) {
  48.         // An explicit 'undefined' value causes the key to be deleted from the
  49.         // destination config and replaced with a default from the template if
  50.         // possible.
  51.         if (subTemplate === undefined || ignoreKeys) {
  52.           // There is nothing in the template, so delete.
  53.           delete destination[k];
  54.         } else {
  55.           // There is something in the template, so go back to that.
  56.           destination[k] = shaka.util.ObjectUtils.cloneObject(subTemplate);
  57.         }
  58.       } else if (subTemplate.constructor == Object &&
  59.                  source[k] &&
  60.                  source[k].constructor == Object) {
  61.         // These are plain Objects with no other constructor.
  63.         if (!destination[k]) {
  64.           // Initialize the destination with the template so that normal
  65.           // merging and type-checking can happen.
  66.           destination[k] = shaka.util.ObjectUtils.cloneObject(subTemplate);
  67.         }
  69.         const subMergeValid = shaka.util.ConfigUtils.mergeConfigObjects(
  70.             destination[k], source[k], subTemplate, overrides, subPath);
  71.         isValid = isValid && subMergeValid;
  72.       } else if (typeof source[k] != typeof subTemplate ||
  73.                  source[k] == null ||
  74.                  // Function cosntructors are not informative, and differ
  75.                  // between sync and async functions.  So don't look at
  76.                  // constructor for function types.
  77.                  (typeof source[k] != 'function' &&
  78.                   source[k].constructor != subTemplate.constructor)) {
  79.         // The source is the wrong type.  This check allows objects to be
  80.         // nulled, but does not allow null for any non-object fields.
  81.         shaka.log.alwaysError('Invalid config, wrong type for ' + subPath);
  82.         isValid = false;
  83.       } else if (typeof template[k] == 'function' &&
  84.                  template[k].length != source[k].length) {
  85.         shaka.log.alwaysWarn(
  86.             'Unexpected number of arguments for ' + subPath);
  87.         destination[k] = source[k];
  88.       } else {
  89.         destination[k] = source[k];
  90.       }
  91.     }
  93.     return isValid;
  94.   }
  97.   /**
  98.    * Convert config from ('fieldName', value) format to a partial config object.
  99.    *
  100.    * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
  101.    * { manifest: { retryParameters: { maxAttempts: 1 }}}.
  102.    *
  103.    * @param {string} fieldName
  104.    * @param {*} value
  105.    * @return {!Object}
  106.    * @export
  107.    */
  108.   static convertToConfigObject(fieldName, value) {
  109.     const configObject = {};
  110.     let last = configObject;
  111.     let searchIndex = 0;
  112.     let nameStart = 0;
  113.     while (true) {  // eslint-disable-line no-constant-condition
  114.       const idx = fieldName.indexOf('.', searchIndex);
  115.       if (idx < 0) {
  116.         break;
  117.       }
  118.       if (idx == 0 || fieldName[idx - 1] != '\\') {
  119.         const part = fieldName.substring(nameStart, idx).replace(/\\\./g, '.');
  120.         last[part] = {};
  121.         last = last[part];
  122.         nameStart = idx + 1;
  123.       }
  124.       searchIndex = idx + 1;
  125.     }
  127.     last[fieldName.substring(nameStart).replace(/\\\./g, '.')] = value;
  128.     return configObject;
  129.   }
  131.   /**
  132.    * Reference the input parameters so the compiler doesn't remove them from
  133.    * the calling function.  Return whatever value is specified.
  134.    *
  135.    * This allows an empty or default implementation of a config callback that
  136.    * still bears the complete function signature even in compiled mode.
  137.    *
  138.    * The caller should look something like this:
  139.    *
  140.    *   const callback = (a, b, c, d) => {
  141.    *     return referenceParametersAndReturn(
  142.              [a, b, c, d],
  143.              a);  // Can be anything, doesn't need to be one of the parameters
  144.    *   };
  145.    *
  146.    * @param {!Array.<?>} parameters
  147.    * @param {T} returnValue
  148.    * @return {T}
  149.    * @template T
  150.    * @noinline
  151.    */
  152.   static referenceParametersAndReturn(parameters, returnValue) {
  153.     return parameters && returnValue;
  154.   }
  155. };