public IndexPlan build()

in oak-query-spi/src/main/java/org/apache/jackrabbit/oak/spi/query/QueryIndex.java [498:682]
161 lines of code
3 McCabe index (conditional complexity)

            public IndexPlan build() {

                return new IndexPlan() {

                    private final double costPerExecution =
                            Builder.this.costPerExecution;
                    private final double costPerEntry =
                            Builder.this.costPerEntry;
                    private final long estimatedEntryCount =
                            Builder.this.estimatedEntryCount;
                    private Filter filter =
                            Builder.this.filter;
                    private final boolean isDelayed =
                            Builder.this.isDelayed;
                    private final boolean isFulltextIndex =
                            Builder.this.isFulltextIndex;
                    private final boolean includesNodeData =
                            Builder.this.includesNodeData;
                    private final List<OrderEntry> sortOrder =
                            Builder.this.sortOrder == null ?
                            null : new ArrayList<OrderEntry>(
                                    Builder.this.sortOrder);
                    private final NodeState definition =
                            Builder.this.definition;
                    private final PropertyRestriction propRestriction =
                            Builder.this.propRestriction;
                    private final String pathPrefix =
                            Builder.this.pathPrefix;
                    private final boolean supportsPathRestriction =
                            Builder.this.supportsPathRestriction;
                    private final Map<String, Object> attributes =
                            Builder.this.attributes;
                    private final String planName = Builder.this.planName;
                    private final boolean deprecated =
                            Builder.this.deprecated;
                    private final boolean logWarningForPathFilterMismatch = Builder.this.logWarningForPathFilterMismatch;
                    private final Map<String, List<String>> additionalMessages = Builder.this.additionalMessages;

                    private String getAdditionalMessageString() {
                        return additionalMessages.entrySet().stream()
                                .map(e -> e.getKey() + " : " + e.getValue())
                                .collect(Collectors.joining(", "));
                    }

                    @Override
                    public String toString() {
                        return String.format(
                              "{ costPerExecution : %s,"
                            + " costPerEntry : %s,"
                            + " estimatedEntryCount : %s,"
                            + " filter : %s,"
                            + " isDelayed : %s,"
                            + " isFulltextIndex : %s,"
                            + " includesNodeData : %s,"
                            + " sortOrder : %s,"
                            + " definition : %s,"
                            + " propertyRestriction : %s,"
                            + " pathPrefix : %s,"
                            + " deprecated : %s,"
                            + " supportsPathRestriction : %s,"
                            + " additionalMessage : %s,"
                            + " logWarningForPathFilterMismatch : %s }",
                            costPerExecution,
                            costPerEntry,
                            estimatedEntryCount,
                            filter,
                            isDelayed,
                            isFulltextIndex,
                            includesNodeData,
                            sortOrder,
                            definition,
                            propRestriction,
                            pathPrefix,
                            deprecated,
                            supportsPathRestriction,
                            getAdditionalMessageString(),
                            logWarningForPathFilterMismatch
                            );
                    }

                    @Override
                    public double getCostPerExecution() {
                        return costPerExecution;
                    }

                    @Override
                    public double getCostPerEntry() {
                        return costPerEntry;
                    }

                    @Override
                    public long getEstimatedEntryCount() {
                        return estimatedEntryCount;
                    }

                    @Override
                    public Filter getFilter() {
                        return filter;
                    }

                    @Override
                    public void setFilter(Filter filter) {
                        this.filter = filter;
                    }

                    @Override
                    public boolean isDelayed() {
                        return isDelayed;
                    }

                    @Override
                    public boolean isFulltextIndex() {
                        return isFulltextIndex;
                    }

                    @Override
                    public boolean includesNodeData() {
                        return includesNodeData;
                    }

                    @Override
                    public List<OrderEntry> getSortOrder() {
                        return sortOrder;
                    }

                    @Override
                    public NodeState getDefinition() {
                        return definition;
                    }

                    @Override
                    public PropertyRestriction getPropertyRestriction() {
                        return propRestriction;
                    }

                    @Override
                    public String getPathPrefix() {
                        return pathPrefix;
                    }

                    @Override
                    public boolean getSupportsPathRestriction() {
                        return supportsPathRestriction;
                    }

                    @Override
                    protected Object clone() throws CloneNotSupportedException {
                        return super.clone();
                    }

                    @Override
                    public IndexPlan copy() {
                        try {
                            return (IndexPlan) super.clone();
                        } catch (CloneNotSupportedException e) {
                            throw new IllegalStateException(e);
                        }
                    }

                    @Override
                    public Object getAttribute(String name) {
                        return attributes.get(name);
                    }

                    @Override
                    public String getPlanName() {
                        return planName;
                    }

                    @Override
                    public boolean isDeprecated() {
                        return deprecated;
                    }
                    
                    @Override
                    public boolean logWarningForPathFilterMismatch() {
                        return logWarningForPathFilterMismatch;
                    }

                    @Override
                    public Map<String, List<String>> getAdditionalLogMessages() {
                        return additionalMessages;
                    }
                };
            }