public SpanWeight(SpanQuery query, Searcher searcher)
{
this.similarity = query.GetSimilarity(searcher);
this.internalQuery = query;
terms = Lucene.Net.Support.Compatibility.SetFactory.CreateHashSet<Term>();
query.ExtractTerms(terms);
idfExp = similarity.IdfExplain(terms, searcher);
idf = idfExp.Idf;
}
public override System.Object Clone()
{
int sz = clauses.Count;
SpanQuery[] newClauses = new SpanQuery[sz];
for (int i = 0; i < sz; i++)
{
newClauses[i] = clauses[i];
}
PayloadNearQuery boostingNearQuery = new PayloadNearQuery(newClauses, internalSlop, inOrder);
boostingNearQuery.Boost = Boost;
return boostingNearQuery;
}
public FieldMaskingSpanQuery(SpanQuery maskedQuery, System.String maskedField)
{
this.maskedQuery = maskedQuery;
this.field = maskedField;
}
/// <summary>Constructs a filter which only matches documents matching
/// <c>query</c>.
/// </summary>
/// <param name="query">The <see cref="Lucene.Net.Search.Spans.SpanQuery" /> to use as the basis for the Filter.
/// </param>
public SpanQueryFilter(SpanQuery query)
{
this.internalQuery = query;
}
/// <summary>Construct a SpanFirstQuery matching spans in <c>match</c> whose end
/// position is less than or equal to <c>end</c>.
/// </summary>
public SpanFirstQuery(SpanQuery match, int end)
{
this.match = match;
this.end = end;
}
/// <summary>Construct a SpanNotQuery matching spans from <c>include</c> which
/// have no overlap with spans from <c>exclude</c>.
/// </summary>
public SpanNotQuery(SpanQuery include, SpanQuery exclude)
{
this.include = include;
this.exclude = exclude;
if (!include.Field.Equals(exclude.Field))
throw new System.ArgumentException("Clauses must have same field.");
}
public PayloadNearQuery(SpanQuery[] clauses, int slop, bool inOrder, PayloadFunction function):base(clauses, slop, inOrder)
{
fieldName = clauses[0].Field; // all clauses must have same field
this.function = function;
}
public PayloadNearQuery(SpanQuery[] clauses, int slop, bool inOrder):this(clauses, slop, inOrder, new AveragePayloadFunction())
{
}
public PayloadNearSpanWeight(PayloadNearQuery enclosingInstance, SpanQuery query, Searcher searcher):base(query, searcher)
{
InitBlock(enclosingInstance);
}
private void QueryToSpanQuery(Query query, ICollection<byte[]> payloads)
{
if (query is BooleanQuery)
{
BooleanClause[] queryClauses = ((BooleanQuery) query).GetClauses();
for (int i = 0; i < queryClauses.Length; i++)
{
if (!queryClauses[i].IsProhibited)
{
QueryToSpanQuery(queryClauses[i].Query, payloads);
}
}
}
else if (query is PhraseQuery)
{
Term[] phraseQueryTerms = ((PhraseQuery) query).GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = ((PhraseQuery) query).Slop;
bool inorder = false;
if (slop == 0)
{
inorder = true;
}
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.Boost = query.Boost;
GetPayloads(payloads, sp);
}
else if (query is TermQuery)
{
SpanTermQuery stq = new SpanTermQuery(((TermQuery) query).Term);
stq.Boost = query.Boost;
GetPayloads(payloads, stq);
}
else if (query is SpanQuery)
{
GetPayloads(payloads, (SpanQuery) query);
}
else if (query is FilteredQuery)
{
QueryToSpanQuery(((FilteredQuery) query).Query, payloads);
}
else if (query is DisjunctionMaxQuery)
{
for (IEnumerator<Query> iterator = ((DisjunctionMaxQuery)query).GetEnumerator(); iterator.MoveNext(); )
{
QueryToSpanQuery(iterator.Current, payloads);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery) query;
System.Collections.Generic.IList<Term[]> termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
IList<Query>[] disjunctLists = new IList<Query>[maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = termArrays[i];
IList<Query> disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new List<Query>(termArray.Length));
++distinctPositions;
}
foreach(Term term in termArray)
{
disjuncts.Add(new SpanTermQuery(term));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
for (int i = 0; i < disjunctLists.Length; ++i)
{
IList<Query> disjuncts = disjunctLists[i];
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery((SpanQuery[]) (disjuncts.ToArray()));
}
else
{
++positionGaps;
}
}
int slop = mpq.Slop;
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.Boost = query.Boost;
GetPayloads(payloads, sp);
}
}
}
private void GetPayloads(ICollection<byte[]> payloads, SpanQuery query)
{
Spans.Spans spans = query.GetSpans(reader);
while (spans.Next() == true)
{
if (spans.IsPayloadAvailable())
{
ICollection<byte[]> payload = spans.GetPayload();
foreach (byte[] bytes in payload)
{
payloads.Add(bytes);
}
}
}
}
