Returns the "sort[]" query parameters.
179153
public function getSorting(): array
    {
        if ($this->sorting === null) {
            $this->sorting = $this->setSorting();
        }

        return $this->sorting;
    }
220120
private function sort()
    {
        if ($this->sort) {
            return $this->sort;
        };
        return $this->sort = array_multisort($this->cleanParam) && ksort($this->cleanParam);
    }
190460
public final List<T> searchSorted(String searchString, String sort) {
        return this.findSortedByQuery(FULLTEXT_QUERY, sort, searchString);
    }
188689
def _sortObjects(orderby='created', **kwargs):
    """"""
    o = []
    
    for m in kwargs.values():
        for l in iter(m):
            o.append(l)
    o = list(set(o))
    sortfunc = _sortByCreated if orderby == 'created' else _sortByModified
    if six.PY2:
        o.sort(sortfunc)
    else:
        o.sort(key=functools.cmp_to_key(sortfunc))

    return o
1027014
protected QueryParameters[] getQueryParams(InputHandler[] inputHandlers) {
        QueryParameters[] result = new QueryParameters[inputHandlers.length];

        for (int i = 0; i < inputHandlers.length; i++) {
            result[i] = inputHandlers[i].getQueryParameters();
        }

        return result;
    }
658927
function (query) {
            if (query instanceof Query && query.query.sort) {
                if (this.$.query) {
                    query.query.where = this.$.query.query.where;
                }


                var options = _.defaults({}, {
                    query: query,
                    root: this.getRoot()
                }, this.$);

                var sortCacheId = query.sortCacheId();

                if (!this.$sortCache[sortCacheId]) {
                    this.$sortCache[sortCacheId] = this._createSortedCollection(query, options);
                }

                return this.$sortCache[sortCacheId];
            }

            return this;
        }
1086327
protected function querySort($query, $sort = [])
    {
        $sort = $sort ?: $this->sort;

        foreach ($sort as $attribute => $order) {
            $query->orderBy($attribute, $order);
        }

        return $query;
    }
1215348
public List<QueryStats> getReportSortedBy(String sortByVal) {
        SortBy sortBy;
        try {
            sortBy = SortBy.valueOf(sortByVal);
        } catch (Exception e) {
            throw new IllegalArgumentException("allowed values are: " + Arrays.toString(SortBy.values()));
        }

        List<QueryStats> res = new ArrayList<>(statsByQuery.values());
        Collections.sort(res, sortBy.getComparator());
        return res;
    }
459678
public function getQueryParams()
    {
        if (is_array($this->query)) {
            return $this->query;
        }

        if ($this->uri === null) {
            return [];
        }

        parse_str($this->uri->getQuery(), $this->query);

        return $this->query;
    }
832343
private function getSortArrayParameter($sortCondition)
    {
        $sortArray = [
            $sortCondition['column']->getUniqueId(),
        ];

        if ('DESC' === $sortCondition['sortDirection']) {
            $desc = SORT_DESC;
            $sortArray[] = $desc;
        } else {
            $asc = SORT_ASC;
            $sortArray[] = $asc;
        }

        switch (get_class($sortCondition['column']->getType())) {
            case Column\Type\Number::class:
                $numeric = SORT_NUMERIC;
                $sortArray[] = $numeric;
                break;

            case Column\Type\PhpString::class:
                $string = SORT_NATURAL | SORT_FLAG_CASE;
                $sortArray[] = $string;
                break;

            default:
                $regular = SORT_REGULAR;
                $sortArray[] = $regular;
                break;
        }

        return $sortArray;
    }
1144760
def actual_sort(self):
        """"""
        if not self._actual_sort:

            # trigger evaluation of operation
            if self.operation in ['query', 'getmore']:
                self._actual_sort = self._find_pattern('orderby: ',
                                                        actual=True)

        return self._actual_sort
1166516
public static function orderBy(): array
    {
        $args = \func_get_args();
        $data = array_shift($args);
        foreach ($args as $n => $field) {
            if (\is_string($field)) {
                $tmp = [];
                foreach ($data as $key => $row) {
                    $tmp[$key] = $row[$field];
                }
                $args[$n] = $tmp;
            }
        }
        $args[] = &$data;
        array_multisort($args);
        return array_pop($args);
    }
579813
public void sortTypes(String sortParams) {

        List<CmsResourceTypeBean> types = getSearchTypes();
        SortParams sort = SortParams.valueOf(sortParams);
        switch (sort) {
            case title_asc:
                Collections.sort(types, new CmsComparatorTitle(true));
                break;
            case title_desc:
                Collections.sort(types, new CmsComparatorTitle(false));
                break;
            case type_asc:
                Collections.sort(types, new CmsComparatorType(true));
                break;
            case type_desc:
                Collections.sort(types, new CmsComparatorType(false));
                break;
            case dateLastModified_asc:
            case dateLastModified_desc:
            case path_asc:
            case path_desc:
            case tree:
            default:
                // not supported
                return;
        }
        m_handler.onUpdateTypes(types, m_searchObject.getTypes());
    }
768741
public function getQueryParameters(): array
    {
        $url = $this->getUrl();
        if (false === ($index = strpos($url, '?'))) {
            return [];
        }

        parse_str(substr($url, $index + 1), $queryParams);

        return $queryParams;
    }
1147745
def sort(self, *sort_tuples):
        ''' 
        '''
        query = self
        for name, direction in sort_tuples:
            field = resolve_name(self.type, name)
            if direction in (ASCENDING, 1):
                query = query.ascending(field)
            elif direction in (DESCENDING, -1):
                query = query.descending(field)
            else:
                raise BadQueryException('Bad sort direction: %s' % direction)
        return query
300441
public function getSortColumns(array $query = [])
    {
        $current_sort_by = $this->getSortColumn($query);

        // sort by
        $sort_by = [];
        foreach (self::$sort_by_column as $column => $info) {
            $sort_by[] = [
                'name' => $info['name'],
                'title' => $info['title'],
                'current' => $current_sort_by == $column,
                'link' => '?'.http_build_query(
                    array_merge($query, ['sort_by' => $column])
                ),
            ];
        }

        return $sort_by;
    }
811513
def get_ordered_params(url):
        

        if url not in URLHelper.__cache:
            URLHelper.__cache[url] = urlparse(url)

        params = URLHelper.query_string_to_dict(URLHelper.__cache[url].query)

        return OrderedDict(sorted(params.items()))