parse GET scoope, all operations with incoming request must be done here
160281
public function parse_request(){
		parent::parse_request();
		
		if (isset($_GET[$this->parent_name]))
			$this->request->set_relation($_GET[$this->parent_name]);
		else
			$this->request->set_relation($this->rootId);
			
		$this->request->set_limit(0,0); //netralize default reaction on dyn. loading mode
	}
475845
function goGet(api, key, requestor, params) {
  /*jshint validthis: true */

  var query  = {};
  var opt;

  // extract query options
  for (opt in this.options) {
    query[opt] = this.options[opt];
  }

  // unexpected params are ignored,
  // so we don't need to filter the query options from the params object
  var opts   = api.request(key, params, query);
  var duplex = requestor.newDuplex(opts);

  return duplex;
}
934445
function parseAll(options) {
  return Promise.all([
    parseData(options),
    parsePages(options),
    parsePatterns(options),
    parseTemplates(options)
  ]).then(
    allData => parseTree(allData, options),
    error => DrizzleError.error(error, options.debug)
  );
}
812172
def all
      response_body = fetch_response(resource.path, query_parameters).body
      Parsers::CollectionParser.new(resource: resource, response: response_body).parse
    end
994354
function Request (method, url) {
      var self = this
      Emitter.call(this)
      this._query = this._query || []
      this.method = method
      this.url = url
      this.header = {}
      this._header = {}
      this.on('end', function (){
        var err = null
        var res = null

        try {
          res = new Response(self)
        } catch(e) {
          err = new Error('Parser is unable to parse the response')
          err.parse = true
          err.original = e
        }

        self.callback(err, res)
      })
    }
129147
def fetch_and_parse(method, uri, params_prefix=None, **params):
    """"""
    response = fetch(method, uri, params_prefix, **params)
    return _parse(json.loads(response.text))
286046
function handleQuery() {
  let query = parseQuery();
  let url = window.location.protocol + '//' + window.location.hostname + ':' +
            window.location.port + ELASTICSEARCH_INTERFACE_ROUTE;
  let httpRequest = new XMLHttpRequest();

  httpRequest.onreadystatechange = function() {
    if(httpRequest.readyState === XMLHttpRequest.DONE) {
      if(httpRequest.status === 200) {
        let response = JSON.parse(httpRequest.responseText);
        updateResults(response);
        updateHits(response);
        updateAggregations(response);
        show(queryResults);
      }
      else {
        queryError.textContent = 'Query returned status ' +
                                 httpRequest.status +
                                 '. Is Elasticsearch connected and running?';
        hide(queryResults);
        hide(queryButton);
        show(queryError);
      }
    }
  };
  httpRequest.open('POST', url);
  httpRequest.setRequestHeader('Content-Type', 'application/json');
  httpRequest.setRequestHeader('Accept', 'application/json');
  httpRequest.send(JSON.stringify(query));
}
256443
def get(url, parameters = {}, skip_status_check = false)
      response = connection.get("#{api_endpoint}#{url}", parameters)
      on_complete(response) unless skip_status_check
      response
    end
1216062
async def parse(self, request):
        
        if request.content_type in {'application/x-www-form-urlencoded', 'multipart/form-data'}:
            return await request.post()

        if request.content_type == 'application/json':
            return await request.json()

        return await request.text()
220318
def _fetch(self, request):
        
        client = self.client

        #: Dispatch the async call
        call = Call(__id__=client.newCall(request.request))
        call.enqueue(request.handler)

        #: Save the call reference
        request.call = call
62243
private void parseRequest(HttpMethod httpMethod, HttpRequestBase request, JsonObject payload) throws MPException {
        this.method = httpMethod.toString();
        this.url = request.getURI().toString();
        if (payload != null) {
            this.payload = payload.toString();
        }
    }
451094
function parse_request(){
		parent::parse_request();

		if (isset($_GET["posStart"]) && isset($_GET["count"]))
			$this->request->set_limit($_GET["posStart"],$_GET["count"]);
	}
952082
def get(self, request, bot_id, format=None):
        
        return super(HandlerList, self).get(request, bot_id, format)
157881
function RequestHooks_process(api) {
        var that = this, route = api.parsedUrl.pathname;
        logger.info('RequestHooks.process:', route);
        return new Promise(function (resolve, reject) {
            var hook;
            try {
                hook = that.get(route);
                logger.info('RequestHooks.hook:', hook);
                if (!!hook) {
                    resolve(hook.func(api));
                } else {
                    resolve(false);
                }
            } catch (e) {
                logger.error('RequestHooks.hook:', {
                    hook: hook,
                    e: e
                });
                reject(new error.HttpError(500, {hook: route}, 'Hook error', e));
            }
        });
    }
1280655
function Router_parseRequest(method, parsedUrl, headers) {
        var all = [];

        this.routes.forEach(function (routeRule) {
            all.push(
                new Promise(function (resolve, reject) {
                    try {
                        resolve(routeRule.parseRequest(method, parsedUrl, headers));
                    } catch (e) {
                        reject(e);
                    }
                })
            );
        });
        return Promise.all(all).then(function (data) {
            var route;
            while (data.length) {
                route = data.shift();
                if (Type.isArray(route) && route.length === 2) {
                    return route;
                }
            }
            return [];
        });
    }
314434
def do_GET(self):
    """"""
    if not self._client_allowed():
      return

    try:
      (_, _, path, query, _) = urlsplit(self.path)
      params = parse_qs(query)
      # Give each handler a chance to respond.
      for prefix, handler in self._GET_handlers:
        if self._maybe_handle(prefix, handler, path, params):
          return
      # If no path specified, default to showing the list of all runs.
      if path == '/':
        self._handle_runs('', {})
        return

      content = 'Invalid GET request {}'.format(self.path).encode('utf-8'),
      self._send_content(content, 'text/html', code=400)
    except (IOError, ValueError):
      pass
793302
def parse(cls, requester, entries):
        """"""
        result_entries = SearchableList()
        for entry in entries:
            result_entries.append(cls.instance.parse(requester, entry))
        return result_entries