How to use

QueryTree

in

com.yahoo.search.query

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));
}

protected final Item simplifyUnnecessaryComposites(Item item) {
  if (item == null) return null;
  QueryTree root = new QueryTree(item);
  QueryCanonicalizer.canonicalize(root);
  return root.getRoot() instanceof NullItem ? null : root.getRoot();
}

@Override
public Object clone() {
  try {
    Model clone = (Model)super.clone();
    if (queryTree != null)
      clone.queryTree = this.queryTree.clone();
    if (sources != null)
      clone.sources = new LinkedHashSet<>(this.sources);
    if (restrict != null)
      clone.restrict = new LinkedHashSet<>(this.restrict);
    return clone;
  }
  catch (CloneNotSupportedException e) {
    throw new RuntimeException("Someone inserted a noncloneable superclass", e);
  }
}

/** Returns the query root. This is null if this is a null query. */
public Item getRoot() {
  if (getItemCount() == 0) return null;
  return getItem(0);
}

/** Returns true if this represents the null query */
public boolean isEmpty() {
  return getRoot() instanceof NullItem || getItemCount() == 0;
}

public void setIndexName(String index) {
  if (getRoot() != null)
    getRoot().setIndexName(index);
}

/** Modifies this query to become the current query AND the given item */
// TODO: Make sure this is complete, unit test and make it public
private void and(Item item) {
  if (isEmpty()) {
    setRoot(item);
  }
  else if (getRoot() instanceof NotItem && item instanceof NotItem) {
    throw new IllegalArgumentException("Can't AND two NOTs"); // TODO: Complete
  }
  else if (getRoot() instanceof NotItem){
    NotItem notItem = (NotItem)getRoot();
    notItem.addPositiveItem(item);
  }
  else if (item instanceof NotItem){
    NotItem notItem = (NotItem)item;
    notItem.addPositiveItem(getRoot());
    setRoot(notItem);
  }
  else {
    AndItem andItem = new AndItem();
    andItem.addItem(getRoot());
    andItem.addItem(item);
    setRoot(andItem);
  }
}

public QueryTree(Item root) {
  setRoot(root);
}

private String queryTreeText() {
  QueryTree root = getModel().getQueryTree();
  if (getTraceLevel() < 2)
    return root.toString();
  if (getTraceLevel() < 6)
    return yqlRepresentation();
  else
    return "\n" + yqlRepresentation() + "\n" + new TextualQueryRepresentation(root.getRoot()) + "\n";
}

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
}

/**
 * Canonicalize this query
 * 
 * @return null if the query is valid, an error message if it is invalid
 */
public static String canonicalize(QueryTree query) {
  ListIterator<Item> rootItemIterator = query.getItemIterator();
  CanonicalizationResult result = recursivelyCanonicalize(rootItemIterator.next(), rootItemIterator);
  if (query.isEmpty() && ! result.isError()) result = CanonicalizationResult.error("No query");
  return result.error().orElse(null); // preserve old API, unfortunately
}

@Override
public QueryTree parse(Parsable query) {
  Item root = parse(query.getQuery(), null, null, null, null, null);
  if (root == null) {
    root = new NullItem();
  }
  return new QueryTree(root);
}

/** Returns a deep copy of this */
@Override
public QueryTree clone() {
  QueryTree clone = (QueryTree) super.clone();
  fixClonedConnectivityReferences(clone);
  return clone;
}

/**
 * Encodes this query onto the given buffer
 *
 * @param buffer The buffer to encode the query to
 * @return the number of encoded items
 */
public int encode(ByteBuffer buffer) {
  return model.getQueryTree().encode(buffer);
}

@Override
public void addItem(Item item) {
  if (getItemCount()==0)
    super.addItem(item);
  else
    throw new RuntimeException("Programming error: Cannot add multiple roots");
}

public int encode(ByteBuffer buffer) {
  if (getRoot() == null) return 0;
  return getRoot().encode(buffer);
}

static public void andQueryItemWithRoot(QueryTree tree, Item item) {
  if (tree.isEmpty()) {
    tree.setRoot(item);
  } else {
    Item oldRoot = tree.getRoot();
    if (oldRoot.getClass() == AndItem.class) {
      ((AndItem) oldRoot).addItem(item);
    } else {
      AndItem newRoot = new AndItem();
      newRoot.addItem(oldRoot);
      newRoot.addItem(item);
      tree.setRoot(newRoot);
    }
  }
}

private void insertMutableInTree(CompositeItem mutable, CompositeItem original, CompositeItem parent) {
  if (parent == null) {
    query.getModel().getQueryTree().setRoot(mutable);
  } else {
    int parentsIndex = parent.getItemIndex(original);
    parent.setItem(parentsIndex, mutable);
  }
}

@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() + "'");
}

@NonNull
private QueryTree buildTree(OperatorNode<?> filterPart) {
  Preconditions.checkArgument(filterPart.getArguments().length == 2,
                "Expected 2 arguments to filter, got %s.",
                filterPart.getArguments().length);
  populateYqlSources(filterPart.<OperatorNode<?>> getArgument(0));
  OperatorNode<ExpressionOperator> filterExpression = filterPart.getArgument(1);
  Item root = convertExpression(filterExpression);
  connectItems();
  userQuery = null;
  return new QueryTree(root);
}