protected override IQueryNode PostProcessNode(IQueryNode node)
{
if (node is BooleanQueryNode)
{
IList <IQueryNode> children = node.GetChildren();
if (children != null && children.Count == 1)
{
IQueryNode child = children[0];
if (child is ModifierQueryNode)
{
ModifierQueryNode modNode = (ModifierQueryNode)child;
if (modNode is BooleanModifierNode ||
modNode.Modifier == Modifier.MOD_NONE)
{
return(child);
}
}
else
{
return(child);
}
}
}
return(node);
}
public virtual Query Build(IQueryNode queryNode)
{
ModifierQueryNode modifierNode = (ModifierQueryNode)queryNode;
return((Query)(modifierNode).GetChild().GetTag(
QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID));
}
private IQueryNode ApplyModifier(IQueryNode node, IQueryNode parent)
{
if (this.usingAnd)
{
if (parent is OrQueryNode)
{
if (node is ModifierQueryNode)
{
ModifierQueryNode modNode = (ModifierQueryNode)node;
if (modNode.Modifier == Modifier.MOD_REQ)
{
return(modNode.GetChild());
}
}
}
else
{
if (node is ModifierQueryNode)
{
ModifierQueryNode modNode = (ModifierQueryNode)node;
if (modNode.Modifier == Modifier.MOD_NONE)
{
return(new BooleanModifierNode(modNode.GetChild(), Modifier.MOD_REQ));
}
}
else
{
return(new BooleanModifierNode(node, Modifier.MOD_REQ));
}
}
}
else
{
if (node.Parent is AndQueryNode)
{
if (node is ModifierQueryNode)
{
ModifierQueryNode modNode = (ModifierQueryNode)node;
if (modNode.Modifier == Modifier.MOD_NONE)
{
return(new BooleanModifierNode(modNode.GetChild(), Modifier.MOD_REQ));
}
}
else
{
return(new BooleanModifierNode(node, Modifier.MOD_REQ));
}
}
}
return(node);
}
protected virtual void TagModifierButDoNotOverride(IQueryNode node, Modifier mod)
{
if (node is ModifierQueryNode)
{
ModifierQueryNode modNode = (ModifierQueryNode)node;
if (modNode.Modifier == Modifier.MOD_NONE)
{
node.SetTag(TAG_MODIFIER, mod);
}
}
else
{
node.SetTag(TAG_MODIFIER, Modifier.MOD_REQ);
}
}
// QueryNode Query(CharSequence field) :
// {
// List clauses = new ArrayList();
// List modifiers = new ArrayList();
// QueryNode q, firstQuery=null;
// ModifierQueryNode.Modifier mods;
// int conj;
// }
// {
// mods=Modifiers() q=Clause(field)
// {
// if (mods == ModifierQueryNode.Modifier.MOD_NONE) firstQuery=q;
//
// // do not create modifier nodes with MOD_NONE
// if (mods != ModifierQueryNode.Modifier.MOD_NONE) {
// q = new ModifierQueryNode(q, mods);
// }
// clauses.add(q);
// }
// (
// conj=Conjunction() mods=Modifiers() q=Clause(field)
// {
// // do not create modifier nodes with MOD_NONE
// if (mods != ModifierQueryNode.Modifier.MOD_NONE) {
// q = new ModifierQueryNode(q, mods);
// }
// clauses.add(q);
// //TODO: figure out what to do with AND and ORs
// }
// )*
// {
// if (clauses.size() == 1 && firstQuery != null)
// return firstQuery;
// else {
// return new BooleanQueryNode(clauses);
// }
// }
// }
public IQueryNode ModClause(string field)
{
IQueryNode q;
Modifier mods;
mods = Modifiers();
q = Clause(field);
if (mods != Modifier.MOD_NONE)
{
q = new ModifierQueryNode(q, mods);
}
{ if (true)
{
return(q);
}
}
throw new Exception("Missing return statement in function");
}
private IQueryNode ApplyModifier(IQueryNode node, Modifier mod)
{
// check if modifier is not already defined and is default
if (!(node is ModifierQueryNode))
{
return(new ModifierQueryNode(node, mod));
}
else
{
ModifierQueryNode modNode = (ModifierQueryNode)node;
if (modNode.Modifier == Modifier.MOD_NONE)
{
return(new ModifierQueryNode(modNode.GetChild(), mod));
}
}
return(node);
}
private static Occur GetModifierValue(IQueryNode node)
{
if (node is ModifierQueryNode)
{
ModifierQueryNode mNode = ((ModifierQueryNode)node);
switch (mNode.Modifier)
{
case Modifier.MOD_REQ:
return(Occur.MUST);
case Modifier.MOD_NOT:
return(Occur.MUST_NOT);
case Modifier.MOD_NONE:
return(Occur.SHOULD);
}
}
return(Occur.SHOULD);
}
private static BooleanClause.Occur GetModifierValue(IQueryNode node)
{
if (node is ModifierQueryNode)
{
ModifierQueryNode mNode = ((ModifierQueryNode)node);
Modifier modifier = mNode.Modifier;
if (Modifier.MOD_NONE.Equals(modifier))
{
return(BooleanClause.Occur.SHOULD);
}
else if (Modifier.MOD_NOT.Equals(modifier))
{
return(BooleanClause.Occur.MUST_NOT);
}
else
{
return(BooleanClause.Occur.MUST);
}
}
return(BooleanClause.Occur.SHOULD);
}