import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
/**
 * Sets the lower and upper bounds.
 * 
 * @param lower the lower bound, <code>null</code> if lower bound is open
 * @param upper the upper bound, <code>null</code> if upper bound is open
 * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
 * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
 * 
 * @see #getLowerBound()
 * @see #getUpperBound()
 * @see #isLowerInclusive()
 * @see #isUpperInclusive()
 */
public void setBounds(T lower, T upper, boolean lowerInclusive,
    boolean upperInclusive) {
  
  if (lower != null && upper != null) {
    String lowerField = StringUtils.toString(lower.getField());
    String upperField = StringUtils.toString(upper.getField());
    
    if ((upperField != null || lowerField != null)
        && ((upperField != null && !upperField.equals(lowerField)) || !lowerField
            .equals(upperField))) {
      throw new IllegalArgumentException(
          "lower and upper bounds should have the same field name!");
    }
    
    this.lowerInclusive = lowerInclusive;
    this.upperInclusive = upperInclusive;
    
    ArrayList<QueryNode> children = new ArrayList<>(2);
    children.add(lower);
    children.add(upper);
    
    set(children);
    
  }
  
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
@Override
public TermRangeQuery build(QueryNode queryNode) throws QueryNodeException {
  TermRangeQueryNode rangeNode = (TermRangeQueryNode) queryNode;
  FieldQueryNode upper = rangeNode.getUpperBound();
  FieldQueryNode lower = rangeNode.getLowerBound();
  
  String field = StringUtils.toString(rangeNode.getField());
  String lowerText = lower.getTextAsString();
  String upperText = upper.getTextAsString();
  
  if (lowerText.length() == 0) {
    lowerText = null;
  }
  
  if (upperText.length() == 0) {
    upperText = null;
  }
  
  TermRangeQuery rangeQuery = TermRangeQuery.newStringRange(field, lowerText, upperText, rangeNode
      .isLowerInclusive(), rangeNode.isUpperInclusive());
  
  MultiTermQuery.RewriteMethod method = (MultiTermQuery.RewriteMethod) queryNode
      .getTag(MultiTermRewriteMethodProcessor.TAG_ID);
  if (method != null) {
    rangeQuery.setRewriteMethod(method);
  }
  
  return rangeQuery;
  
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
/**
 * This method is use toQueryString to detect if fld is the default field
 * 
 * @param fld - field name
 * @return true if fld is the default field
 */
// TODO: remove this method, it's commonly used by {@link
// #toQueryString(org.apache.lucene.queryParser.core.parser.EscapeQuerySyntax)}
// to figure out what is the default field, however, {@link
// #toQueryString(org.apache.lucene.queryParser.core.parser.EscapeQuerySyntax)}
// should receive the default field value directly by parameter
protected boolean isDefaultField(CharSequence fld) {
  if (this.toQueryStringIgnoreFields)
    return true;
  if (fld == null)
    return true;
  if (QueryNodeImpl.PLAINTEXT_FIELD_NAME.equals(StringUtils.toString(fld)))
    return true;
  return false;
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
/**
 * Sets the lower and upper bounds.
 * 
 * @param lower the lower bound, <code>null</code> if lower bound is open
 * @param upper the upper bound, <code>null</code> if upper bound is open
 * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
 * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
 * 
 * @see #getLowerBound()
 * @see #getUpperBound()
 * @see #isLowerInclusive()
 * @see #isUpperInclusive()
 */
public void setBounds(T lower, T upper, boolean lowerInclusive,
    boolean upperInclusive) {
  
  if (lower != null && upper != null) {
    String lowerField = StringUtils.toString(lower.getField());
    String upperField = StringUtils.toString(upper.getField());
    
    if ((upperField != null || lowerField != null)
        && ((upperField != null && !upperField.equals(lowerField)) || !lowerField
            .equals(upperField))) {
      throw new IllegalArgumentException(
          "lower and upper bounds should have the same field name!");
    }
    
    this.lowerInclusive = lowerInclusive;
    this.upperInclusive = upperInclusive;
    
    ArrayList<QueryNode> children = new ArrayList<QueryNode>(2);
    children.add(lower);
    children.add(upper);
    
    set(children);
    
  }
  
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
public Query fuzzy(String fieldName, Object value) {
    return new FuzzyQuery(new Term(fieldName, StringUtils.toString(value)));
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
@Override
public NumericRangeQuery<? extends Number> build(QueryNode queryNode)
    throws QueryNodeException {
  NumericRangeQueryNode numericRangeNode = (NumericRangeQueryNode) queryNode;
  
  NumericQueryNode lowerNumericNode = numericRangeNode.getLowerBound();
  NumericQueryNode upperNumericNode = numericRangeNode.getUpperBound();
  
  Number lowerNumber = lowerNumericNode.getValue();
  Number upperNumber = upperNumericNode.getValue();
  
  NumericConfig numericConfig = numericRangeNode.getNumericConfig();
  NumericType numberType = numericConfig.getType();
  String field = StringUtils.toString(numericRangeNode.getField());
  boolean minInclusive = numericRangeNode.isLowerInclusive();
  boolean maxInclusive = numericRangeNode.isUpperInclusive();
  int precisionStep = numericConfig.getPrecisionStep();
  
  switch (numberType) {
    
    case LONG:
      return NumericRangeQuery.newLongRange(field, precisionStep,
          (Long) lowerNumber, (Long) upperNumber, minInclusive, maxInclusive);
    
    case INT:
      return NumericRangeQuery.newIntRange(field, precisionStep,
          (Integer) lowerNumber, (Integer) upperNumber, minInclusive,
          maxInclusive);
    
    case FLOAT:
      return NumericRangeQuery.newFloatRange(field, precisionStep,
          (Float) lowerNumber, (Float) upperNumber, minInclusive,
          maxInclusive);
    
    case DOUBLE:
      return NumericRangeQuery.newDoubleRange(field, precisionStep,
          (Double) lowerNumber, (Double) upperNumber, minInclusive,
          maxInclusive);
      
      default :
        throw new QueryNodeException(new MessageImpl(
          QueryParserMessages.UNSUPPORTED_NUMERIC_DATA_TYPE, numberType));
      
  }
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
public String asDBKey(Operation<?> expr, int index) {
    return StringUtils.toString(asDBValue(expr, index));
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
public static QueryBuilder eq(String key, Object value) {
    return QueryBuilders.queryStringQuery(StringUtils.toString(value)).field(key);
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
public static QueryBuilder eq(String key, Object value) {
    return QueryBuilders.queryString(StringUtils.toString(value)).field(key);
}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
private void purgeOldSnapshots() {
	logger.info("Purging expired snapshot(s) for index(es): {} ", this.snapshotSettings.getIndices());
	// get old snapshots to remove
	GetSnapshotsRequestBuilder getBuilder = new GetSnapshotsRequestBuilder(this.client.admin().cluster(), this.snapshotSettings.getRepository());
	GetSnapshotsResponse getResp = getBuilder.get();

	Set<String> configIndices = getConfiguredIndicesAsSet();
	if (getResp != null && getResp.getSnapshots() != null) {
		ImmutableList<SnapshotInfo> snapshots = getResp.getSnapshots();
		if (snapshots == null || snapshots.isEmpty()) {
			return;
		}

		logger.debug("Found a total of {} snapshots in the repository", snapshots.size());
		List<String> purgeSnapshots = new ArrayList<String>();
		for (Iterator<SnapshotInfo> i = snapshots.iterator(); i.hasNext();) {
			SnapshotInfo snap = i.next();
			logger.debug("This snapshot [{}] includes the following indices: {}", snap.name(), StringUtils.toString(snap.indices()));

			if(this.snapshotSettings.isPurgeIndicesMustMatch()){					
				// if number of indices don't match, do not purge
				if (snap.indices().size() != configIndices.size()) {
					logger.info("Snapshot [{}] not purged. The number of indices in the snapshot ({}) must match the number of indices in the current configuration ({}). To purge all snapshots, configure purge_indices_must_match:false.", snap.name(), snap.indices().size(), configIndices.size());
					continue;
				}

				// if the size matches, verify that the indexes within the snapshot are exactly the same as those
				// configured for the river
				if (!snapshotIndicesMatch(snap, configIndices)) {
					logger.info("Snapshot [{}] not purged. In order to purge a snapshot automatically, the specific indexes must match exactly. The snapshot does not match current purge configuration indices. To purge all snapshots, configure purge_indices_must_match:false.", snap.name());
					continue;
				}
			} 

			// finally check if the snapshot is beyond the purgeAfter age
			Date expiration = new Date(snap.startTime() + this.snapshotSettings.getPurgeAfter().millis());
			if (expiration.before(new Date())) {
				purgeSnapshots.add(snap.name());
			}
		} 

		// remove old snapshots
		logger.debug("{} snapshots are scheduled to be purged.", purgeSnapshots.size());
		for (String snapshotName : purgeSnapshots) {
			DeleteSnapshotRequestBuilder deleteBuilder = new DeleteSnapshotRequestBuilder(this.client.admin().cluster());
			deleteBuilder.setRepository(this.snapshotSettings.getRepository());
			deleteBuilder.setSnapshot(snapshotName);
			DeleteSnapshotResponse deleteResp = deleteBuilder.get();
			if (deleteResp.isAcknowledged()) {
				logger.info("Expired snapshot [{}] has been deleted.", snapshotName);
			} else {
				logger.error("Not able to delete expired snapshot [{}]", snapshotName);
			}
		}
	}
}
 

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

  if (node instanceof FieldableNode && 
      (node.getParent() == null || !(node.getParent() instanceof FieldableNode))) {
    
    FieldableNode fieldNode = (FieldableNode) node;
    QueryConfigHandler config = getQueryConfigHandler();

    if (config != null) {
      CharSequence field = fieldNode.getField();
      FieldConfig fieldConfig = config.getFieldConfig(StringUtils.toString(field));

      if (fieldConfig != null) {
        Float boost = fieldConfig.get(ConfigurationKeys.BOOST);

        if (boost != null) {
          return new BoostQueryNode(node, boost);
        }

      }

    }

  }

  return node;

}
 

import org.apache.lucene.queryparser.flexible.core.util.StringUtils; //导入依赖的package包/类
/**
 * Returns an implementation of
 * {@link FieldConfig} for a specific field name. If the implemented
 * {@link QueryConfigHandler} does not know a specific field name, it may
 * return <code>null</code>, indicating there is no configuration for that
 * field.
 * 
 * @param fieldName
 *          the field name
 * @return a {@link FieldConfig} object containing the field name
 *         configuration or <code>null</code>, if the implemented
 *         {@link QueryConfigHandler} has no configuration for that field
 */
public FieldConfig getFieldConfig(String fieldName) {
  FieldConfig fieldConfig = new FieldConfig(StringUtils.toString(fieldName));

  for (FieldConfigListener listener : this.listeners) {
    listener.buildFieldConfig(fieldConfig);
  }

  return fieldConfig;

}