Examples with Comparator java.util.Comparator used on opensource projects

Example 56 with Comparator

use of java.util.Comparator in project OpenGrok by OpenGrok.

the class JFlexXref method writeSymbolTable.

/**
     * Write a JavaScript function that returns an array with the definitions to
     * list in the navigation panel. Each element of the array is itself an
     * array containing the name of the definition type, the CSS class name for
     * the type, and an array of (symbol, line) pairs for the definitions of
     * that type.
     */
private void writeSymbolTable() throws IOException {
    if (defs == null) {
        // No definitions, no symbol table to write
        return;
    }
    // We want the symbol table to be sorted
    Comparator<Tag> cmp = new Comparator<Tag>() {

        @Override
        public int compare(Tag tag1, Tag tag2) {
            // Order by symbol name, and then by line number if multiple
            // definitions use the same symbol name
            int ret = tag1.symbol.compareTo(tag2.symbol);
            if (ret == 0) {
                ret = tag1.line - tag2.line;
            }
            return ret;
        }
    };
    Map<String, SortedSet<Tag>> symbols = new HashMap<>();
    for (Tag tag : defs.getTags()) {
        Style style = getStyle(tag.type);
        if (style != null && style.title != null) {
            SortedSet<Tag> tags = symbols.get(style.name);
            if (tags == null) {
                tags = new TreeSet<>(cmp);
                symbols.put(style.name, tags);
            }
            tags.add(tag);
        }
    }
    //TODO try to get rid of included js scripts generated from here (all js should ideally be in util)
    out.append("<script type=\"text/javascript\">/* <![CDATA[ */\n");
    out.append("function get_sym_list(){return [");
    boolean first = true;
    for (Style style : DEFINITION_STYLES) {
        SortedSet<Tag> tags = symbols.get(style.name);
        if (tags != null) {
            if (!first) {
                out.append(',');
            }
            out.append("[\"");
            out.append(style.title);
            out.append("\",\"");
            out.append(style.ssClass);
            out.append("\",[");
            boolean firstTag = true;
            for (Tag tag : tags) {
                if (!firstTag) {
                    out.append(',');
                }
                out.append('[');
                out.append(Util.jsStringLiteral(tag.symbol));
                out.append(',');
                out.append(Integer.toString(tag.line));
                out.append(']');
                firstTag = false;
            }
            out.append("]]");
            first = false;
        }
    }
    /* no LF intentionally - xml is whitespace aware ... */
    out.append("];} /* ]]> */</script>");
}

Example 57 with Comparator

use of java.util.Comparator in project pinot by linkedin.

the class StarTreeJsonNode method build.

private int build(StarTreeIndexNodeInterf indexNode, StarTreeJsonNode json) {
    Iterator<? extends StarTreeIndexNodeInterf> childrenIterator = indexNode.getChildrenIterator();
    if (!childrenIterator.hasNext()) {
        return 0;
    }
    int childDimensionId = indexNode.getChildDimensionName();
    String childDimensionName = dimensionNameToIndexMap.inverse().get(childDimensionId);
    Dictionary dictionary = dictionaries.get(childDimensionName);
    int totalChildNodes = indexNode.getNumChildren();
    Comparator<Pair<String, Integer>> comparator = new Comparator<Pair<String, Integer>>() {

        @Override
        public int compare(Pair<String, Integer> o1, Pair<String, Integer> o2) {
            return -1 * Integer.compare(o1.getRight(), o2.getRight());
        }
    };
    MinMaxPriorityQueue<Pair<String, Integer>> queue = MinMaxPriorityQueue.orderedBy(comparator).maximumSize(MAX_CHILDREN).create();
    StarTreeJsonNode allNode = null;
    while (childrenIterator.hasNext()) {
        StarTreeIndexNodeInterf childIndexNode = childrenIterator.next();
        int childDimensionValueId = childIndexNode.getDimensionValue();
        String childDimensionValue = "ALL";
        if (childDimensionValueId != StarTreeIndexNodeInterf.ALL) {
            childDimensionValue = dictionary.get(childDimensionValueId).toString();
        }
        StarTreeJsonNode childJson = new StarTreeJsonNode(childDimensionValue);
        totalChildNodes += build(childIndexNode, childJson);
        if (childDimensionValueId != StarTreeIndexNodeInterf.ALL) {
            json.addChild(childJson);
            queue.add(ImmutablePair.of(childDimensionValue, totalChildNodes));
        } else {
            allNode = childJson;
        }
    }
    //put ALL node at the end
    if (allNode != null) {
        json.addChild(allNode);
    }
    if (totalChildNodes > MAX_CHILDREN) {
        Iterator<Pair<String, Integer>> qIterator = queue.iterator();
        Set<String> topKDimensions = new HashSet<>();
        topKDimensions.add("ALL");
        while (qIterator.hasNext()) {
            topKDimensions.add(qIterator.next().getKey());
        }
        Iterator<StarTreeJsonNode> iterator = json.getChildren().iterator();
        while (iterator.hasNext()) {
            StarTreeJsonNode next = iterator.next();
            if (!topKDimensions.contains(next.getName())) {
                iterator.remove();
            }
        }
    }
    return totalChildNodes;
}

