From 830958254079b56705a207bc47f4f013fa10868c Mon Sep 17 00:00:00 2001 From: Jon Bratseth Date: Fri, 26 Mar 2021 07:56:44 +0100 Subject: Cleanup: No functional changes --- .../yahoo/prelude/semantics/engine/Evaluation.java | 59 +++++++++++----------- .../com/yahoo/prelude/semantics/engine/Match.java | 30 ++++++----- .../semantics/engine/ReferencedMatches.java | 14 ++--- .../semantics/rule/LiteralPhraseProduction.java | 18 +++---- .../semantics/rule/LiteralTermProduction.java | 20 ++++---- .../semantics/rule/ReferenceTermProduction.java | 34 ++++++------- .../prelude/semantics/rule/TermProduction.java | 15 +++--- 7 files changed, 96 insertions(+), 94 deletions(-) (limited to 'container-search') diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Evaluation.java b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Evaluation.java index b1b317379ff..07342a48916 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Evaluation.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Evaluation.java @@ -246,13 +246,12 @@ public class Evaluation { public void insertItem(Item item, CompositeItem parent, int index, TermType desiredParentType) { if (parent == null) { // TODO: Accommodate for termtype in this case too query.getModel().getQueryTree().setRoot(item); - return; } if (parent.getItemCount()>0 && parent instanceof QueryTree && parent.getItem(0) instanceof CompositeItem) { // combine with the existing root instead - parent=(CompositeItem)parent.getItem(0); + parent = (CompositeItem)parent.getItem(0); if (index == 1) { // that means adding it after the existing root index = parent.getItemCount(); } @@ -260,7 +259,7 @@ public class Evaluation { if (( desiredParentType == TermType.DEFAULT || desiredParentType.hasItemClass(parent.getClass()) ) && equalIndexNameIfParentIsPhrase(item, parent)) { - addItem(parent,index,item,desiredParentType); + addItem(parent, index, item, desiredParentType); } else { insertIncompatibleItem(item, parent, query, desiredParentType); @@ -273,27 +272,27 @@ public class Evaluation { parent.setItem(0, item); } else if (index<=1 && !(parent.getItem(0) instanceof CompositeItem)) { // Case 2: The positive must become a composite - CompositeItem positiveComposite=(CompositeItem)desiredParentType.createItemClass(); + CompositeItem positiveComposite = (CompositeItem)desiredParentType.createItemClass(); positiveComposite.addItem(parent.getItem(0)); - positiveComposite.addItem(index,item); - parent.setItem(0,positiveComposite); + positiveComposite.addItem(index, item); + parent.setItem(0, positiveComposite); } else if (parent.getItem(0)!=null && parent.getItem(0) instanceof CompositeItem // Case 3: Add to the positive composite - && index<=((CompositeItem)parent.getItem(0)).getItemCount()) { - ((CompositeItem)parent.getItem(0)).addItem(index,item); + && index <= ((CompositeItem)parent.getItem(0)).getItemCount()) { + ((CompositeItem)parent.getItem(0)).addItem(index, item); } else { // Case 4: Add negative - parent.addItem(index,item); + parent.addItem(index, item); } } - else if (parent.getItemCount()>0 && parent instanceof QueryTree) { - CompositeItem composite=(CompositeItem)desiredParentType.createItemClass(); + else if (parent.getItemCount() > 0 && parent instanceof QueryTree) { + CompositeItem composite = (CompositeItem)desiredParentType.createItemClass(); composite.addItem(parent.getItem(0)); - composite.addItem(index,item); - parent.setItem(0,composite); + composite.addItem(index, item); + parent.setItem(0, composite); } else { - parent.addItem(index,item); + parent.addItem(index, item); } } @@ -305,32 +304,32 @@ public class Evaluation { return ((PhraseItem)parent).getIndexName().equals(((IndexedItem)item).getIndexName()); } - private void insertIncompatibleItem(Item item,CompositeItem parent,Query query,TermType desiredParentType) { + private void insertIncompatibleItem(Item item, CompositeItem parent, Query query, TermType desiredParentType) { // Create new parent CompositeItem newParent; - if (desiredParentType==TermType.DEFAULT) - newParent=new AndItem(); + if (desiredParentType == TermType.DEFAULT) + newParent = new AndItem(); else - newParent=(CompositeItem)desiredParentType.createItemClass(); + newParent = (CompositeItem)desiredParentType.createItemClass(); // Save previous parent parent - CompositeItem parentsParent=parent.getParent(); + CompositeItem parentsParent = parent.getParent(); // Add items to new parent newParent.addItem(parent); newParent.addItem(item); // Insert new parent as root or child of old parents parent - if (parentsParent==null) { + if (parentsParent == null) { query.getModel().getQueryTree().setRoot(newParent); } else { - int parentIndex=0; - if (parentsParent!=null) { - parentIndex=parentsParent.getItemIndex(parent); + int parentIndex = 0; + if (parentsParent != null) { + parentIndex = parentsParent.getItemIndex(parent); } - parentsParent.setItem(parentIndex,newParent); + parentsParent.setItem(parentIndex, newParent); } } @@ -338,19 +337,19 @@ public class Evaluation { if (first instanceof NullItem) { return second; } else if (first instanceof NotItem) { - NotItem notItem=(NotItem)first; - if (termType==TermType.NOT) { + NotItem notItem = (NotItem)first; + if (termType == TermType.NOT) { notItem.addNegativeItem(second); } else { - Item newPositive=combineItems(notItem.getPositiveItem(),second,termType); + Item newPositive = combineItems(notItem.getPositiveItem(), second, termType); notItem.setPositiveItem(newPositive); } return notItem; } else if (first instanceof CompositeItem) { - CompositeItem composite=(CompositeItem)first; - CompositeItem combined=createType(termType); + CompositeItem composite = (CompositeItem)first; + CompositeItem combined = createType(termType); if (combined.getClass().equals(composite.getClass())) { composite.addItem(second); return composite; @@ -362,7 +361,7 @@ public class Evaluation { } } else if (first instanceof TermItem) { - CompositeItem combined=createType(termType); + CompositeItem combined = createType(termType); combined.addItem(first); combined.addItem(second); return combined; diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Match.java b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Match.java index 9e7c761deba..95b53bc5809 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Match.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/Match.java @@ -6,6 +6,8 @@ import com.yahoo.prelude.query.Item; import com.yahoo.prelude.query.TermItem; import com.yahoo.prelude.query.WordItem; +import java.util.Objects; + /** * A match * @@ -14,15 +16,15 @@ import com.yahoo.prelude.query.WordItem; public class Match { /** The start position of this match */ - private int position; + private final int position; - private TermItem item; + private final TermItem item; /** The string to replace the match by, usually item.getIndexedString() */ - private String replaceValue; + private final String replaceValue; /** The parent of the matched item */ - private CompositeItem parent=null; + private final CompositeItem parent; /** * Creates a match @@ -56,23 +58,23 @@ public class Match { */ public CompositeItem getParent() { return parent; } - public int hashCode() { - return - 17*item.getIndexedString().hashCode()+ - 33*item.getIndexName().hashCode(); - } - /** Returns a new item representing this match */ public Item toItem(String label) { - return new WordItem(getReplaceValue(),label); + return new WordItem(getReplaceValue(), label); + } + + @Override + public int hashCode() { + return Objects.hash(item.getIndexedString(), item.getIndexName()); } + @Override public boolean equals(Object o) { if (! (o instanceof Match)) return false; - Match other=(Match)o; - if (other.position!=position) return false; - if (!other.item.equals(item)) return false; + Match other = (Match)o; + if (other.position != position) return false; + if ( ! other.item.equals(item)) return false; return true; } diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/ReferencedMatches.java b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/ReferencedMatches.java index 274528f1fb3..f21f861a801 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/engine/ReferencedMatches.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/engine/ReferencedMatches.java @@ -14,12 +14,12 @@ import com.yahoo.prelude.query.PhraseItem; */ public class ReferencedMatches { - private String contextName; + private final String contextName; - private List matches=new java.util.ArrayList<>(1); + private final List matches = new java.util.ArrayList<>(1); public ReferencedMatches(String contextName) { - this.contextName=contextName; + this.contextName = contextName; } public void addMatch(Match match) { @@ -38,12 +38,12 @@ public class ReferencedMatches { * @param label the label of the matches */ public Item toItem(String label) { - if (matches.size()==0) return null; - if (matches.size()==1) return matches.get(0).toItem(label); + if (matches.size() == 0) return null; + if (matches.size() == 1) return matches.get(0).toItem(label); - PhraseItem phrase=new PhraseItem(); // TODO: Somehow allow AND items instead here + PhraseItem phrase = new PhraseItem(); // TODO: Somehow allow AND items instead here phrase.setIndexName(label); - for (Iterator i=matches.iterator(); i.hasNext(); ) { + for (Iterator i = matches.iterator(); i.hasNext(); ) { phrase.addItem(i.next().toItem(label)); } return phrase; diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralPhraseProduction.java b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralPhraseProduction.java index cad753a570b..d06c4144fbc 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralPhraseProduction.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralPhraseProduction.java @@ -19,7 +19,7 @@ import com.yahoo.protect.Validator; */ public class LiteralPhraseProduction extends TermProduction { - private List terms=new ArrayList<>(); + private final List terms = new ArrayList<>(); /** Creates a new produced literal phrase */ public LiteralPhraseProduction() { @@ -45,20 +45,20 @@ public class LiteralPhraseProduction extends TermProduction { public List getTerms() { return Collections.unmodifiableList(terms); } public void produce(RuleEvaluation e,int offset) { - PhraseItem newPhrase=new PhraseItem(); + PhraseItem newPhrase = new PhraseItem(); newPhrase.setIndexName(getLabel()); for (String term : terms) newPhrase.addItem(new WordItem(term)); if (replacing) { - Match matched=e.getNonreferencedMatch(0); - insertMatch(e,matched,newPhrase,offset); + Match matched = e.getNonreferencedMatch(0); + insertMatch(e, matched, newPhrase, offset); } else { newPhrase.setWeight(getWeight()); - if (e.getTraceLevel()>=6) - e.trace(6,"Adding '" + newPhrase + "'"); - e.addItem(newPhrase,getTermType()); + if (e.getTraceLevel() >= 6) + e.trace(6, "Adding '" + newPhrase + "'"); + e.addItem(newPhrase, getTermType()); } } @@ -67,8 +67,8 @@ public class LiteralPhraseProduction extends TermProduction { } private String getSpaceSeparated(List terms) { - StringBuilder builder=new StringBuilder(); - for (Iterator i=terms.iterator(); i.hasNext(); ) { + StringBuilder builder = new StringBuilder(); + for (Iterator i = terms.iterator(); i.hasNext(); ) { builder.append(i.next()); if (i.hasNext()) builder.append(" "); diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralTermProduction.java b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralTermProduction.java index 69a4a87c04e..5402d74cc4e 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralTermProduction.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/LiteralTermProduction.java @@ -44,31 +44,31 @@ public class LiteralTermProduction extends TermProduction { * @param literal this term word * @param termType the type of term to produce */ - public LiteralTermProduction(String label,String literal, TermType termType) { - super(label,termType); + public LiteralTermProduction(String label, String literal, TermType termType) { + super(label, termType); setLiteral(literal); } /** The literal term value, never null */ public void setLiteral(String literal) { - Validator.ensureNotNull("A produced term",literal); + Validator.ensureNotNull("A produced term", literal); this.literal=literal; } /** Returns the term word produced, never null */ public String getLiteral() { return literal; } - public void produce(RuleEvaluation e,int offset) { - WordItem newItem=new WordItem(literal,getLabel()); + public void produce(RuleEvaluation e, int offset) { + WordItem newItem = new WordItem(literal, getLabel()); if (replacing) { - Match matched=e.getNonreferencedMatch(0); - insertMatch(e,matched,newItem,offset); + Match matched = e.getNonreferencedMatch(0); + insertMatch(e, matched, newItem, offset); } else { newItem.setWeight(getWeight()); - if (e.getTraceLevel()>=6) - e.trace(6,"Adding '" + newItem + "'"); - e.addItem(newItem,getTermType()); + if (e.getTraceLevel() >= 6) + e.trace(6, "Adding '" + newItem + "'"); + e.addItem(newItem, getTermType()); } } diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/ReferenceTermProduction.java b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/ReferenceTermProduction.java index d4593a5dbb9..e1bb8ff102d 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/ReferenceTermProduction.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/ReferenceTermProduction.java @@ -48,7 +48,7 @@ public class ReferenceTermProduction extends TermProduction { * @param label the label of the produced term * @param reference the label of the condition this should take it's value from */ - public ReferenceTermProduction(String label,String reference) { + public ReferenceTermProduction(String label, String reference) { super(label); setReference(reference); } @@ -60,15 +60,15 @@ public class ReferenceTermProduction extends TermProduction { * @param reference the label of the condition this should take it's value from * @param termType the type of term to produce */ - public ReferenceTermProduction(String label,String reference, TermType termType) { - super(label,termType); + public ReferenceTermProduction(String label, String reference, TermType termType) { + super(label, termType); setReference(reference); } /** The label of the condition this should take its value from, never null */ public void setReference(String reference) { Validator.ensureNotNull("reference name of a produced reference term",reference); - this.reference =reference; + this.reference = reference; } /** Returns the label of the condition this should take its value from, never null */ @@ -78,29 +78,29 @@ public class ReferenceTermProduction extends TermProduction { matchReferences.add(reference); } - public void produce(RuleEvaluation e,int offset) { - ReferencedMatches referencedMatches=e.getReferencedMatches(reference); - if (referencedMatches==null) + public void produce(RuleEvaluation e, int offset) { + ReferencedMatches referencedMatches = e.getReferencedMatches(reference); + if (referencedMatches == null) throw new EvaluationException("Referred match '" + reference + "' not found"); if (replacing) { - replaceMatches(e,referencedMatches); + replaceMatches(e, referencedMatches); } else { - addMatches(e,referencedMatches); + addMatches(e, referencedMatches); } } - public void replaceMatches(RuleEvaluation e,ReferencedMatches referencedMatches) { - Item referencedItem=referencedMatches.toItem(getLabel()); - if (referencedItem==null) return; + public void replaceMatches(RuleEvaluation e, ReferencedMatches referencedMatches) { + Item referencedItem = referencedMatches.toItem(getLabel()); + if (referencedItem == null) return; e.removeMatches(referencedMatches); - insertMatch(e, referencedMatches.matchIterator().next(),referencedItem,0); + insertMatch(e, referencedMatches.matchIterator().next(), referencedItem, 0); } - private void addMatches(RuleEvaluation e,ReferencedMatches referencedMatches) { - Item referencedItem=referencedMatches.toItem(getLabel()); - if (referencedItem==null) return; - e.addItem(referencedItem,getTermType()); + private void addMatches(RuleEvaluation e, ReferencedMatches referencedMatches) { + Item referencedItem = referencedMatches.toItem(getLabel()); + if (referencedItem == null) return; + e.addItem(referencedItem, getTermType()); } public String toInnerTermString() { diff --git a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/TermProduction.java b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/TermProduction.java index 847014ff646..5eff8f8033a 100644 --- a/container-search/src/main/java/com/yahoo/prelude/semantics/rule/TermProduction.java +++ b/container-search/src/main/java/com/yahoo/prelude/semantics/rule/TermProduction.java @@ -51,7 +51,7 @@ public abstract class TermProduction extends Production { /** Sets the term type to produce */ public void setTermType(TermType termType) { - Validator.ensureNotNull("Type of produced Term",termType); + Validator.ensureNotNull("Type of produced Term", termType); this.termType = termType; } @@ -61,18 +61,19 @@ public abstract class TermProduction extends Production { */ protected void insertMatch(RuleEvaluation e, Match matched, Item newItem, int offset) { newItem.setWeight(getWeight()); - int insertPosition=matched.getPosition()+offset; + int insertPosition = matched.getPosition()+offset; // This check is necessary (?) because earlier items may have been removed // after we recorded the match position. It is sort of hackish. A cleaner // solution would be to update the match position on changes - if (insertPosition>matched.getParent().getItemCount()) { - insertPosition=matched.getParent().getItemCount(); + if (insertPosition > matched.getParent().getItemCount()) { + insertPosition = matched.getParent().getItemCount(); } - e.insertItem(newItem,matched.getParent(),insertPosition,getTermType()); - if (e.getTraceLevel()>=6) - e.trace(6,"Inserted item '" + newItem + "' at position " + insertPosition + " producing " + e.getEvaluation().getQuery().getModel().getQueryTree()); + e.insertItem(newItem, matched.getParent(), insertPosition,getTermType()); + if (e.getTraceLevel() >= 6) + e.trace(6, "Inserted item '" + newItem + "' at position " + insertPosition + " producing " + + e.getEvaluation().getQuery().getModel().getQueryTree()); } protected String getLabelString() { -- cgit v1.2.3