parse GET scoope, all operations with incoming request must be done here
519539
protected function parse_request(){
		if (isset($_GET['action'])){
			$action = $_GET['action'];
			//simple request mode
			if ($action == "get"){
				//data request
				if (isset($_GET['id'])){
					//single entity data request
					$this->request->set_filter($this->config->id["name"],$_GET['id'],"=");
				} else {
					//loading collection of items
				}
			} else {
				//data saving
				$this->editing = true;
			}
			parent::check_csrf();
		} else {
			if (isset($_GET['editing']) && isset($_POST['ids']))
				$this->editing = true;			
			parent::parse_request();
		}
	
		if (isset($_GET["start"]) && isset($_GET["count"]))
			$this->request->set_limit($_GET["start"],$_GET["count"]);

	}
1052780
function parseTextBody(req, res, next){
    if (req.body === undefined) {
      req.body = '';
      req.on('data', function(chunk){ req.body += chunk });
      req.on('end', next);
    } else {
      next();
    }
  }
1092026
@RequestHandler(dynamic = true)
    public void onGet(Request.In.Get event, IOSubchannel channel)
            throws ParseException, IOException {
        int prefixSegs = resourcePattern.matches(event.requestUri());
        if (prefixSegs < 0) {
            return;
        }
        if (contentDirectory == null) {
            getFromUri(event, channel, prefixSegs);
        } else {
            getFromFileSystem(event, channel, prefixSegs);
        }
    }
1327944
function getRequest(at, api_url, config, callback) {
  if (!config.responseCode)
    config.responseCode = 200;

  request(
    {
      uri:    getURL(at, api_url, config.opts),
      method: 'GET',
      headers: {'Content-Type': 'application/json'}
    },
    function(err,res,body) {
      if (!err && res.statusCode == config.responseCode) {
        if (config.doParse) {
          callback(null,JSON.parse(body).response);    
        } else {
          callback(null,res.statusCode);         
        }
      } else  {
        callback(res)
      }
  });  

}
334175
function getHandler (method, getArgs) {
  return service => {
    return function (req, res, next) {
      const { query } = req;
      const route = omit(req.params, '__feathersId');

      res.setHeader('Allow', allowedMethods(service).join(','));

      // Check if the method exists on the service at all. Send 405 (Method not allowed) if not
      if (typeof service[method] !== 'function') {
        debug(`Method '${method}' not allowed on '${req.url}'`);
        res.status(statusCodes.methodNotAllowed);

        return next(new errors.MethodNotAllowed(`Method \`${method}\` is not supported by this endpoint.`));
      }

      // Grab the service parameters. Use req.feathers
      // and set the query to req.query merged with req.params
      const params = Object.assign({
        query, route
      }, req.feathers);

      Object.defineProperty(params, '__returnHook', {
        value: true
      });

      // Run the getArgs callback, if available, for additional parameters
      const args = getArgs(req, params);

      debug(`REST handler calling \`${method}\` from \`${req.url}\``);

      service[method](...args, true)
        .then(hook => {
          const data = hook.dispatch !== undefined ? hook.dispatch : hook.result;

          res.data = data;
          res.hook = hook;

          if (hook.statusCode) {
            res.status(hook.statusCode);
          } else if (!data) {
            debug(`No content returned for '${req.url}'`);
            res.status(statusCodes.noContent);
          } else if (method === 'create') {
            res.status(statusCodes.created);
          }

          return next();
        })
        .catch(hook => {
          const { error } = hook;

          debug(`Error in handler: \`${error.message}\``);
          res.hook = hook;

          return next(hook.error);
        });
    };
  };
}
1102246
function parseArgs() {
    var args = Array.prototype.slice.call(arguments);

    var ret = {
        query: args[0],
        params: [],
        options: {},
        callback: undefined,
        endCallback: undefined
    };

    args.shift();

    // If specified, params must be an array
    if (args[0] instanceof Array) {
        ret.params = args[0];
        args.shift();
    }

    // If specified, options must be a non-Function object
    if (! (args[0] instanceof Function)) {
        ret.options = args[0];
        args.shift();
    }

    ret.callback = args[0];
    ret.endCallback = args[1];

    if (ret.query === undefined || ret.callback === undefined) {
        throw new Error('query and callback are required');
    }

    return ret;
}
551831
def parse(self, method, endpoint, body):
        '''  '''
        if isinstance(body, dict):  # request body was already parsed
            return body
        if endpoint == 'list':
            return self.parse_list(body)

        return self.parse_detail(body)
466013
function Request_parse() {
        var that = this, url = this.url;
        if (this.isForwarded) {
            return this._process()
                .then(function destroy() {
                    logger.info('Request.destroy', {
                        url: that.url,
                        status: that.statusCode,
                        id: that.id,
                        isRendered: that.isRendered,
                        content_type: that.getHeader('content-type')
                    });
                    that._destroy();
                })
                .catch(function error(e) {
                    logger.error('Request.destroy', {error: e, url: url});
                });
        }
        // receive body as buffer
        this.request.on('data', this.body.push.bind(this.body));

        return new Promise(this.request.on.bind(this.request, 'end'))
            .then(this._process.bind(this))
            .then(function destroy() {
                logger.info('Request.destroy', {
                    url: that.url,
                    status: that.statusCode,
                    id: that.id,
                    isRendered: that.isRendered,
                    content_type: that.getHeader('content-type')
                });
                that._destroy();
            })
            .catch(function error(e) {
                logger.error('Request.destroy', {error: e, url: url});
            });

    }
793302
def parse(cls, requester, entries):
        """"""
        result_entries = SearchableList()
        for entry in entries:
            result_entries.append(cls.instance.parse(requester, entry))
        return result_entries
245081
def requests_get(url):
    

    LOGGER.info(u'Fetching %s…', url)
    return requests.get(url)
129147
def fetch_and_parse(method, uri, params_prefix=None, **params):
    """"""
    response = fetch(method, uri, params_prefix, **params)
    return _parse(json.loads(response.text))
618403
def fetch(self, raise_exc=True):
        ''''''
        self._request(GET, raise_exc=raise_exc)  # ingests response
        self.fetched = True
        return self.state.copy()
569465
public Parse getParse(String params) throws Exception {
    String action = "parse";
    Api api = getActionResult(action, params);
    super.handleError(api);
    return api.getParse();
  }
949705
def parse_request(self):
        
        data = {}
        options = {}
        ### get data
        if request.headers['Content-Type'].startswith('application/json'):
            # data in JSON
            data = request.json
            assert data is not None #FIXME: better error than assertError ?
            if "options" in data:
                options = data["options"]
                del data["options"]
        else:
            # data in URL/post
            data = dict()
            data.update(request.form)
            data.update(request.args)
            for key, value in six.iteritems(data):
                if isinstance(value, list) and len(value) == 1:
                    data[key] = value[0]
            # manage config in url
            options = self._config_from_url()
        return data, options
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)
  );
}
516671
function queryParser( req, res, next ) {
	if ( !req.query ) {
		var val = parseUrl( req ).query;
		req.query = queryparse( val );
	}
	next();
}
86443
def parse(self, input):
        """"""
        query = None
        for handler in self._line_handlers:
            try:
                query = handler.handle(input)
            except Exception as e:
                query = None
            finally:
                if query is not None:
                    return query
        return None