/** * Adds an item. The first item is the positive * the rest is negative */ public void addItem(Item item) { super.addItem(item); }
public void addItem(Item item) { if (locked) { dontAdd(); } super.addItem(item); }
public void addItem(int index, Item item) { if (locked) { dontAdd(); } super.addItem(index, item); }
@Override public void addItem(Item item) { if (getItemCount()==0) super.addItem(item); else throw new RuntimeException("Programming error: Cannot add multiple roots"); }
public final void setRoot(Item root) { if (root == this) throw new IllegalArgumentException("Cannot make a root point at itself"); if (root == null) throw new IllegalArgumentException("Root must not be null, use NullItem instead."); if (root instanceof QueryTree) throw new IllegalArgumentException("Do not use a new QueryTree instance as a root."); if (this.getItemCount() == 0) // initializing super.addItem(root); else setItem(0,root); // replacing }
@Override public void addItem(int index, Item item) { if (getItemCount()==0 && index==0) super.addItem(index,item); else throw new RuntimeException("Programming error: Cannot add multiple roots, have '" + getRoot() + "'"); }
protected void addChildren(T item, ItemArguments arguments, ItemContext itemContext) { for (Object child : arguments.children) { item.addItem(asItem(child)); } ItemInitializer.initialize(item, arguments, itemContext); }
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)); }
CompositeItem combined=createType(termType); if (combined.getClass().equals(composite.getClass())) { composite.addItem(second); return composite; combined.addItem(first); combined.addItem(second); // Also works for nots return combined; combined.addItem(first); combined.addItem(second); return combined;
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; }
private void addItem(CompositeItem parent,int index,Item item,TermType desiredParentType) { if (parent instanceof NotItem) { if (index==0 && parent.getItem(0)==null) { // Case 1: The current positive is null and we are adding a positive 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(); positiveComposite.addItem(parent.getItem(0)); 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); } else { // Case 4: Add negative parent.addItem(index,item); } } 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); } else { parent.addItem(index,item); } }
/** * Convert segment items into their mutable counterpart, do not update query tree. * Non-segment items are returned directly. * * @return a mutable CompositeItem instance */ private CompositeItem convertSegmentItem(CompositeItem item) { if (!(item instanceof SegmentItem)) { return item; } CompositeItem converted = null; if (item instanceof AndSegmentItem) { converted = new AndItem(); } else if (item instanceof PhraseSegmentItem) { PhraseItem p = new PhraseItem(); PhraseSegmentItem old = (PhraseSegmentItem) item; p.setIndexName(old.getIndexName()); converted = p; } else { // TODO: Do something else than nothing for unknowns? return item; } for (Iterator<Item> i = item.getItemIterator(); i.hasNext();) { converted.addItem(i.next()); } return converted; }
private void addItemsFromInspector(CompositeItem item, Inspector inspector){ if (inspector.type() == ARRAY){ inspector.traverse((ArrayTraverser) (index, new_value) -> { item.addItem(walkJson(new_value)); }); } else if (inspector.type() == OBJECT){ if (inspector.field("children").valid()){ inspector.field("children").traverse((ArrayTraverser) (index, new_value) -> { item.addItem(walkJson(new_value)); }); } } }
@NonNull private CompositeItem convertVarArgs(OperatorNode<ExpressionOperator> ast, int argIdx, @NonNull CompositeItem out) { Iterable<OperatorNode<ExpressionOperator>> args = ast.getArgument(argIdx); for (OperatorNode<ExpressionOperator> arg : args) { assertHasOperator(arg, ExpressionOperator.class); out.addItem(convertExpression(arg)); } return out; }
private void insertIncompatibleItem(Item item,CompositeItem parent,Query query,TermType desiredParentType) { // Create new parent CompositeItem newParent; if (desiredParentType==TermType.DEFAULT) newParent=new AndItem(); else newParent=(CompositeItem)desiredParentType.createItemClass(); // Save previous parent parent 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) { query.getModel().getQueryTree().setRoot(newParent); } else { int parentIndex=0; if (parentsParent!=null) { parentIndex=parentsParent.getItemIndex(parent); } parentsParent.setItem(parentIndex,newParent); } }
/** * Splits the given item into n-grams and adds them as a CompositeItem containing WordItems searching the * index of the input term. If the result is a single gram, that single WordItem is returned rather than the AndItem * * @param term the term to split, must be an item which implement the IndexedItem and BlockItem "mixins" * @param text the text of the item, just stringValue() if the item is a TermItem * @param gramSize the gram size to split to * @param query the query in which this rewriting is done * @return the root of the query subtree produced by this, containing the split items */ protected Item splitToGrams(Item term, String text, int gramSize, Query query) { String index = ((HasIndexItem)term).getIndexName(); CompositeItem gramsItem = createGramRoot(query); gramsItem.setIndexName(index); Substring origin = ((BlockItem)term).getOrigin(); for (Iterator<GramSplitter.Gram> i = getGramSplitter().split(text,gramSize); i.hasNext(); ) { GramSplitter.Gram gram = i.next(); WordItem gramWord = new WordItem(gram.extractFrom(text), index, false, origin); gramWord.setWeight(term.getWeight()); gramWord.setProtected(true); gramsItem.addItem(gramWord); } return gramsItem.getItemCount()==1 ? gramsItem.getItem(0) : gramsItem; // return the AndItem, or just the single gram if not multiple }
w.setSegmentIndex(n++); w.setStemmed(false); composite.addItem(w);
setSignificance(w, current); composite.addItem((Item) w);
} else if (topLevelItem instanceof CompositeItem && !(topLevelItem instanceof SegmentItem)) { ((CompositeItem) topLevelItem).addItem(item); expectingOperator = true; } else {