Source: Request.js

  1. const ee = require('event-emitter')
  2. const SortedCallbacks = require('./SortedCallbacks')
  4. /**
  5.  * A compiled query
  6.  * @typedef {Object} Request#SubRequest
  7.  * @property {string} query - The compiled code
  8.  * @property {object[]} parts - An entry for each part (separated by the 'out count' separator)
  9.  * @property {int} parts[].properties - The properties which each returned map feature has set (TAGS, BBOX, ...)
  10.  * @property {int} effort - Supposed "effort" of this query
  11.  * @property {int} count - Count of discovered items
  12.  * @property {Request} request - The request this compiled query belongs to
  13.  */
  15. /**
  16.  * An unspecified request
  17.  * @param {OverpassFrontend} overpass
  18.  * @param {object} options
  19.  */
  20. class Request {
  21.   constructor (overpass, data) {
  22.     this.overpass = overpass
  24.     for (const k in data) {
  25.       this[k] = data[k]
  26.     }
  28.     if (!this.options) {
  29.       this.options = {}
  30.     }
  32.     this.priority = 'priority' in this.options ? this.options.priority : 0
  34.     const callbacks = new SortedCallbacks(this.options, this.featureCallback, this.finalCallback)
  35.     this.featureCallback = callbacks.next.bind(callbacks)
  36.     this.finalCallback = callbacks.final.bind(callbacks)
  38.     this.count = 0
  39.     this.callCount = 0
  40.     this.timestampPreprocess = 0
  41.   }
  43.   /**
  44.    * Request got aborted
  45.    * @event Request#abort
  46.    */
  48.   /**
  49.    * abort this request
  50.    */
  51.   abort () {
  52.     this.aborted = true
  53.     this.emit('abort')
  54.     this.overpass._abortRequest(this)
  55.   }
  57.   /**
  58.    * Request is finished
  59.    * @event Request#finish
  60.    * @param {Error|null} - null if no error occured
  61.    */
  63.   /**
  64.    * request is finished
  65.    * @param {Error|null} err - null if no error occured
  66.    */
  67.   finish (err) {
  68.     if (!this.aborted) {
  69.       this.finalCallback(err)
  70.     }
  72.     this.overpass._finishRequest(this)
  73.     this.finished = true
  74.     this.emit('finish', err)
  75.   }
  77.   /**
  78.    * shall this Request be included in the current call?
  79.    * @param {OverpassFrontend#Context} context - Current context
  80.    * @return {boolean} - yes|no
  81.    */
  82.   willInclude (context) {
  83.     return true
  84.   }
  86.   /**
  87.    * @typedef {Object} Request#minMaxEffortResult
  88.    * @property {number} Remaining minimal effort of this request
  89.    * @property {number|null} Remaining maximum effort (or null if unknown)
  90.    */
  92.   /**
  93.    * how much effort can a call to this request use
  94.    * @return {Request#minMaxEffortResult} - minimum and maximum effort
  95.    */
  96.   minMaxEffort () {
  97.     return { minEffort: 0, maxEffort: 0 }
  98.   }
  100.   /**
  101.    * SubRequest got compiled
  102.    * @event Request#subrequest-compiile
  103.    * @param {Request#SubRequest} subRequest - the sub request
  104.    */
  106.   /**
  107.    * compile the query
  108.    * @param {OverpassFrontend#Context} context - Current context
  109.    * @return {Request#SubRequest} - the compiled query
  110.    */
  111.   compileQuery (context) {
  112.     const subRequest = this._compileQuery(context)
  113.     this.emit('subrequest-compile', subRequest)
  115.     this.callCount++
  117.     return subRequest
  118.   }
  120.   /**
  121.    * receive an object from OverpassFronted -> enter to cache, return to caller
  122.    * @param {OverpassObject} ob - Object which has been received
  123.    * @param {Request#SubRequest} subRequest - sub request which is being handled right now
  124.    * @param {int} partIndex - Which part of the subRequest is being received
  125.    */
  126.   receiveObject (ob) {
  127.     this.count++
  128.   }
  130.   /**
  131.    * SubRequest got finished
  132.    * @event Request#subrequest-finished
  133.    * @param {Request#SubRequest} subRequest - the sub request
  134.    */
  136.   /**
  137.    * the current subrequest is finished -> update caches, check whether request is finished
  138.    * @param {Request#SubRequest} subRequest - the current sub request
  139.    */
  140.   finishSubRequest (subRequest) {
  141.     this.emit('subrequest-finish', subRequest)
  142.   }
  143. }
  145. ee(Request.prototype)
  147. module.exports = Request