Example 58 with Comparator

use of java.util.Comparator in project AndroidAsync by koush.

the class AsyncHttpServer method directory.

public void directory(String regex, final File directory, final boolean list) {
    assert directory.isDirectory();
    addAction("GET", regex, new HttpServerRequestCallback() {

        @Override
        public void onRequest(AsyncHttpServerRequest request, final AsyncHttpServerResponse response) {
            String path = request.getMatcher().replaceAll("");
            File file = new File(directory, path);
            if (file.isDirectory() && list) {
                ArrayList<File> dirs = new ArrayList<File>();
                ArrayList<File> files = new ArrayList<File>();
                for (File f : file.listFiles()) {
                    if (f.isDirectory())
                        dirs.add(f);
                    else
                        files.add(f);
                }
                Comparator<File> c = new Comparator<File>() {

                    @Override
                    public int compare(File lhs, File rhs) {
                        return lhs.getName().compareTo(rhs.getName());
                    }
                };
                Collections.sort(dirs, c);
                Collections.sort(files, c);
                files.addAll(0, dirs);
                return;
            }
            if (!file.isFile()) {
                response.code(404);
                response.end();
                return;
            }
            try {
                FileInputStream is = new FileInputStream(file);
                response.code(200);
                Util.pump(is, response, new CompletedCallback() {

                    @Override
                    public void onCompleted(Exception ex) {
                        response.end();
                    }
                });
            } catch (FileNotFoundException ex) {
                response.code(404);
                response.end();
            }
        }
    });
}

Example 59 with Comparator

use of java.util.Comparator in project storm by apache.

the class DirectoryCleaner method deleteOldestWhileTooLarge.

/**
     * If totalSize of files exceeds the either the per-worker quota or global quota,
     * Logviewer deletes oldest inactive log files in a worker directory or in all worker dirs.
     * We use the parameter for_per_dir to switch between the two deletion modes.
     * @param dirs the list of directories to be scanned for deletion
     * @param quota the per-dir quota or the total quota for the all directories
     * @param for_per_dir if true, deletion happens for a single dir; otherwise, for all directories globally
     * @param active_dirs only for global deletion, we want to skip the active logs in active_dirs
     * @return number of files deleted
     */
