Sorts all blocks in ascending order of CRF.

@return the sorted CRF of all blocks
4114
private List<Map.Entry<Long, Double>> getSortedCRF() {
    List<Map.Entry<Long, Double>> sortedCRF = new ArrayList<>(mBlockIdToCRFValue.entrySet());
    sortedCRF.sort(Comparator.comparingDouble(Entry::getValue));
    return sortedCRF;
  }
794153
public int getSortColRenderIndex() {
        final ValueExpression veSortBy = getValueExpression(PropertyKeys.sortBy.name());
        if (veSortBy == null) {
            return -1;
        }

        final String sortByExp = veSortBy.getExpressionString();
        int colIdx = 0;
        for (final SheetColumn column : getColumns()) {
            if (!column.isRendered()) {
                continue;
            }

            final ValueExpression veCol = column.getValueExpression(PropertyKeys.sortBy.name());
            if (veCol != null) {
                if (veCol.getExpressionString().equals(sortByExp)) {
                    return colIdx;
                }
            }
            colIdx++;
        }
        return -1;
    }
1003083
public Comparator<S> comparator() {
        if (mChunkMatcher == null) {
            return mChunkSorter;
        }
        return new Comparator<S>() {
            public int compare(S a, S b) {
                int result = mChunkMatcher.compare(a, b);
                if (result == 0) {
                    result = mChunkSorter.compare(a, b);
                }
                return result;
            }
        };
    }
1002777
public List<T> getSortedKeys() {
    List<T> l = Lists.newArrayList(counts.keySet());
    Collections.sort(l, Ordering.natural().reverse().onResultOf(Functions.forMap(counts.getBaseMap())));
    return l;
  }
1363987
public boolean inOrder() {
        SortedSet<Integer> prev = null;
        for (SortedSet<Integer> cell : cells) {
            if (prev == null) {
                prev = cell;
            } else {
                int first = cell.first();
                int last = cell.last();
                if (first > prev.first() && last > prev.last()) {
                    prev = cell;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
753920
public function getSortedCellList()
    {
        $sortKeys = array();
        foreach ($this->getCellList() as $coord) {
            sscanf($coord, '%[A-Z]%d', $column, $row);
            $sortKeys[sprintf('%09d%3s', $row, $column)] = $coord;
        }
        ksort($sortKeys);

        return array_values($sortKeys);
    }
22434
public SortedSet<TypeElement> allUnnamedClasses() {
        for (PackageElement pkg : allClasses.keySet()) {
            if (pkg.isUnnamed()) {
                return allClasses.get(pkg);
            }
        }
        return new TreeSet<>(comparator);
    }
1291286
public List<FacesConfigOrderingType<FacesConfigType<T>>> getAllOrdering()
   {
      List<FacesConfigOrderingType<FacesConfigType<T>>> list = new ArrayList<FacesConfigOrderingType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("ordering");
      for(Node node: nodeList)
      {
         FacesConfigOrderingType<FacesConfigType<T>>  type = new FacesConfigOrderingTypeImpl<FacesConfigType<T>>(this, "ordering", childNode, node);
         list.add(type);
      }
      return list;
   }
48916
public Map<T, Integer> getAllSorted()
    {
        Map<T, Integer> map = styles;
        TreeMap<T, Integer> smap = new TreeMap<T, Integer>(new StyleCountComparator(map));
        smap.putAll(map);
        return smap;
    }
671423
public List<T> keySetSorted() {
        List<T> result = new ArrayList<>();

        PriorityQueue<Pair<T, Double>> pq = asPriorityQueue();
        while (!pq.isEmpty()) {
            result.add(pq.poll().getFirst());
        }

        return result;
    }
219295
List<Object> getSortedRules() {
        List<Object> result = new ArrayList<Object>();
        for (RuleEntry entry : getSortedEntries()) {
            result.add(entry.rule);
        }
        return result;
    }
909424
public List<FacesConfigAbsoluteOrderingType<FacesConfigType<T>>> getAllAbsoluteOrdering()
   {
      List<FacesConfigAbsoluteOrderingType<FacesConfigType<T>>> list = new ArrayList<FacesConfigAbsoluteOrderingType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("absolute-ordering");
      for(Node node: nodeList)
      {
         FacesConfigAbsoluteOrderingType<FacesConfigType<T>>  type = new FacesConfigAbsoluteOrderingTypeImpl<FacesConfigType<T>>(this, "absolute-ordering", childNode, node);
         list.add(type);
      }
      return list;
   }
1187181
def _build_block_element_list(self):
        
        return sorted(
            [e for e in self.block_elements.values() if not e.virtual],
            key=lambda e: e.priority,
            reverse=True
        )
980257
def sorted_records
      # pull out RRs we want to stick near the top
      top_rrs = {}
      top = %w{SOA NS MX SPF TXT}
      top.each { |t| top_rrs[t] = @records.select { |rr| rr.type == t } }

      remaining = @records.reject { |rr| top.include?(rr.type) }

      # sort remaining RRs by type, alphabeticly
      remaining.sort! { |a,b| a.type <=> b.type }

      top_rrs.values.flatten + remaining
    end
806473
public function getSorts()
    {
        $sortInput = $this->request->input($this->sortName, '');

        $sortFields = $this->collection->make(
            is_array($sortInput) ? $sortInput :
                explode($this->sortFieldsSeparator, $sortInput));

        $sorts = $this->collection->make();

        $sortFields->each(function ($field) use ($sorts) {
            $s = new Sort();
            $order = 'ASC';

            if (starts_with($field, $this->sortDescSign)) {
                $order = 'DESC';
                $field = mb_substr($field, mb_strlen($this->sortDescSign));
            }

            if ($field = trim($field)) {
                $s->setField($field);
                $s->setOrder($order);
                $sorts->put($field, $s);
            }
        });

        return $sorts->values();
    }
371415
List getOrderby()
    {
        List result = _getOrderby();
        Iterator iter = getCriteria().iterator();
        Object crit;

        while (iter.hasNext())
        {
            crit = iter.next();
            if (crit instanceof Criteria)
            {
                result.addAll(((Criteria) crit).getOrderby());
            }
        }

        return result;
    }
1093164
public java.util.List<alluxio.grpc.BlockMasterInfoField> getFiltersList() {
    return new com.google.protobuf.Internal.ListAdapter<
        java.lang.Integer, alluxio.grpc.BlockMasterInfoField>(filters_, filters_converter_);
  }