covutils/lib/collection/create.js

Utilities for creating, transforming, and handling Coverage Data objects.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CollectionQuery = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

exports.addCollectionQueryFunction = addCollectionQueryFunction;

var _constants = require('../constants.js');

var _referencing = require('../domain/referencing.js');

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Adds a basic query() function to the coverage collection object.
 * Note that this does not support paging.
 */
function addCollectionQueryFunction(collection) {
  if (collection.paging) {
    throw new Error('Paged collections not supported');
  }
  collection.query = function () {
    return new CollectionQuery(collection);
  };
}

var CollectionQuery = exports.CollectionQuery = function () {
  /**
   * @param {CoverageCollection} collection
   */

  function CollectionQuery(collection) {
    _classCallCheck(this, CollectionQuery);

    this._collection = collection;
    this._filter = {};
    this._subset = {};
  }

  /**
   * Matching mode: intersect
   *
   * Supports ISO8601 date string axes.
   * All other string-type axes are compared alphabetically.
   *
   * @example
   * collection.query().filter({
   *   't': {start: '2015-01-01T01:00:00', stop: '2015-01-01T02:00:00'}
   * }).execute().then(filteredCollection => {
   *   console.log(filteredCollection.coverages.length)
   * })
   * @param {Object} spec
   * @return {CollectionQuery}
   */


  _createClass(CollectionQuery, [{
    key: 'filter',
    value: function filter(spec) {
      mergeInto(spec, this._filter);
      return this;
    }

    /**
     * Subset coverages by domain values.
     *
     * Equivalent to calling {@link Coverage.subsetByValue}(spec) on each
     * coverage in the collection.
     *
     * @param {Object} spec
     * @return {CollectionQuery}
     */

  }, {
    key: 'subset',
    value: function subset(spec) {
      mergeInto(spec, this._subset);
      return this;
    }

    /**
     * Applies the query operators and returns
     * a Promise that succeeds with a new CoverageCollection.
     *
     * @return {Promise<CoverageCollection>}
     */

  }, {
    key: 'execute',
    value: function execute() {
      var _this = this;

      var coll = this._collection;
      var newcoll = {
        type: _constants.COVERAGECOLLECTION,
        coverages: [],
        parameters: coll.parameters,
        domainType: coll.domainType
      };

      var promises = [];
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        var _loop = function _loop() {
          var cov = _step.value;

          promises.push(cov.loadDomain().then(function (domain) {
            if (!matchesFilter(domain, _this._filter)) {
              return;
            }

            if (Object.keys(_this._subset).length === 0) {
              newcoll.coverages.push(cov);
            } else {
              return cov.subsetByValue(_this._subset).then(function (subsetted) {
                newcoll.coverages.push(subsetted);
              });
            }
          }));
        };

        for (var _iterator = coll.coverages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          _loop();
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      return Promise.all(promises).then(function () {
        newcoll.query = function () {
          return new CollectionQuery(newcoll);
        };
        return newcoll;
      });
    }
  }]);

  return CollectionQuery;
}();

function matchesFilter(domain, filter) {
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = Object.keys(filter)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var axisName = _step2.value;

      var condition = filter[axisName];
      if (!domain.axes.has(axisName)) {
        throw new Error('Axis "' + axisName + '" does not exist');
      }
      var axis = domain.axes.get(axisName);
      var vals = axis.values;

      var min = vals[0];
      var max = vals[vals.length - 1];

      if (typeof min !== 'number' && typeof min !== 'string') {
        throw new Error('Can only filter primitive axis values');
      }
      var start = condition.start;
      var stop = condition.stop;

      // special handling

      if ((0, _referencing.isISODateAxis)(domain, axisName)) {
        var _ref = [(0, _referencing.asTime)(min), (0, _referencing.asTime)(max)];
        min = _ref[0];
        max = _ref[1];
        var _ref2 = [(0, _referencing.asTime)(start), (0, _referencing.asTime)(stop)];
        start = _ref2[0];
        stop = _ref2[1];
      } else if ((0, _referencing.isLongitudeAxis)(domain, axisName)) {
        var lonWrapper = (0, _referencing.getLongitudeWrapper)(domain, axisName);var _ref3 = [lonWrapper(start), lonWrapper(stop)];
        start = _ref3[0];
        stop = _ref3[1];
      }

      if (min > max) {
        var _ref4 = [max, min];
        min = _ref4[0];
        max = _ref4[1];
      }
      if (max < start || stop < min) {
        return false;
      }
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }

  return true;
}

function mergeInto(inputObj, targetObj) {
  var _iteratorNormalCompletion3 = true;
  var _didIteratorError3 = false;
  var _iteratorError3 = undefined;

  try {
    for (var _iterator3 = Object.keys(inputObj)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
      var k = _step3.value;

      targetObj[k] = inputObj[k];
    }
  } catch (err) {
    _didIteratorError3 = true;
    _iteratorError3 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion3 && _iterator3.return) {
        _iterator3.return();
      }
    } finally {
      if (_didIteratorError3) {
        throw _iteratorError3;
      }
    }
  }
}