public int deleteOldestWhileTooLarge(List<File> dirs, long quota, boolean for_per_dir, Set<String> active_dirs) throws IOException {
    // max number of files to delete for every round
    final int PQ_SIZE = 1024;
    // max rounds of scanning the dirs
    final int MAX_ROUNDS = 512;
    long totalSize = 0;
    int deletedFiles = 0;
    for (File dir : dirs) {
        try (DirectoryStream<Path> stream = getStreamForDirectory(dir)) {
            for (Path path : stream) {
                File file = path.toFile();
                totalSize += file.length();
            }
        }
    }
    long toDeleteSize = totalSize - quota;
    if (toDeleteSize <= 0) {
        return deletedFiles;
    }
    Comparator<File> comparator = new Comparator<File>() {

        public int compare(File f1, File f2) {
            if (f1.lastModified() > f2.lastModified()) {
                return -1;
            } else {
                return 1;
            }
        }
    };
    // the oldest pq_size files in this directory will be placed in PQ, with the newest at the root
    PriorityQueue<File> pq = new PriorityQueue<File>(PQ_SIZE, comparator);
    int round = 0;
    while (toDeleteSize > 0) {
        LOG.debug("To delete size is {}, start a new round of deletion, round: {}", toDeleteSize, round);
        for (File dir : dirs) {
            try (DirectoryStream<Path> stream = getStreamForDirectory(dir)) {
                for (Path path : stream) {
                    File file = path.toFile();
                    if (for_per_dir) {
                        if (ACTIVE_LOG_PATTERN.matcher(file.getName()).matches()) {
                            // skip active log files
                            continue;
                        }
                    } else {
                        // for global cleanup
                        if (active_dirs.contains(dir.getCanonicalPath())) {
                            // for an active worker's dir, make sure for the last "/"
                            if (ACTIVE_LOG_PATTERN.matcher(file.getName()).matches()) {
                                // skip active log files
                                continue;
                            }
                        } else {
                            if (META_LOG_PATTERN.matcher(file.getName()).matches()) {
                                // skip yaml and pid files
                                continue;
                            }
                        }
                    }
                    if (pq.size() < PQ_SIZE) {
                        pq.offer(file);
                    } else {
                        if (file.lastModified() < pq.peek().lastModified()) {
                            pq.poll();
                            pq.offer(file);
                        }
                    }
                }
            }
        }
        // need to reverse the order of elements in PQ to delete files from oldest to newest
        Stack<File> stack = new Stack<File>();
        while (!pq.isEmpty()) {
            File file = pq.poll();
            stack.push(file);
        }
        while (!stack.isEmpty() && toDeleteSize > 0) {
            File file = stack.pop();
            toDeleteSize -= file.length();
            LOG.info("Delete file: {}, size: {}, lastModified: {}", file.getCanonicalPath(), file.length(), file.lastModified());
            file.delete();
            deletedFiles++;
        }
        pq.clear();
        round++;
        if (round >= MAX_ROUNDS) {
            if (for_per_dir) {
                LOG.warn("Reach the MAX_ROUNDS: {} during per-dir deletion, you may have too many files in " + "a single directory : {}, will delete the rest files in next interval.", MAX_ROUNDS, dirs.get(0).getCanonicalPath());
            } else {
                LOG.warn("Reach the MAX_ROUNDS: {} during global deletion, you may have too many files, " + "will delete the rest files in next interval.", MAX_ROUNDS);
            }
            break;
        }
    }
    return deletedFiles;
}

Example 60 with Comparator

use of java.util.Comparator in project groovy by apache.

the class TupleConstructorASTTransformation method createConstructor.

