public SpanNearQuery(SpanQuery[] clauses,
    int slop,
    boolean inOrder) 
{
    this(clauses, slop, inOrder, true);
}

Construct a SpanNearQuery. Matches spans matching a span from each clause, with up to slop total unmatched positions between them. * When inOrder is true, the spans from each clause must be * ordered as in clauses.

 public SpanNearQuery(SpanQuery[] clauses,
    int slop,
    boolean inOrder,
    boolean collectPayloads) 
{
    // copy clauses array into an ArrayList
    this.clauses = new ArrayList< SpanQuery >(clauses.length);
    for (int i = 0; i <  clauses.length; i++) {
      SpanQuery clause = clauses[i];
      if (i == 0) {                               // check field
        field = clause.getField();
      } else if (!clause.getField().equals(field)) {
        throw new IllegalArgumentException("Clauses must have same field.");
      }
      this.clauses.add(clause);
    }
    this.collectPayloads = collectPayloads;
    this.slop = slop;
    this.inOrder = inOrder;
}

 public Object clone() 
{
    int sz = clauses.size();
    SpanQuery[] newClauses = new SpanQuery[sz];
    for (int i = 0; i <  sz; i++) {
      newClauses[i] = (SpanQuery) clauses.get(i).clone();
    }
    SpanNearQuery spanNearQuery = new SpanNearQuery(newClauses, slop, inOrder);
    spanNearQuery.setBoost(getBoost());
    return spanNearQuery;
}

 public boolean equals(Object o) 
{
    if (this == o) return true;
    if (!(o instanceof SpanNearQuery)) return false;
    final SpanNearQuery spanNearQuery = (SpanNearQuery) o;
    if (inOrder != spanNearQuery.inOrder) return false;
    if (slop != spanNearQuery.slop) return false;
    if (!clauses.equals(spanNearQuery.clauses)) return false;
    return getBoost() == spanNearQuery.getBoost();
}

Returns true iff o is equal to this.

 public  void extractTerms(Set<Term> terms) 
{
	    for (final SpanQuery clause : clauses) {
	      clause.extractTerms(terms);
	    }
}

 public SpanQuery[] getClauses() 
{
    return clauses.toArray(new SpanQuery[clauses.size()]);
}

Return the clauses whose spans are matched.

 public String getField() 
{
 return field;
}

 public int getSlop() 
{
 return slop;
}

Return the maximum number of intervening unmatched positions permitted.

 public Spans getSpans(IndexReader reader) throws IOException 
{
    if (clauses.size() == 0)                      // optimize 0-clause case
      return new SpanOrQuery(getClauses()).getSpans(reader);
    if (clauses.size() == 1)                      // optimize 1-clause case
      return clauses.get(0).getSpans(reader);
    return inOrder
            ? (Spans) new NearSpansOrdered(this, reader, collectPayloads)
            : (Spans) new NearSpansUnordered(this, reader);
}

 public int hashCode() 
{
    int result;
    result = clauses.hashCode();
    // Mix bits before folding in things like boost, since it could cancel the
    // last element of clauses.  This particular mix also serves to
    // differentiate SpanNearQuery hashcodes from others.
    result ^= (result < <  14) | (result  > > > 19);  // reversible
    result += Float.floatToRawIntBits(getBoost());
    result += slop;
    result ^= (inOrder ? 0x99AFD3BD : 0);
    return result;
}

 public boolean isInOrder() 
{
 return inOrder;
}

Return true if matches are required to be in-order.

 public Query rewrite(IndexReader reader) throws IOException 
{
    SpanNearQuery clone = null;
    for (int i = 0 ; i <  clauses.size(); i++) {
      SpanQuery c = clauses.get(i);
      SpanQuery query = (SpanQuery) c.rewrite(reader);
      if (query != c) {                     // clause rewrote: must clone
        if (clone == null)
          clone = (SpanNearQuery) this.clone();
        clone.clauses.set(i,query);
      }
    }
    if (clone != null) {
      return clone;                        // some clauses rewrote
    } else {
      return this;                         // no clauses rewrote
    }
}

 public String toString(String field) 
{
    StringBuilder buffer = new StringBuilder();
    buffer.append("spanNear([");
    Iterator< SpanQuery > i = clauses.iterator();
    while (i.hasNext()) {
      SpanQuery clause = i.next();
      buffer.append(clause.toString(field));
      if (i.hasNext()) {
        buffer.append(", ");
      }
    }
    buffer.append("], ");
    buffer.append(slop);
    buffer.append(", ");
    buffer.append(inOrder);
    buffer.append(")");
    buffer.append(ToStringUtils.boost(getBoost()));
    return buffer.toString();
}