src/Lucene.Net/Search/Sort.cs - lucenenet - Git at Google

 using Lucene.Net.Support;
 using System.IO;
 using System.Text;

 namespace Lucene.Net.Search
 {
     /*
      * Licensed to the Apache Software Foundation (ASF) under one or more
      * contributor license agreements.  See the NOTICE file distributed with
      * this work for additional information regarding copyright ownership.
      * The ASF licenses this file to You under the Apache License, Version 2.0
      * (the "License"); you may not use this file except in compliance with
      * the License.  You may obtain a copy of the License at
      *
      *     http://www.apache.org/licenses/LICENSE-2.0
      *
      * Unless required by applicable law or agreed to in writing, software
      * distributed under the License is distributed on an "AS IS" BASIS,
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      * See the License for the specific language governing permissions and
      * limitations under the License.
      */

     /// <summary>
     /// Encapsulates sort criteria for returned hits.
     ///
     /// <para/>The fields used to determine sort order must be carefully chosen.
     /// <see cref="Documents.Document"/>s must contain a single term in such a field,
     /// and the value of the term should indicate the document's relative position in
     /// a given sort order.  The field must be indexed, but should not be tokenized,
     /// and does not need to be stored (unless you happen to want it back with the
     /// rest of your document data).  In other words:
     ///
     /// <para/><code>document.Add(new Field("byNumber", x.ToString(CultureInfo.InvariantCulture), Field.Store.NO, Field.Index.NOT_ANALYZED));</code>
     ///
     ///
     /// <para/><h3>Valid Types of Values</h3>
     ///
     /// <para/>There are four possible kinds of term values which may be put into
     /// sorting fields: <see cref="int"/>s, <see cref="long"/>s, <see cref="float"/>s, or <see cref="string"/>s.  Unless
     /// <see cref="SortField"/> objects are specified, the type of value
     /// in the field is determined by parsing the first term in the field.
     ///
     /// <para/><see cref="int"/> term values should contain only digits and an optional
     /// preceding negative sign.  Values must be base 10 and in the range
     /// <see cref="int.MinValue"/> and <see cref="int.MaxValue"/> inclusive.
     /// Documents which should appear first in the sort
     /// should have low value integers, later documents high values
     /// (i.e. the documents should be numbered <c>1..n</c> where
     /// <c>1</c> is the first and <c>n</c> the last).
     ///
     /// <para/><see cref="long"/> term values should contain only digits and an optional
     /// preceding negative sign.  Values must be base 10 and in the range
     /// <see cref="long.MinValue"/> and <see cref="long.MaxValue"/> inclusive.
     /// Documents which should appear first in the sort
     /// should have low value integers, later documents high values.
     ///
     /// <para/><see cref="float"/> term values should conform to values accepted by
     /// <see cref="float"/> (except that <c>NaN</c>
     /// and <c>Infinity</c> are not supported).
     /// <see cref="Documents.Document"/>s which should appear first in the sort
     /// should have low values, later documents high values.
     ///
     /// <para/><see cref="string"/> term values can contain any valid <see cref="string"/>, but should
     /// not be tokenized.  The values are sorted according to their
     /// comparable natural order (<see cref="System.StringComparer.Ordinal"/>).  Note that using this type
     /// of term value has higher memory requirements than the other
     /// two types.
     ///
     /// <para/><h3>Object Reuse</h3>
     ///
     /// <para/>One of these objects can be
     /// used multiple times and the sort order changed between usages.
     ///
     /// <para/>This class is thread safe.
     ///
     /// <para/><h3>Memory Usage</h3>
     ///
     /// <para/>Sorting uses of caches of term values maintained by the
     /// internal HitQueue(s).  The cache is static and contains an <see cref="int"/>
     /// or <see cref="float"/> array of length <c>IndexReader.MaxDoc</c> for each field
     /// name for which a sort is performed.  In other words, the size of the
     /// cache in bytes is:
     ///
     /// <para/><code>4 * IndexReader.MaxDoc * (# of different fields actually used to sort)</code>
     ///
     /// <para/>For <see cref="string"/> fields, the cache is larger: in addition to the
     /// above array, the value of every term in the field is kept in memory.
     /// If there are many unique terms in the field, this could
     /// be quite large.
     ///
     /// <para/>Note that the size of the cache is not affected by how many
     /// fields are in the index and <i>might</i> be used to sort - only by
     /// the ones actually used to sort a result set.
     ///
     /// <para/>Created: Feb 12, 2004 10:53:57 AM
     /// <para/>
     /// @since   lucene 1.4
     /// </summary>
     public class Sort
     {
         /// <summary>
         /// Represents sorting by computed relevance. Using this sort criteria returns
         /// the same results as calling
         /// <see cref="IndexSearcher.Search(Query, int)"/>without a sort criteria,
         /// only with slightly more overhead.
         /// </summary>
         public static readonly Sort RELEVANCE = new Sort();

         /// <summary>
         /// Represents sorting by index order. </summary>
         public static readonly Sort INDEXORDER = new Sort(SortField.FIELD_DOC);

         // internal representation of the sort criteria
         internal SortField[] fields;

         /// <summary>
         /// Sorts by computed relevance. This is the same sort criteria as calling
         /// <see cref="IndexSearcher.Search(Query, int)"/> without a sort criteria,
         /// only with slightly more overhead.
         /// </summary>
         public Sort()
             : this(SortField.FIELD_SCORE)
         {
         }

         /// <summary>
         /// Sorts by the criteria in the given <see cref="SortField"/>. </summary>
         public Sort(SortField field)
         {
             SetSort(field);
         }

         /// <summary>
         /// Sorts in succession by the criteria in each <see cref="SortField"/>. </summary>
         public Sort(params SortField[] fields)
         {
             SetSort(fields);
         }

         /// <summary>Sets the sort to the given criteria. </summary>
         public virtual void SetSort(SortField field)
         {
             this.fields = new SortField[] { field };
         }

         /// <summary>Sets the sort to the given criteria in succession. </summary>
         public virtual void SetSort(params SortField[] fields)
         {
             this.fields = fields;
         }

         /// <summary> Representation of the sort criteria.</summary>
         /// <returns> Array of <see cref="SortField"/> objects used in this sort criteria
         /// </returns>
         [WritableArray]
         public virtual SortField[] GetSort()
         {
             return fields;
         }

         /// <summary>
         /// Rewrites the <see cref="SortField"/>s in this <see cref="Sort"/>, returning a new <see cref="Sort"/> if any of the fields
         /// changes during their rewriting.
         /// <para/>
         /// @lucene.experimental
         /// </summary>
         /// <param name="searcher"> <see cref="IndexSearcher"/> to use in the rewriting </param>
         /// <returns> <c>this</c> if the Sort/Fields have not changed, or a new <see cref="Sort"/> if there
         ///        is a change </returns>
         /// <exception cref="IOException"> Can be thrown by the rewriting</exception>
         public virtual Sort Rewrite(IndexSearcher searcher)
         {
             bool changed = false;

             SortField[] rewrittenSortFields = new SortField[fields.Length];
             for (int i = 0; i < fields.Length; i++)
             {
                 rewrittenSortFields[i] = fields[i].Rewrite(searcher);
                 if (fields[i] != rewrittenSortFields[i])
                 {
                     changed = true;
                 }
             }

             return (changed) ? new Sort(rewrittenSortFields) : this;
         }

         public override string ToString()
         {
             StringBuilder buffer = new StringBuilder();

             for (int i = 0; i < fields.Length; i++)
             {
                 buffer.Append(fields[i].ToString());
                 if ((i + 1) < fields.Length)
                 {
                     buffer.Append(',');
                 }
             }

             return buffer.ToString();
         }

         /// <summary>
         /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary>
         public override bool Equals(object o)
         {
             if (this == o)
             {
                 return true;
             }
             if (!(o is Sort))
             {
                 return false;
             }
             Sort other = (Sort)o;
             return Arrays.Equals(this.fields, other.fields);
         }

         /// <summary>
         /// Returns a hash code value for this object. </summary>
         public override int GetHashCode()
         {
             return 0x45aaf665 + Arrays.GetHashCode(fields);
         }

         /// <summary>
         /// Returns <c>true</c> if the relevance score is needed to sort documents. </summary>
         public virtual bool NeedsScores
         {
             get
             {
                 foreach (SortField sortField in fields)
                 {
                     if (sortField.NeedsScores)
                     {
                         return true;
                     }
                 }
                 return false;
             }
         }
     }
 }
	using Lucene.Net.Support;
	using System.IO;
	using System.Text;

	namespace Lucene.Net.Search
	{
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/// <summary>
	/// Encapsulates sort criteria for returned hits.
	///
	/// <para/>The fields used to determine sort order must be carefully chosen.
	/// <see cref="Documents.Document"/>s must contain a single term in such a field,
	/// and the value of the term should indicate the document's relative position in
	/// a given sort order. The field must be indexed, but should not be tokenized,
	/// and does not need to be stored (unless you happen to want it back with the
	/// rest of your document data). In other words:
	///
	/// <para/><code>document.Add(new Field("byNumber", x.ToString(CultureInfo.InvariantCulture), Field.Store.NO, Field.Index.NOT_ANALYZED));</code>
	///
	///
	/// <para/><h3>Valid Types of Values</h3>
	///
	/// <para/>There are four possible kinds of term values which may be put into
	/// sorting fields: <see cref="int"/>s, <see cref="long"/>s, <see cref="float"/>s, or <see cref="string"/>s. Unless
	/// <see cref="SortField"/> objects are specified, the type of value
	/// in the field is determined by parsing the first term in the field.
	///
	/// <para/><see cref="int"/> term values should contain only digits and an optional
	/// preceding negative sign. Values must be base 10 and in the range
	/// <see cref="int.MinValue"/> and <see cref="int.MaxValue"/> inclusive.
	/// Documents which should appear first in the sort
	/// should have low value integers, later documents high values
	/// (i.e. the documents should be numbered <c>1..n</c> where
	/// <c>1</c> is the first and <c>n</c> the last).
	///
	/// <para/><see cref="long"/> term values should contain only digits and an optional
	/// preceding negative sign. Values must be base 10 and in the range
	/// <see cref="long.MinValue"/> and <see cref="long.MaxValue"/> inclusive.
	/// Documents which should appear first in the sort
	/// should have low value integers, later documents high values.
	///
	/// <para/><see cref="float"/> term values should conform to values accepted by
	/// <see cref="float"/> (except that <c>NaN</c>
	/// and <c>Infinity</c> are not supported).
	/// <see cref="Documents.Document"/>s which should appear first in the sort
	/// should have low values, later documents high values.
	///
	/// <para/><see cref="string"/> term values can contain any valid <see cref="string"/>, but should
	/// not be tokenized. The values are sorted according to their
	/// comparable natural order (<see cref="System.StringComparer.Ordinal"/>). Note that using this type
	/// of term value has higher memory requirements than the other
	/// two types.
	///
	/// <para/><h3>Object Reuse</h3>
	///
	/// <para/>One of these objects can be
	/// used multiple times and the sort order changed between usages.
	///
	/// <para/>This class is thread safe.
	///
	/// <para/><h3>Memory Usage</h3>
	///
	/// <para/>Sorting uses of caches of term values maintained by the
	/// internal HitQueue(s). The cache is static and contains an <see cref="int"/>
	/// or <see cref="float"/> array of length <c>IndexReader.MaxDoc</c> for each field
	/// name for which a sort is performed. In other words, the size of the
	/// cache in bytes is:
	///
	/// <para/><code>4 * IndexReader.MaxDoc * (# of different fields actually used to sort)</code>
	///
	/// <para/>For <see cref="string"/> fields, the cache is larger: in addition to the
	/// above array, the value of every term in the field is kept in memory.
	/// If there are many unique terms in the field, this could
	/// be quite large.
	///
	/// <para/>Note that the size of the cache is not affected by how many
	/// fields are in the index and <i>might</i> be used to sort - only by
	/// the ones actually used to sort a result set.
	///
	/// <para/>Created: Feb 12, 2004 10:53:57 AM
	/// <para/>
	/// @since lucene 1.4
	/// </summary>
	public class Sort
	{
	/// <summary>
	/// Represents sorting by computed relevance. Using this sort criteria returns
	/// the same results as calling
	/// <see cref="IndexSearcher.Search(Query, int)"/>without a sort criteria,
	/// only with slightly more overhead.
	/// </summary>
	public static readonly Sort RELEVANCE = new Sort();

	/// <summary>
	/// Represents sorting by index order. </summary>
	public static readonly Sort INDEXORDER = new Sort(SortField.FIELD_DOC);

	// internal representation of the sort criteria
	internal SortField[] fields;

	/// <summary>
	/// Sorts by computed relevance. This is the same sort criteria as calling
	/// <see cref="IndexSearcher.Search(Query, int)"/> without a sort criteria,
	/// only with slightly more overhead.
	/// </summary>
	public Sort()
	: this(SortField.FIELD_SCORE)
	{
	}

	/// <summary>
	/// Sorts by the criteria in the given <see cref="SortField"/>. </summary>
	public Sort(SortField field)
	{
	SetSort(field);
	}

	/// <summary>
	/// Sorts in succession by the criteria in each <see cref="SortField"/>. </summary>
	public Sort(params SortField[] fields)
	{
	SetSort(fields);
	}

	/// <summary>Sets the sort to the given criteria. </summary>
	public virtual void SetSort(SortField field)
	{
	this.fields = new SortField[] { field };
	}

	/// <summary>Sets the sort to the given criteria in succession. </summary>
	public virtual void SetSort(params SortField[] fields)
	{
	this.fields = fields;
	}

	/// <summary> Representation of the sort criteria.</summary>
	/// <returns> Array of <see cref="SortField"/> objects used in this sort criteria
	/// </returns>
	[WritableArray]
	public virtual SortField[] GetSort()
	{
	return fields;
	}

	/// <summary>
	/// Rewrites the <see cref="SortField"/>s in this <see cref="Sort"/>, returning a new <see cref="Sort"/> if any of the fields
	/// changes during their rewriting.
	/// <para/>
	/// @lucene.experimental
	/// </summary>
	/// <param name="searcher"> <see cref="IndexSearcher"/> to use in the rewriting </param>
	/// <returns> <c>this</c> if the Sort/Fields have not changed, or a new <see cref="Sort"/> if there
	/// is a change </returns>
	/// <exception cref="IOException"> Can be thrown by the rewriting</exception>
	public virtual Sort Rewrite(IndexSearcher searcher)
	{
	bool changed = false;

	SortField[] rewrittenSortFields = new SortField[fields.Length];
	for (int i = 0; i < fields.Length; i++)
	{
	rewrittenSortFields[i] = fields[i].Rewrite(searcher);
	if (fields[i] != rewrittenSortFields[i])
	{
	changed = true;
	}
	}

	return (changed) ? new Sort(rewrittenSortFields) : this;
	}

	public override string ToString()
	{
	StringBuilder buffer = new StringBuilder();

	for (int i = 0; i < fields.Length; i++)
	{
	buffer.Append(fields[i].ToString());
	if ((i + 1) < fields.Length)
	{
	buffer.Append(',');
	}
	}

	return buffer.ToString();
	}

	/// <summary>
	/// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary>
	public override bool Equals(object o)
	{
	if (this == o)
	{
	return true;
	}
	if (!(o is Sort))
	{
	return false;
	}
	Sort other = (Sort)o;
	return Arrays.Equals(this.fields, other.fields);
	}

	/// <summary>
	/// Returns a hash code value for this object. </summary>
	public override int GetHashCode()
	{
	return 0x45aaf665 + Arrays.GetHashCode(fields);
	}

	/// <summary>
	/// Returns <c>true</c> if the relevance score is needed to sort documents. </summary>
	public virtual bool NeedsScores
	{
	get
	{
	foreach (SortField sortField in fields)
	{
	if (sortField.NeedsScores)
	{
	return true;
	}
	}
	return false;
	}
	}
	}
	}