public static void createConstructor(AbstractASTTransformation xform, ClassNode cNode, boolean includeFields, boolean includeProperties, boolean includeSuperFields, boolean includeSuperProperties, boolean callSuper, boolean force, List<String> excludes, final List<String> includes, boolean useSetters, boolean defaults, boolean allNames, SourceUnit sourceUnit, ClosureExpression pre, ClosureExpression post) {
    // no processing if existing constructors found
    if (!cNode.getDeclaredConstructors().isEmpty() && !force)
        return;
    List<FieldNode> superList = new ArrayList<FieldNode>();
    if (includeSuperProperties) {
        superList.addAll(getSuperPropertyFields(cNode.getSuperClass()));
    }
    if (includeSuperFields) {
        superList.addAll(getSuperNonPropertyFields(cNode.getSuperClass()));
    }
    List<FieldNode> list = new ArrayList<FieldNode>();
    if (includeProperties) {
        list.addAll(getInstancePropertyFields(cNode));
    }
    if (includeFields) {
        list.addAll(getInstanceNonPropertyFields(cNode));
    }
    final List<Parameter> params = new ArrayList<Parameter>();
    final List<Expression> superParams = new ArrayList<Expression>();
    final BlockStatement preBody = new BlockStatement();
    boolean superInPre = false;
    if (pre != null) {
        superInPre = copyStatementsWithSuperAdjustment(pre, preBody);
        if (superInPre && callSuper) {
            xform.addError("Error during " + MY_TYPE_NAME + " processing, can't have a super call in 'pre' " + "closure and also 'callSuper' enabled", cNode);
        }
    }
    final BlockStatement body = new BlockStatement();
    for (FieldNode fNode : superList) {
        String name = fNode.getName();
        if (shouldSkipUndefinedAware(name, excludes, includes, allNames))
            continue;
        params.add(createParam(fNode, name, defaults, xform));
        boolean hasSetter = cNode.getProperty(name) != null && !fNode.isFinal();
        if (callSuper) {
            superParams.add(varX(name));
        } else if (!superInPre) {
            if (useSetters && hasSetter) {
                body.addStatement(stmt(callThisX(getSetterName(name), varX(name))));
            } else {
                body.addStatement(assignS(propX(varX("this"), name), varX(name)));
            }
        }
    }
    if (callSuper) {
        body.addStatement(stmt(ctorX(ClassNode.SUPER, args(superParams))));
    }
    if (!preBody.isEmpty()) {
        body.addStatements(preBody.getStatements());
    }
    for (FieldNode fNode : list) {
        String name = fNode.getName();
        if (shouldSkipUndefinedAware(name, excludes, includes, allNames))
            continue;
        Parameter nextParam = createParam(fNode, name, defaults, xform);
        params.add(nextParam);
        boolean hasSetter = cNode.getProperty(name) != null && !fNode.isFinal();
        if (useSetters && hasSetter) {
            body.addStatement(stmt(callThisX(getSetterName(name), varX(nextParam))));
        } else {
            body.addStatement(assignS(propX(varX("this"), name), varX(nextParam)));
        }
    }
    if (post != null) {
        body.addStatement(post.getCode());
    }
    if (includes != null) {
        Comparator<Parameter> includeComparator = new Comparator<Parameter>() {

            public int compare(Parameter p1, Parameter p2) {
                return new Integer(includes.indexOf(p1.getName())).compareTo(includes.indexOf(p2.getName()));
            }
        };
        Collections.sort(params, includeComparator);
    }
    cNode.addConstructor(new ConstructorNode(ACC_PUBLIC, params.toArray(new Parameter[params.size()]), ClassNode.EMPTY_ARRAY, body));
    if (sourceUnit != null && !body.isEmpty()) {
        VariableScopeVisitor scopeVisitor = new VariableScopeVisitor(sourceUnit);
        scopeVisitor.visitClass(cNode);
    }
    // or if there is only one Map property (for backwards compatibility)
    if (!params.isEmpty() && defaults) {
        ClassNode firstParam = params.get(0).getType();
        if (params.size() > 1 || firstParam.equals(ClassHelper.OBJECT_TYPE)) {
            String message = "The class " + cNode.getName() + " was incorrectly initialized via the map constructor with null.";
            if (firstParam.equals(ClassHelper.MAP_TYPE)) {
                addMapConstructors(cNode, true, message);
            } else {
                ClassNode candidate = HMAP_TYPE;
                while (candidate != null) {
                    if (candidate.equals(firstParam)) {
                        addMapConstructors(cNode, true, message);
                        break;
                    }
                    candidate = candidate.getSuperClass();
                }
            }
        }
    }
}