Inherits diversity settings.

1 files changed, 35 insertions, 32 deletions

diff --git a/config-model/src/main/java/com/yahoo/schema/RankProfile.java b/config-model/src/main/java/com/yahoo/schema/RankProfile.java
index 0619fce5865..ed1a4e98b49 100644
--- a/config-model/src/main/java/com/yahoo/schema/RankProfile.java
+++ b/config-model/src/main/java/com/yahoo/schema/RankProfile.java
@@ -315,18 +315,21 @@ public class RankProfile implements Cloneable {
 
     public MatchPhaseSettings getMatchPhase() {
         if (matchPhase != null) return matchPhase;
-        return uniquelyInherited(p -> p.getMatchPhase(), "match phase settings").orElse(null);
+        return uniquelyInherited(RankProfile::getMatchPhase, "match phase settings").orElse(null);
     }
     public void setDiversity(DiversitySettings value) {
         value.checkValid();
         diversity = value;
     }
-    public DiversitySettings      getDiversity() { return diversity; }
+    public DiversitySettings getDiversity() {
+        if (diversity != null) return diversity;
+        return uniquelyInherited(RankProfile::getDiversity, "diversity settings").orElse(null);
+    }
 
     /** Returns the uniquely determined property, where non-empty is defined as non-null */
     private <T> Optional<T> uniquelyInherited(Function<RankProfile, T> propertyRetriever,
                                               String propertyDescription) {
-        return uniquelyInherited(propertyRetriever, p -> p != null, propertyDescription);
+        return uniquelyInherited(propertyRetriever, Objects::nonNull, propertyDescription);
     }
 
     /**
@@ -341,8 +344,8 @@ public class RankProfile implements Cloneable {
                                               Predicate<T> nonEmptyValueFilter,
                                               String propertyDescription) {
         Set<T> uniqueProperties = inherited().stream()
-                                             .map(p -> propertyRetriever.apply(p))
-                                             .filter(p -> nonEmptyValueFilter.test(p))
+                                             .map(propertyRetriever)
+                                             .filter(nonEmptyValueFilter)
                                              .collect(Collectors.toSet());
         if (uniqueProperties.isEmpty()) return Optional.empty();
         if (uniqueProperties.size() == 1) return uniqueProperties.stream().findAny();
@@ -501,7 +504,7 @@ public class RankProfile implements Cloneable {
 
     public RankingExpressionFunction getFirstPhase() {
         if (firstPhaseRanking != null) return firstPhaseRanking;
-        return uniquelyInherited(p -> p.getFirstPhase(), "first-phase expression").orElse(null);
+        return uniquelyInherited(RankProfile::getFirstPhase, "first-phase expression").orElse(null);
     }
 
     void setFirstPhaseRanking(RankingExpression rankingExpression) {
@@ -528,7 +531,7 @@ public class RankProfile implements Cloneable {
 
     public RankingExpressionFunction getSecondPhase() {
         if (secondPhaseRanking != null) return secondPhaseRanking;
-        return uniquelyInherited(p -> p.getSecondPhase(), "second-phase expression").orElse(null);
+        return uniquelyInherited(RankProfile::getSecondPhase, "second-phase expression").orElse(null);
     }
 
     public void setSecondPhaseRanking(String expression) {
@@ -548,7 +551,7 @@ public class RankProfile implements Cloneable {
 
     public RankingExpressionFunction getGlobalPhase() {
         if (globalPhaseRanking != null) return globalPhaseRanking;
-        return uniquelyInherited(p -> p.getGlobalPhase(), "global-phase expression").orElse(null);
+        return uniquelyInherited(RankProfile::getGlobalPhase, "global-phase expression").orElse(null);
     }
 
     public void setGlobalPhaseRanking(String expression) {
@@ -607,7 +610,7 @@ public class RankProfile implements Cloneable {
             return Collections.unmodifiableSet(combined);
         }
         if (summaryFeatures != null) return Collections.unmodifiableSet(summaryFeatures);
-        return uniquelyInherited(p -> p.getSummaryFeatures(), f -> ! f.isEmpty(), "summary features")
+        return uniquelyInherited(RankProfile::getSummaryFeatures, f -> ! f.isEmpty(), "summary features")
                 .orElse(Set.of());
     }
 
@@ -624,13 +627,13 @@ public class RankProfile implements Cloneable {
             return Collections.unmodifiableSet(combined);
         }
         if (matchFeatures != null) return Collections.unmodifiableSet(matchFeatures);
-        return uniquelyInherited(p -> p.getMatchFeatures(), f -> ! f.isEmpty(), "match features")
+        return uniquelyInherited(RankProfile::getMatchFeatures, f -> ! f.isEmpty(), "match features")
                 .orElse(Set.of());
     }
 
     public Set<ReferenceNode> getHiddenMatchFeatures() {
         if (hiddenMatchFeatures != null) return Collections.unmodifiableSet(hiddenMatchFeatures);
-        return uniquelyInherited(p -> p.getHiddenMatchFeatures(), f -> ! f.isEmpty(), "hidden match features")
+        return uniquelyInherited(RankProfile::getHiddenMatchFeatures, f -> ! f.isEmpty(), "hidden match features")
                 .orElse(Set.of());
     }
 
@@ -668,7 +671,7 @@ public class RankProfile implements Cloneable {
     /** Returns a read-only view of the rank features to use in this profile. This is never null */
     public Set<ReferenceNode> getRankFeatures() {
         if (rankFeatures != null) return Collections.unmodifiableSet(rankFeatures);
-        return uniquelyInherited(p -> p.getRankFeatures(), f -> ! f.isEmpty(), "summary-features")
+        return uniquelyInherited(RankProfile::getRankFeatures, f -> ! f.isEmpty(), "summary-features")
                 .orElse(Set.of());
     }
 
@@ -699,7 +702,7 @@ public class RankProfile implements Cloneable {
         if (rankProperties.isEmpty() && inherited().isEmpty()) return Map.of();
         if (inherited().isEmpty()) return Collections.unmodifiableMap(rankProperties);
 
-        var inheritedProperties = uniquelyInherited(p -> p.getRankPropertyMap(), m -> ! m.isEmpty(), "rank-properties")
+        var inheritedProperties = uniquelyInherited(RankProfile::getRankPropertyMap, m -> ! m.isEmpty(), "rank-properties")
                 .orElse(Map.of());
         if (rankProperties.isEmpty()) return inheritedProperties;
 
@@ -741,21 +744,21 @@ public class RankProfile implements Cloneable {
 
     public int getRerankCount() {
         if (rerankCount >= 0) return rerankCount;
-        return uniquelyInherited(p -> p.getRerankCount(), c -> c >= 0, "rerank-count").orElse(-1);
+        return uniquelyInherited(RankProfile::getRerankCount, c -> c >= 0, "rerank-count").orElse(-1);
     }
 
     public void setGlobalPhaseRerankCount(int count) { this.globalPhaseRerankCount = count; }
 
     public int getGlobalPhaseRerankCount() {
         if (globalPhaseRerankCount >= 0) return globalPhaseRerankCount;
-        return uniquelyInherited(p -> p.getGlobalPhaseRerankCount(), c -> c >= 0, "global-phase rerank-count").orElse(-1);
+        return uniquelyInherited(RankProfile::getGlobalPhaseRerankCount, c -> c >= 0, "global-phase rerank-count").orElse(-1);
     }
 
     public void setNumThreadsPerSearch(int numThreads) { this.numThreadsPerSearch = numThreads; }
 
     public int getNumThreadsPerSearch() {
         if (numThreadsPerSearch >= 0) return numThreadsPerSearch;
-        return uniquelyInherited(p -> p.getNumThreadsPerSearch(), n -> n >= 0, "num-threads-per-search")
+        return uniquelyInherited(RankProfile::getNumThreadsPerSearch, n -> n >= 0, "num-threads-per-search")
                 .orElse(-1);
     }
 
@@ -763,14 +766,14 @@ public class RankProfile implements Cloneable {
 
     public int getMinHitsPerThread() {
         if (minHitsPerThread >= 0) return minHitsPerThread;
-        return uniquelyInherited(p -> p.getMinHitsPerThread(), n -> n >= 0, "min-hits-per-search").orElse(-1);
+        return uniquelyInherited(RankProfile::getMinHitsPerThread, n -> n >= 0, "min-hits-per-search").orElse(-1);
     }
 
     public void setNumSearchPartitions(int numSearchPartitions) { this.numSearchPartitions = numSearchPartitions; }
 
     public int getNumSearchPartitions() {
         if (numSearchPartitions >= 0) return numSearchPartitions;
-        return uniquelyInherited(p -> p.getNumSearchPartitions(), n -> n >= 0, "num-search-partitions").orElse(-1);
+        return uniquelyInherited(RankProfile::getNumSearchPartitions, n -> n >= 0, "num-search-partitions").orElse(-1);
     }
 
     public void setTermwiseLimit(double termwiseLimit) { this.termwiseLimit = termwiseLimit; }
@@ -780,7 +783,7 @@ public class RankProfile implements Cloneable {
 
     public OptionalDouble getTermwiseLimit() {
         if (termwiseLimit != null) return OptionalDouble.of(termwiseLimit);
-        return uniquelyInherited(p -> p.getTermwiseLimit(), l -> l.isPresent(), "termwise-limit")
+        return uniquelyInherited(RankProfile::getTermwiseLimit, OptionalDouble::isPresent, "termwise-limit")
                 .orElse(OptionalDouble.empty());
     }
 
@@ -788,21 +791,21 @@ public class RankProfile implements Cloneable {
         if (postFilterThreshold != null) {
             return OptionalDouble.of(postFilterThreshold);
         }
-        return uniquelyInherited(p -> p.getPostFilterThreshold(), l -> l.isPresent(), "post-filter-threshold").orElse(OptionalDouble.empty());
+        return uniquelyInherited(RankProfile::getPostFilterThreshold, OptionalDouble::isPresent, "post-filter-threshold").orElse(OptionalDouble.empty());
     }
 
     public OptionalDouble getApproximateThreshold() {
         if (approximateThreshold != null) {
             return OptionalDouble.of(approximateThreshold);
         }
-        return uniquelyInherited(p -> p.getApproximateThreshold(), l -> l.isPresent(), "approximate-threshold").orElse(OptionalDouble.empty());
+        return uniquelyInherited(RankProfile::getApproximateThreshold, OptionalDouble::isPresent, "approximate-threshold").orElse(OptionalDouble.empty());
     }
 
     public OptionalDouble getTargetHitsMaxAdjustmentFactor() {
         if (targetHitsMaxAdjustmentFactor != null) {
             return OptionalDouble.of(targetHitsMaxAdjustmentFactor);
         }
-        return uniquelyInherited(p -> p.getTargetHitsMaxAdjustmentFactor(), l -> l.isPresent(), "target-hits-max-adjustment-factor").orElse(OptionalDouble.empty());
+        return uniquelyInherited(RankProfile::getTargetHitsMaxAdjustmentFactor, OptionalDouble::isPresent, "target-hits-max-adjustment-factor").orElse(OptionalDouble.empty());
     }
 
     /** Whether we should ignore the default rank features. Set to null to use inherited */
@@ -812,21 +815,21 @@ public class RankProfile implements Cloneable {
 
     public Boolean getIgnoreDefaultRankFeatures() {
         if (ignoreDefaultRankFeatures != null) return ignoreDefaultRankFeatures;
-        return uniquelyInherited(p -> p.getIgnoreDefaultRankFeatures(), "ignore-default-rank-features").orElse(false);
+        return uniquelyInherited(RankProfile::getIgnoreDefaultRankFeatures, "ignore-default-rank-features").orElse(false);
     }
 
     public void setKeepRankCount(int rerankArraySize) { this.keepRankCount = rerankArraySize; }
 
     public int getKeepRankCount() {
         if (keepRankCount >= 0) return keepRankCount;
-        return uniquelyInherited(p -> p.getKeepRankCount(), c -> c >= 0, "keep-rank-count").orElse(-1);
+        return uniquelyInherited(RankProfile::getKeepRankCount, c -> c >= 0, "keep-rank-count").orElse(-1);
     }
 
     public void setRankScoreDropLimit(double rankScoreDropLimit) { this.rankScoreDropLimit = rankScoreDropLimit; }
 
     public double getRankScoreDropLimit() {
         if (rankScoreDropLimit > -Double.MAX_VALUE) return rankScoreDropLimit;
-        return uniquelyInherited(p -> p.getRankScoreDropLimit(), c -> c > -Double.MAX_VALUE, "rank.score-drop-limit")
+        return uniquelyInherited(RankProfile::getRankScoreDropLimit, c -> c > -Double.MAX_VALUE, "rank.score-drop-limit")
                 .orElse(rankScoreDropLimit);
     }
 
@@ -836,7 +839,7 @@ public class RankProfile implements Cloneable {
         if (secondPhaseRankScoreDropLimit > -Double.MAX_VALUE) {
             return secondPhaseRankScoreDropLimit;
         }
-        return uniquelyInherited(p -> p.getSecondPhaseRankScoreDropLimit(), c -> c > -Double.MAX_VALUE, "second-phase rank-score-drop-limit")
+        return uniquelyInherited(RankProfile::getSecondPhaseRankScoreDropLimit, c -> c > -Double.MAX_VALUE, "second-phase rank-score-drop-limit")
                 .orElse(secondPhaseRankScoreDropLimit);
     }
 
@@ -964,7 +967,7 @@ public class RankProfile implements Cloneable {
     }
 
     private boolean needToUpdateFunctionCache() {
-        if (inherited().stream().anyMatch(profile -> profile.needToUpdateFunctionCache())) return true;
+        if (inherited().stream().anyMatch(RankProfile::needToUpdateFunctionCache)) return true;
         return allFunctionsCached == null;
     }
 
@@ -972,7 +975,7 @@ public class RankProfile implements Cloneable {
 
     /** Returns all filter fields in this profile and any profile it inherits. */
     public Set<String> allFilterFields() {
-        Set<String> inheritedFilterFields = uniquelyInherited(p -> p.allFilterFields(), fields -> ! fields.isEmpty(),
+        Set<String> inheritedFilterFields = uniquelyInherited(RankProfile::allFilterFields, fields -> ! fields.isEmpty(),
                                                               "filter fields").orElse(Set.of());
 
         if (inheritedFilterFields.isEmpty()) return Collections.unmodifiableSet(filterFields);
@@ -983,7 +986,7 @@ public class RankProfile implements Cloneable {
     }
 
     private ExpressionFunction parseRankingExpression(String name, List<String> arguments, String expression) throws ParseException {
-        if (expression.trim().length() == 0)
+        if (expression.trim().isEmpty())
             throw new ParseException("Encountered an empty ranking expression in " + name() + ", " + name + ".");
 
         try (Reader rankingExpressionReader = openRankingExpressionReader(name, expression.trim())) {
@@ -1207,7 +1210,7 @@ public class RankProfile implements Cloneable {
 
     private Map<Reference, TensorType> featureTypes() {
         Map<Reference, TensorType> featureTypes = inputs().values().stream()
-                .collect(Collectors.toMap(input -> input.name(),
+                .collect(Collectors.toMap(Input::name,
                                           input -> input.type().tensorType()));
         allFields().forEach(field -> addAttributeFeatureTypes(field, featureTypes));
         allImportedFields().forEach(field -> addAttributeFeatureTypes(field, featureTypes));
@@ -1701,7 +1704,7 @@ public class RankProfile implements Cloneable {
 
     }
 
-    public static record RankFeatureNormalizer(Reference original, String name, String input, String algo, double kparam) {
+    public record RankFeatureNormalizer(Reference original, String name, String input, String algo, double kparam) {
         @Override
         public String toString() {
             return "normalizer{name=" + name + ",input=" + input + ",algo=" + algo + ",k=" + kparam + "}";
@@ -1722,7 +1725,7 @@ public class RankProfile implements Cloneable {
         }
     }
 
-    private List<RankFeatureNormalizer> featureNormalizers = new ArrayList<>();
+    private final List<RankFeatureNormalizer> featureNormalizers = new ArrayList<>();
 
     public Map<String, RankFeatureNormalizer> getFeatureNormalizers() {
         Map<String, RankFeatureNormalizer> all = new LinkedHashMap<>();