Dispatch the parameters to sort, filter, ...
165179
protected function parseInput()
    {
        foreach ($this->input as $key=>$value) {
            $this->applyParameter($key, $value);
        }
    }
1068680
def dispatch(self, request, *args, **kwargs):
        """"""
        self._add_next_and_user(request)
        return super(DeleteImageView, self).dispatch(request, *args, **kwargs)
1108289
function( json, params, callback ){
    var where = sql.parse( 'select * from foo where '+ params.where).where;

    var features = [];
    _.each(json.features, function(f){
      var props = f.attributes || f.properties;
      var param = where.conditions.left.value;
      var val = where.conditions.right.value;
      if ( ( this.whereOps[ where.conditions.operation ] && props[ param ] && this.whereOps[ where.conditions.operation ]( props[ param ], val ) ) || param == val ) {
        features.push( f );
      }
    }, this);
    json.features = features;

    delete params.where;
    // recycle the data + params through the filter fn
    this.filter( json, params, callback );
  }
530452
def dispatch(self, request, *args, **kwargs):
        
        self.args = args
        self.kwargs = kwargs
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        try:
            self.initial(request, *args, **kwargs)

            # Get the appropriate handler method
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed

            response = handler(request, *args, **kwargs)

        except Exception as exc:
            response = self.handle_exception(exc)

        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response
1178959
function orderByParam(query) {
  const value = query[orderedBy];

  switch (value) {
  case orderByKey:
    return;

  case orderByValue:
    return '$value';

  case orderByPriority:
    return '$priority';

  default:
    return value;
  }
}
926155
def dispatch(self, request, *args, **kwargs):
        
        if request.GET.get(self.xeditable_fieldname_param):
            return self.get_ajax_xeditable_choices(request, *args, **kwargs)
        return super(XEditableMixin, self).dispatch(request, *args, **kwargs)
52396
function dispatch(context, event, args) {
    var date = new Date()
    for (var i = 0; i < listeners.length; i++)
      listeners[i](context, event, date, args)
  }
465911
def _getParameters(self):
        """"""
        param = self.query._getParameters()        
        sortingNames = []
        for outputCol in self.__columns:
            sort_dictionary={"field" : outputCol, "direction" : "ASC"}
            sortingNames.append(sort_dictionary)            
        param.update({'sort' : {"ordersList" : sortingNames}})
        return param
237888
protected function _initFilterOptions()
    {
        if (!$this->_filterEnabled && !$this->_sortEnabled) {
            return;
        }

        $options = [
            'conditions' => [],
            'order' => []
        ];

        // check filter params
        if (!empty($this->request->getData())) {
            foreach ($this->request->getData() as $field => $value) {
                if (!isset($this->filterFields[$field]) || $value === '') {
                    continue;
                }

                $options = $this->_createFilterFieldOption($field, $value, $options);

                $this->activeFilters[$field] = $value;
            }
        }

        if (isset($this->sortFields[$this->request->getQuery('s')])) {
            $d = 'asc';
            if ($this->request->getQuery('d')) {
                $dir = strtolower($this->request->getQuery('d'));
                if (in_array($dir, ['asc', 'desc'])) {
                    $d = $dir;
                }
            }
            $field = $this->request->getQuery('s');
            $options = $this->_createSortFieldOption($field, $d, $options);
            $this->activeSort[$field] = $d;
        } elseif (!empty($this->defaultSort)) {
            $options = $this->_createSortFieldOption($this->defaultSort['field'], $this->defaultSort['dir'], $options);
            $this->activeSort[$this->defaultSort['field']] = $this->defaultSort['dir'];
        }

        if ($this->request->getQuery('p')) {
            $this->page = $this->request->getQuery('p');
        }

        $this->filterOptions = $options;
    }
319841
def dispatch(argdict):
    ''''''
    cmd = argdict['command']
    ftc = getattr(THIS_MODULE, 'do_'+cmd)
    ftc(argdict)
251314
def remove_parameter(self, parameter_name):
        """"""
        if parameter_name in self.paramorder:
            index = self.paramorder.index(parameter_name)
            del self.paramorder[index]

        if parameter_name in self._parameters:
            del self._parameters[parameter_name]
925284
def dispatch(self, event):
        

        for event_types, queues in self.queues.items():
            if event.type & event_types:
                for queue in queues:
                    queue.put(event)
313380
def dispatch(self, request, *args, **kwargs):
        """"""
        if False:  # TODO do permission check based on Model
            raise PermissionDenied
        return super().dispatch(request, *args, **kwargs)
462983
async def dispatch(self, request, view=None, **kwargs):
        """"""
        # Authorization endpoint
        self.auth = await self.authorize(request, **kwargs)  # noqa

        # Load collection
        self.collection = await self.get_many(request, **kwargs)

        if request.method == 'POST' and view is None:
            return await super(RESTHandler, self).dispatch(request, **kwargs)

        # Load resource
        resource = await self.get_one(request, **kwargs)

        headers = {}

        if request.method == 'GET' and resource is None:

            # Filter resources
            if VAR_WHERE in request.query:
                self.collection = await self.filter(request, **kwargs)

            # Sort resources
            if VAR_SORT in request.query:
                sorting = [(name.strip('-'), name.startswith('-'))
                           for name in request.query[VAR_SORT].split(',')]
                self.collection = await self.sort(*sorting, **kwargs)

            # Paginate resources
            per_page = request.query.get(VAR_PER_PAGE, self.meta.per_page)
            if per_page:
                try:
                    per_page = int(per_page)
                    if per_page:
                        page = int(request.query.get(VAR_PAGE, 0))
                        offset = page * per_page
                        self.collection, total = await self.paginate(request, offset, per_page)
                        headers = make_pagination_headers(
                            request, per_page, page, total, self.meta.page_links)
                except ValueError:
                    raise RESTBadRequest(reason='Pagination params are invalid.')

        response = await super(RESTHandler, self).dispatch(
            request, resource=resource, view=view, **kwargs)
        response.headers.update(headers)
        return response
8228
def _getParameters(self):
        """"""
        param = self.query._getParameters() 
        index = self._getFilterIndex()
        param.update({
        'filter['+str(index)+'][columnAlias]' : self.__column,
        'filter['+str(index)+'][data][type]' : self.__type,
        'filter['+str(index)+'][data][value]' : self.__value,
        'filter['+str(index)+'][data][comparison]' : self.__comparison})        
        #self.__column.getColumnAlias()
        return param
729689
@Override
	public Parameter doParameter(final Parameter parameter) {
		if (getFilters().isEmpty()) {
			return parameter;
		}
		Parameter param = parameter;
		for (final SqlFilter filter : getFilters()) {
			param = filter.doParameter(param);
		}
		return param;
	}
389443
def _dispatch(self, cmd, args):
        
        if cmd in self.clis:
            extern_cmd, args = args[0], args[1:]
            self.clis[cmd]._dispatch(extern_cmd, args)
        else:
            if cmd in self.cmds:
                callback, parser = self.cmds[cmd]
                try:
                    p_args = parser.parse_args(args)
                except SystemExit:
                    return
                callback(**dict(filter(lambda p:p[1] != None, p_args._get_kwargs())))
            else:
                self._invalid_cmd(command=cmd)