import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
@Override
protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {

  if (node instanceof WildcardQueryNode) {
    WildcardQueryNode wildcardNode = (WildcardQueryNode) node;

    if (wildcardNode.getText().length() > 0) {
      
      // Validate if the wildcard was escaped
      if (UnescapedCharSequence.wasEscaped(wildcardNode.getText(), 0))
        return node;
      
      switch (wildcardNode.getText().charAt(0)) {    
        case '*':
        case '?':
          throw new QueryNodeException(new MessageImpl(
              QueryParserMessages.LEADING_WILDCARD_NOT_ALLOWED, node
                  .toQueryString(new EscapeQuerySyntaxImpl())));    
      }
    }

  }

  return node;

}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
private static NumericType getNumericDataType(Number number) throws QueryNodeException {
  
  if (number instanceof Long) {
    return NumericType.LONG;
  } else if (number instanceof Integer) {
    return NumericType.INT;
  } else if (number instanceof Double) {
    return NumericType.DOUBLE;
  } else if (number instanceof Float) {
    return NumericType.FLOAT;
  } else {
    throw new QueryNodeException(
        new MessageImpl(
            QueryParserMessages.NUMBER_CLASS_NOT_SUPPORTED_BY_NUMERIC_RANGE_QUERY,
            number.getClass()));
  }
  
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * @param clauses
 *          - QueryNode children
 * @param field
 *          - field name
 * @param type
 *          - type of proximity query
 * @param distance
 *          - positive integer that specifies the distance
 * @param inorder
 *          - true, if the tokens should be matched in the order of the
 *          clauses
 */
public ProximityQueryNode(List<QueryNode> clauses, CharSequence field,
    Type type, int distance, boolean inorder) {
  super(clauses);
  setLeaf(false);
  this.proximityType = type;
  this.inorder = inorder;
  this.field = field;
  if (type == Type.NUMBER) {
    if (distance <= 0) {
      throw new QueryNodeError(new MessageImpl(
          QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED, "distance",
          distance));

    } else {
      this.distance = distance;
    }

  }
  clearFields(clauses, field);
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
private static ConfigurationType extractConfType(String qry) throws ParseException {
    if(!StringUtils.hasText(qry)) {
        throw new ParseException(new MessageImpl("EMPTY_QUERY"));
    }
    try {
        if(qry.contains("key.configuration.type:")) {
            qry = qry.substring(qry.indexOf("key.configuration.type:")+"key.configuration.type:".length());
            String[] split = qry.split("\\s");
            if(split.length > 0) {
                return ConfigurationType.fromValue(split[0].toUpperCase());
            }
        }
    } catch(IllegalArgumentException e) {
        throw new ParseException(new MessageImpl("Illegal ConfigurationType"));
    }
    return null;
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
private ExpertRevisionSearchCommand(DirectoryManager.DirectoryPath path, String qry, Configuration configuration)
        throws QueryNodeException {
    super(path, ResultList.ResultType.REVISION);
    setLanguage(extractLanguage(qry));
    Map<String, NumericConfig> nums = new HashMap<>();

    /*StandardQueryParser parser = new StandardQueryParser(getAnalyzer());*/
    StandardQueryParser parser = new StandardQueryParser();
    parser.setAllowLeadingWildcard(true);
    parser.setAnalyzer(getAnalyzer());
    if(!StringUtils.hasText(qry)) {
        throw new ParseException(new MessageImpl("EMPTY_QUERY"));
    }
    query = parser.parse(qry, "general");

    // No matter if we have configuraion or not we'll parse the query twice. This second parsing will add analyzers for known keys like key.id
    // as well as fields found from configuration if configuration is provided
    addAnalyzersAndConfigs(query, nums, configuration);
    parser.setAnalyzer(getAnalyzer());
    parser.setNumericConfigMap(nums);
    query = parser.parse(qry, "general");
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/** Returns the numeric value of the hexadecimal character */
private static final int hexToInt(char c) throws ParseException {
  if ('0' <= c && c <= '9') {
    return c - '0';
  } else if ('a' <= c && c <= 'f') {
    return c - 'a' + 10;
  } else if ('A' <= c && c <= 'F') {
    return c - 'A' + 10;
  } else {
    throw new ParseException(new MessageImpl(
        QueryParserMessages.INVALID_SYNTAX_ESCAPE_NONE_HEX_UNICODE, c));
  }
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * This constructor is used by the method "generateParseException"
 * in the generated parser.  Calling this constructor generates
 * a new object of this type with the fields "currentToken",
 * "expectedTokenSequences", and "tokenImage" set.
 */
public ParseException(Token currentTokenVal,
   int[][] expectedTokenSequencesVal, String[] tokenImageVal) {
   super(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, initialise(
   currentTokenVal, expectedTokenSequencesVal, tokenImageVal)));
   this.currentToken = currentTokenVal;
   this.expectedTokenSequences = expectedTokenSequencesVal;
   this.tokenImage = tokenImageVal;
 }
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
@Override
public MatchAllDocsQuery build(QueryNode queryNode) throws QueryNodeException {

  // validates node
  if (!(queryNode instanceof MatchAllDocsQueryNode)) {
    throw new QueryNodeException(new MessageImpl(
        QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode
            .toQueryString(new EscapeQuerySyntaxImpl()), queryNode.getClass()
            .getName()));
  }

  return new MatchAllDocsQuery();

}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
@Override
public BooleanQuery build(QueryNode queryNode) throws QueryNodeException {

  // validates node
  if (!(queryNode instanceof MatchNoDocsQueryNode)) {
    throw new QueryNodeException(new MessageImpl(
        QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, queryNode
            .toQueryString(new EscapeQuerySyntaxImpl()), queryNode.getClass()
            .getName()));
  }

  return new BooleanQuery();

}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * Constructs a boost node
 * 
 * @param query
 *          the query to be boosted
 * @param value
 *          the boost value, it may vary from 0.0 to 1.0
 */
public BoostQueryNode(QueryNode query, float value) {
  if (query == null) {
    throw new QueryNodeError(new MessageImpl(
        QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));
  }

  this.value = value;
  setLeaf(false);
  allocate();
  add(query);
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * Used to store the modifier value on the original query string
 * 
 * @param query
 *          - QueryNode subtree
 * @param mod
 *          - Modifier Value
 */
public ModifierQueryNode(QueryNode query, Modifier mod) {
  if (query == null) {
    throw new QueryNodeError(new MessageImpl(
        QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED, "query", "null"));
  }

  allocate();
  setLeaf(false);
  add(query);
  this.modifier = mod;
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * @exception QueryNodeError throw in overridden method to disallow
 */
public PhraseSlopQueryNode(QueryNode query, int value) {
  if (query == null) {
    throw new QueryNodeError(new MessageImpl(
        QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));
  }

  this.value = value;
  setLeaf(false);
  allocate();
  add(query);
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * This QueryNode is used to identify parenthesis on the original query string
 */
public GroupQueryNode(QueryNode query) {
  if (query == null) {
    throw new QueryNodeError(new MessageImpl(
        QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED, "query", "null"));
  }

  allocate();
  setLeaf(false);
  add(query);
}
 

import org.apache.lucene.queryparser.flexible.messages.MessageImpl; //导入依赖的package包/类
/**
 * @param query
 *          - QueryNode Tree with the phrase
 * @param value
 *          - slop value
 */
public SlopQueryNode(QueryNode query, int value) {
  if (query == null) {
    throw new QueryNodeError(new MessageImpl(
        QueryParserMessages.NODE_ACTION_NOT_SUPPORTED, "query", "null"));
  }

  this.value = value;
  setLeaf(false);
  allocate();
  add(query);
}