public IPage list()

in hugegraph-hubble/hubble-be/src/main/java/org/apache/hugegraph/service/schema/PropertyIndexService.java [124:191]
62 lines of code
13 McCabe index (conditional complexity)

    public IPage<PropertyIndex> list(int connId, HugeType type, String content,
                                     int pageNo, int pageSize) {
        HugeClient client = this.client(connId);
        List<IndexLabel> indexLabels = client.schema().getIndexLabels();

        Map<String, List<PropertyIndex>> matchedResults = new HashMap<>();
        Map<String, List<PropertyIndex>> unMatchResults = new HashMap<>();
        for (IndexLabel indexLabel : indexLabels) {
            if (!indexLabel.baseType().equals(type)) {
                continue;
            }
            String baseValue = indexLabel.baseValue();
            List<PropertyIndex> groupedIndexes;
            // Collect indexlabels that contains content
            boolean match = baseValue.contains(content);
            if (match) {
                groupedIndexes = matchedResults.computeIfAbsent(baseValue,
                                                                k -> new ArrayList<>());
            } else {
                groupedIndexes = unMatchResults.computeIfAbsent(baseValue,
                                                                k -> new ArrayList<>());
            }
            match = match || indexLabel.name().contains(content) ||
                    indexLabel.indexFields().stream()
                              .anyMatch(f -> f.contains(content));
            if (match) {
                groupedIndexes.add(convert(indexLabel));
            }
        }

        // Sort matched results by relevance
        if (!StringUtils.isEmpty(content)) {
            for (Map.Entry<String, List<PropertyIndex>> entry :
                    matchedResults.entrySet()) {
                List<PropertyIndex> groupedIndexes = entry.getValue();
                groupedIndexes.sort(new Comparator<PropertyIndex>() {
                    final int highScore = 2;
                    final int lowScore = 1;

                    @Override
                    public int compare(PropertyIndex o1, PropertyIndex o2) {
                        int o1Score = 0;
                        if (o1.getName().contains(content)) {
                            o1Score += highScore;
                        }
                        if (o1.getFields().stream()
                              .anyMatch(field -> field.contains(content))) {
                            o1Score += lowScore;
                        }

                        int o2Score = 0;
                        if (o2.getName().contains(content)) {
                            o2Score += highScore;
                        }
                        if (o2.getFields().stream()
                              .anyMatch(field -> field.contains(content))) {
                            o2Score += lowScore;
                        }
                        return o2Score - o1Score;
                    }
                });
            }
        }
        List<PropertyIndex> all = new ArrayList<>();
        matchedResults.values().forEach(all::addAll);
        unMatchResults.values().forEach(all::addAll);
        return PageUtil.page(all, pageNo, pageSize);
    }