Source: RequestGet.js

  1. const Request = require('./Request')
  2. const defines = require('./defines')
  3. const BoundingBox = require('boundingbox')
  4. const overpassOutOptions = require('./overpassOutOptions')
  5. const RequestGetMembers = require('./RequestGetMembers')
  6. const isGeoJSON = require('./isGeoJSON')
  8. /**
  9.  * A get request (request list of map features by id)
  10.  * @extends Request
  11.  */
  12. class RequestGet extends Request {
  13.   /**
  14.    * @param {OverpassFrontend} overpass
  15.    * @param {data} data
  16.    */
  17.   constructor (overpass, data) {
  18.     super(overpass, data)
  19.     this.type = 'get'
  21.     if (typeof this.ids === 'string') {
  22.       this.ids = [this.ids]
  23.     } else {
  24.       this.ids = this.ids.concat()
  25.     }
  27.     if (typeof this.options.properties === 'undefined') {
  28.       this.options.properties = defines.DEFAULT
  29.     }
  31.     for (let i = 0; i < this.ids.length; i++) {
  32.       if (this.ids[i] in this.overpass.cacheElements && this.overpass.cacheElements[this.ids[i]] === false) {
  33.         delete this.overpass.cacheElements[this.ids[i]]
  34.       }
  35.     }
  37.     if (this.options.bounds) {
  38.       if (isGeoJSON(this.options.bounds)) {
  39.         this.geojsonBounds = this.options.bounds
  40.       }
  42.       this.options.bounds = new BoundingBox(this.options.bounds)
  43.     } else if (this.options.bbox) {
  44.       this.options.bounds = new BoundingBox(this.options.bbox)
  45.       delete this.options.bbox
  46.       console.error('OverpassFrontend.get(): option "bbox" is deprecated, use "bounds" instead')
  47.     }
  48.     // option 'split' not available for get requests -> use effort instead
  49.     delete this.options.split
  51.     this.done = {}
  53.     if ('members' in this.options) {
  54.       RequestGetMembers(this)
  55.     }
  56.   }
  58.   _effortForId (id) {
  59.     if (!id) {
  60.       return null
  61.     }
  63.     const type = id.substr(0, 1)
  64.     switch (type) {
  65.       case 'n':
  66.         return this.overpass.options.effortNode
  67.       case 'w':
  68.         return this.overpass.options.effortWay
  69.       case 'r':
  70.         return this.overpass.options.effortRelation
  71.     }
  72.   }
  74.   /**
  75.    * how much effort can a call to this request use
  76.    * @return {Request#minMaxEffortResult} - minimum and maximum effort
  77.    */
  78.   minMaxEffort () {
  79.     const todo = this.ids.filter(x => x)
  81.     if (todo.length === 0) {
  82.       return { minEffort: 0, maxEffort: 0 }
  83.     }
  85.     const minEffort = Math.min.apply(this, todo.map(id => this._effortForId(id)))
  86.     const maxEffort = todo.map(id => this._effortForId(id)).reduce((a, b) => a + b)
  88.     return { minEffort, maxEffort }
  89.   }
  91.   /**
  92.    * check if there are any map features which can be returned right now
  93.    */
  94.   preprocess () {
  95.     this.allFound = true
  97.     for (let i = 0; i < this.ids.length; i++) {
  98.       const id = this.ids[i]
  100.       if (id === null) {
  101.         continue
  102.       }
  104.       if (id in this.overpass.cacheElements) {
  105.         const ob = this.overpass.cacheElements[id]
  106.         let ready = true
  108.         // Feature does not exists!
  109.         if (ob.missingObject) {
  110.           this.featureCallback(null, null, i)
  111.           this.ids[i] = null
  112.           continue
  113.         }
  115.         // for bounds option, if object is (partly) loaded, but outside call
  116.         // featureCallback with 'false'
  117.         if (this.options.bounds) {
  118.           const intersects = this.geojsonBounds ? ob.intersects(this.geojsonBounds) : ob.intersects(this.options.bounds)
  119.           if (intersects === 0 || (!ob.bounds && ob.properties | defines.BBOX)) {
  120.             this.featureCallback(null, false, i)
  121.             this.ids[i] = null
  122.             continue
  123.           }
  124.         }
  126.         // not fully loaded
  127.         if ((ob !== false && ob !== null) && (this.options.properties & ob.properties) !== this.options.properties) {
  128.           ready = false
  129.         }
  131.         // if sort is set in options maybe defer calling featureCallback
  132.         if (ready) {
  133.           this.receiveObject(ob)
  134.           this.featureCallback(null, ob, i)
  135.           this.ids[i] = null
  136.           continue
  137.         }
  138.       } else {
  139.         // Illegal ID
  140.         if (id !== null && !id.match(/^[nwr][0-9]+$/)) {
  141.           this.featureCallback(null, null, i)
  142.           this.ids[i] = null
  143.           continue
  144.         }
  145.       }
  147.       this.allFound = false
  148.     }
  149.   }
  151.   /**
  152.    * compile the query
  153.    * @param {OverpassFrontend#Context} context - Current context
  154.    * @return {Request#SubRequest} - the compiled query
  155.    */
  156.   _compileQuery (context) {
  157.     let query = ''
  158.     let nodeQuery = ''
  159.     let wayQuery = ''
  160.     let relationQuery = ''
  161.     let BBoxQuery = ''
  162.     let effort = 0
  163.     let outOptions
  165.     if (this.options.bounds) {
  166.       BBoxQuery = '(' + this.options.bounds.toLatLonString() + ')'
  167.     }
  169.     for (let i = 0; i < this.ids.length; i++) {
  170.       const id = this.ids[i]
  171.       outOptions = overpassOutOptions(this.options)
  173.       if (effort > context.maxEffort) {
  174.         break
  175.       }
  177.       if (id === null) {
  178.         continue
  179.       }
  181.       // don't load objects multiple times in same context
  182.       if (id in context.todo) {
  183.         continue
  184.       }
  186.       if (this.options.bounds) {
  187.         // check if we already know the bounds of the element; if yes, don't try
  188.         // to load object if it does not intersect bounds
  189.         if (id in this.overpass.cacheElements && (this.overpass.cacheElements[id].properties & defines.BBOX)) {
  190.           if (!this.overpass.cacheElements[id].intersects(this.options.bounds)) {
  191.             continue
  192.           }
  193.         }
  194.       }
  196.       switch (id.substr(0, 1)) {
  197.         case 'n':
  198.           nodeQuery += 'node(' + id.substr(1) + ');\n'
  199.           effort += this.overpass.options.effortNode
  200.           break
  201.         case 'w':
  202.           wayQuery += 'way(' + id.substr(1) + ');\n'
  203.           effort += this.overpass.options.effortWay
  204.           break
  205.         case 'r':
  206.           relationQuery += 'relation(' + id.substr(1) + ');\n'
  207.           effort += this.overpass.options.effortRelation
  208.           break
  209.       }
  211.       context.todo[id] = true
  212.     }
  214.     if (nodeQuery !== '') {
  215.       query += '((' + nodeQuery + ');)->.n;\n'
  216.       if (BBoxQuery) {
  217.         query += '(node.n; - node.n' + BBoxQuery + '->.n;);\nout ids bb qt;\n'
  218.       }
  219.     }
  221.     if (wayQuery !== '') {
  222.       query += '((' + wayQuery + ');)->.w;\n'
  223.       if (BBoxQuery) {
  224.         query += '(way.w; - way.w' + BBoxQuery + '->.w;);\nout ids bb qt;\n'
  225.       }
  226.     }
  228.     if (relationQuery !== '') {
  229.       query += '((' + relationQuery + ');)->.r;\n'
  230.       if (BBoxQuery) {
  231.         query += '(relation.r; - relation.r' + BBoxQuery + '->.r;);\nout ids bb qt;\n'
  232.       }
  233.     }
  235.     const requestParts = []
  236.     if (BBoxQuery && (nodeQuery !== '' || wayQuery !== '' || relationQuery !== '')) {
  237.       // additional separator to separate objects outside bbox from inside bbox
  238.       query += 'out count;\n'
  240.       requestParts.push({
  241.         properties: defines.BBOX,
  242.         bounds: this.options.bounds,
  243.         boundsNoMatch: true
  244.       })
  245.     }
  246.     if (nodeQuery !== '') {
  247.       query += '.n out ' + outOptions + ';\n'
  248.     }
  249.     if (wayQuery !== '') {
  250.       query += '.w out ' + outOptions + ';\n'
  251.     }
  252.     if (relationQuery !== '') {
  253.       query += '.r out ' + outOptions + ';\n'
  254.     }
  256.     if (query) {
  257.       requestParts.push({
  258.         properties: this.options.properties,
  259.         receiveObject: this.receiveObject.bind(this),
  260.         checkFeatureCallback: this.checkFeatureCallback.bind(this),
  261.         featureCallback: this._featureCallback.bind(this, this.featureCallback)
  262.       })
  263.     }
  265.     const subRequest = {
  266.       query,
  267.       effort: effort,
  268.       request: this,
  269.       parts: requestParts
  270.     }
  272.     return subRequest
  273.   }
  275.   checkFeatureCallback (ob) {
  276.     if (this.geojsonBounds && ob.intersects(this.geojsonBounds) === 0) {
  277.       return false
  278.     }
  280.     return true
  281.   }
  283.   _featureCallback (fun, err, ob) {
  284.     const indexes = []
  285.     let p
  287.     while ((p = this.ids.indexOf(ob.id)) !== -1) {
  288.       this.ids[p] = null
  289.       indexes.push(p)
  290.     }
  292.     if (this.options.bounds && !ob.intersects(this.options.bounds)) {
  293.       indexes.forEach(p => fun(null, false, p))
  294.       return
  295.     }
  297.     indexes.forEach(p => fun(null, ob, p))
  298.   }
  300.   needLoad () {
  301.     this.preprocess()
  303.     return this.allFound
  304.   }
  306.   mayFinish () {
  307.     return this.allFound
  308.   }
  309. }
  311. module.exports = RequestGet