SpanNearQuery.cs
上传用户:zhangkuixh
上传日期:2013-09-30
资源大小:5473k
文件大小:5k
源码类别:

搜索引擎

开发平台:

C#

  1. /*
  2.  * Copyright 2004 The Apache Software Foundation
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. using System;
  17. using IndexReader = Lucene.Net.Index.IndexReader;
  18. using Query = Lucene.Net.Search.Query;
  19. using ToStringUtils = Lucene.Net.Util.ToStringUtils;
  20. namespace Lucene.Net.Search.Spans
  21. {
  22. /// <summary>Matches spans which are near one another.  One can specify <i>slop</i>, the
  23. /// maximum number of intervening unmatched positions, as well as whether
  24. /// matches are required to be in-order. 
  25. /// </summary>
  26. [Serializable]
  27. public class SpanNearQuery : SpanQuery
  28. {
  29. private System.Collections.ArrayList clauses;
  30. private int slop;
  31. private bool inOrder;
  32. private System.String field;
  33. /// <summary>Construct a SpanNearQuery.  Matches spans matching a span from each
  34. /// clause, with up to <code>slop</code> total unmatched positions between
  35. /// them.  * When <code>inOrder</code> is true, the spans from each clause
  36. /// must be * ordered as in <code>clauses</code>. 
  37. /// </summary>
  38. public SpanNearQuery(SpanQuery[] clauses, int slop, bool inOrder)
  39. {
  40. // copy clauses array into an ArrayList
  41. this.clauses = new System.Collections.ArrayList(clauses.Length);
  42. for (int i = 0; i < clauses.Length; i++)
  43. {
  44. SpanQuery clause = clauses[i];
  45. if (i == 0)
  46. {
  47. // check field
  48. field = clause.GetField();
  49. }
  50. else if (!clause.GetField().Equals(field))
  51. {
  52. throw new System.ArgumentException("Clauses must have same field.");
  53. }
  54. this.clauses.Add(clause);
  55. }
  56. this.slop = slop;
  57. this.inOrder = inOrder;
  58. }
  59. /// <summary>Return the clauses whose spans are matched. </summary>
  60. public virtual SpanQuery[] GetClauses()
  61. {
  62. return (SpanQuery[]) clauses.ToArray(typeof(SpanQuery));
  63. }
  64. /// <summary>Return the maximum number of intervening unmatched positions permitted.</summary>
  65. public virtual int GetSlop()
  66. {
  67. return slop;
  68. }
  69. /// <summary>Return true if matches are required to be in-order.</summary>
  70. public virtual bool IsInOrder()
  71. {
  72. return inOrder;
  73. }
  74. public override System.String GetField()
  75. {
  76. return field;
  77. }
  78. public override System.Collections.ICollection GetTerms()
  79. {
  80. System.Collections.ArrayList terms = new System.Collections.ArrayList();
  81. System.Collections.IEnumerator i = clauses.GetEnumerator();
  82. while (i.MoveNext())
  83. {
  84. SpanQuery clause = (SpanQuery) i.Current;
  85. terms.AddRange(clause.GetTerms());
  86. }
  87. return terms;
  88. }
  89. public override System.String ToString(System.String field)
  90. {
  91. System.Text.StringBuilder buffer = new System.Text.StringBuilder();
  92. buffer.Append("spanNear([");
  93. System.Collections.IEnumerator i = clauses.GetEnumerator();
  94. while (i.MoveNext())
  95. {
  96. SpanQuery clause = (SpanQuery) i.Current;
  97. buffer.Append(clause.ToString(field));
  98. if (i.MoveNext())
  99. {
  100. buffer.Append(", ");
  101. }
  102. }
  103. buffer.Append("], ");
  104. buffer.Append(slop);
  105. buffer.Append(", ");
  106. buffer.Append(inOrder);
  107. buffer.Append(")");
  108. buffer.Append(ToStringUtils.Boost(GetBoost()));
  109. return buffer.ToString();
  110. }
  111. public override Spans GetSpans(IndexReader reader)
  112. {
  113. if (clauses.Count == 0)
  114. // optimize 0-clause case
  115. return new SpanOrQuery(GetClauses()).GetSpans(reader);
  116. if (clauses.Count == 1)
  117. // optimize 1-clause case
  118. return ((SpanQuery) clauses[0]).GetSpans(reader);
  119. return new NearSpans(this, reader);
  120. }
  121. public override Query Rewrite(IndexReader reader)
  122. {
  123. SpanNearQuery clone = null;
  124. for (int i = 0; i < clauses.Count; i++)
  125. {
  126. SpanQuery c = (SpanQuery) clauses[i];
  127. SpanQuery query = (SpanQuery) c.Rewrite(reader);
  128. if (query != c)
  129. {
  130. // clause rewrote: must clone
  131. if (clone == null)
  132. clone = (SpanNearQuery) this.Clone();
  133. clone.clauses[i] = query;
  134. }
  135. }
  136. if (clone != null)
  137. {
  138. return clone; // some clauses rewrote
  139. }
  140. else
  141. {
  142. return this; // no clauses rewrote
  143. }
  144. }
  145. /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
  146. public  override bool Equals(System.Object o)
  147. {
  148. if (this == o)
  149. return true;
  150. if (o == null || GetType() != o.GetType())
  151. return false;
  152. SpanNearQuery spanNearQuery = (SpanNearQuery) o;
  153. if (inOrder != spanNearQuery.inOrder)
  154. return false;
  155. if (slop != spanNearQuery.slop)
  156. return false;
  157. if (!clauses.Equals(spanNearQuery.clauses))
  158. return false;
  159. if (!field.Equals(spanNearQuery.field))
  160. return false;
  161. return GetBoost() == spanNearQuery.GetBoost();
  162. }
  163. public override int GetHashCode()
  164. {
  165. int result;
  166. result = clauses.GetHashCode();
  167. result += slop * 29;
  168. result += (inOrder?1:0);
  169. result ^= field.GetHashCode();
  170. return result;
  171. }
  172. }
  173. }