@Override WordItem newTermItem(String word) { return new WordItem(word); }
/** Creates a phrase containing the given words */ public PhraseItem(String[] words) { for (int i = 0; i < words.length; i++) { addIndexedItem(new WordItem(words[i])); } }
private boolean syntheticLowerCaseCheck(String indexName, IndexFacts.Session indexFacts, boolean isFromQuery) { WordItem w = new WordItem("not-used", indexName, isFromQuery); return shouldLowercase(w, indexFacts); }
/** Returns a new item representing this match */ public Item toItem(String label) { return new WordItem(getReplaceValue(),label); }
private WordItem singleStemSegment(Item blockAsItem, String stem, String indexName, Substring substring) { WordItem replacement = new WordItem(stem, indexName, true, substring); replacement.setStemmed(true); copyAttributes(blockAsItem, replacement); return replacement; }
/** * Add custom highlight term * * @param field Field name * @param item Term to be highlighted */ public void addHighlightTerm(String field, String item) { addHighlightItem(field, new WordItem(toLowerCase(item), field, true)); }
private CompositeItem populate(CompositeItem parent, String fieldName, Map<String,Integer> tokens) { for (Map.Entry<String,Integer> entry : tokens.entrySet()) { WordItem wordItem = new WordItem(entry.getKey(), fieldName); wordItem.setWeight(entry.getValue()); wordItem.setStemmed(true); wordItem.setNormalizable(false); parent.addItem(wordItem); } return parent; }
@Override public void disclose(Discloser discloser) { super.disclose(discloser); discloser.addProperty("index", indexName); for (Map.Entry<Object, Integer> entry : set.entrySet()) { WordItem subitem = new WordItem(entry.getKey().toString(), indexName); subitem.setWeight(entry.getValue()); discloser.addChild(subitem); } }
/** * create an EQUIV with the given item and a set * of alternate words as children. * The new EQUIV will take connectivity, * significance and weight from the given item. * * @param item Will be modified and added as a child. * @param words Set of words to create WordItems from. **/ public EquivItem(Item item, Collection<String> words) { this(item); String idx = ((IndexedItem)item).getIndexName(); for (String word : words) { WordItem witem = new WordItem(word, idx); addItem(witem); } } }
private IndexedItem convertIntToWord(Item orig) { IntItem o = (IntItem) orig; return new WordItem(o.stringValue(), o.getIndexName(), o.isFromQuery()); }
private void addAndItem(QueryTree q, String term) { Item root = q.getRoot(); CompositeItem compositeRoot; if (root instanceof AndItem) { compositeRoot = (CompositeItem) root; } else { compositeRoot = new AndItem(); compositeRoot.addItem(root); q.setRoot(compositeRoot); } compositeRoot.addItem(new WordItem(term)); }
/** * Add custom highlight phrase * @param field Field name * @param phrase List of terms to be highlighted as a phrase */ public void addHighlightPhrase(String field, List<String> phrase) { PhraseItem pi = new PhraseItem(); pi.setIndexName(field); for (String s : phrase) { pi.addItem(new WordItem(toLowerCase(s), field, true)); } addHighlightItem(field, pi); }
private void addLiterals(RankItem rankTerms, Item item, IndexFacts.Session indexFacts) { if (item == null) return; if (item instanceof NotItem) { addLiterals(rankTerms, ((NotItem) item).getPositiveItem(), indexFacts); } else if (item instanceof CompositeItem) { for (Iterator<Item> i = ((CompositeItem)item).getItemIterator(); i.hasNext(); ) addLiterals(rankTerms, i.next(), indexFacts); } else if (item instanceof TermItem) { TermItem termItem = (TermItem)item; Index index = indexFacts.getIndex(termItem.getIndexName()); if (index.getLiteralBoost()) rankTerms.addItem(new WordItem(toLowerCase(termItem.getRawWord()), index.getName() + "_literal")); } }
private Hit retrieveUserProfile(String userId, Execution execution) { Query query = new Query(); query.getModel().setRestrict("user"); query.getModel().getQueryTree().setRoot(new WordItem(userId, "user_id")); query.setHits(1); SearchChain vespaChain = execution.searchChainRegistry().getComponent("vespa"); Result result = new Execution(vespaChain, execution.context()).search(query); execution.fill(result); // This is needed to get the actual summary data Iterator<Hit> hiterator = result.hits().deepIterator(); return hiterator.hasNext() ? hiterator.next() : null; }
@NonNull private Item instantiateEquivItem(String field, String key, Inspector value) { HashMap<Integer, Inspector> children = getChildrenMap(value); Preconditions.checkArgument(children.size() >= 2, "Expected 2 or more arguments, got %s.", children.size()); EquivItem equiv = new EquivItem(); equiv.setIndexName(field); for (Inspector word : children.values()){ if (word.type() == STRING || word.type() == LONG || word.type() == DOUBLE){ equiv.addItem(new WordItem(word.asString(), field)); } if (word.type() == OBJECT){ word.traverse((ObjectTraverser) (key2, value2) -> { assertHasOperator(key2, PHRASE); equiv.addItem(instantiatePhraseItem(field, key2, value2)); }); } } return leafStyleSettings(getAnnotations(value), equiv); }
@NonNull private Item instantiateONearItem(String field, String key, Inspector value) { assertHasOperator(key, ONEAR); NearItem onear = new ONearItem(); onear.setIndexName(field); HashMap<Integer, Inspector> children = getChildrenMap(value); for (Inspector word : children.values()){ onear.addItem(new WordItem(word.asString(), field)); } Integer distance = getIntegerAnnotation(DISTANCE, getAnnotationMap(value), null); if (distance != null) { onear.setDistance(distance); } return onear; }
@NonNull private Item instantiateNearItem(String field, String key, Inspector value) { assertHasOperator(key, NEAR); NearItem near = new NearItem(); near.setIndexName(field); HashMap<Integer, Inspector> children = getChildrenMap(value); for (Inspector word : children.values()){ near.addItem(new WordItem(word.asString(), field)); } Integer distance = getIntegerAnnotation(DISTANCE, getAnnotationMap(value), null); if (distance != null) { near.setDistance((int)distance); } return near; }
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); } else { newItem.setWeight(getWeight()); if (e.getTraceLevel()>=6) e.trace(6,"Adding '" + newItem + "'"); e.addItem(newItem,getTermType()); } }
@NonNull private Item instantiatePhraseItem(String field, String key, Inspector value) { assertHasOperator(key, PHRASE); PhraseItem phrase = new PhraseItem(); phrase.setIndexName(field); HashMap<Integer, Inspector> children = getChildrenMap(value); for (Inspector word : children.values()) { if (word.type() == STRING) phrase.addItem(new WordItem(word.asString())); else if (word.type() == OBJECT && word.field(PHRASE).valid()) phrase.addItem(instantiatePhraseItem(field, key, getChildren(word))); } return leafStyleSettings(getAnnotations(value), phrase); }
public void produce(RuleEvaluation e,int offset) { 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); } else { newPhrase.setWeight(getWeight()); if (e.getTraceLevel()>=6) e.trace(6,"Adding '" + newPhrase + "'"); e.addItem(newPhrase,getTermType()); } }