mcs/tools/monkeydoc/Lucene.Net/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 using System;
  19
  20 using IndexReader = Mono.Lucene.Net.Index.IndexReader;
  21 using FieldCache = Mono.Lucene.Net.Search.FieldCache;
  22
  23 namespace Mono.Lucene.Net.Search.Function
  24 {
  25
  26         /// <summary> Expert: obtains the ordinal of the field value from the default Lucene
  27         /// {@link Mono.Lucene.Net.Search.FieldCache FieldCache} using getStringIndex()
  28         /// and reverses the order.
  29         /// <p/>
  30         /// The native lucene index order is used to assign an ordinal value for each field value.
  31         /// <p/>
  32         /// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
  33         /// <br/>
  34         /// Example of reverse ordinal (rord):
  35         /// <br/>If there were only three field values: "apple","banana","pear"
  36         /// <br/>then rord("apple")=3, rord("banana")=2, ord("pear")=1
  37         /// <p/>
  38         /// WARNING:
  39         /// rord() depends on the position in an index and can thus change
  40         /// when other documents are inserted or deleted,
  41         /// or if a MultiSearcher is used.
  42         ///
  43         /// <p/><font color="#FF0000">
  44         /// WARNING: The status of the <b>Search.Function</b> package is experimental.
  45         /// The APIs introduced here might change in the future and will not be
  46         /// supported anymore in such a case.</font>
  47         ///
  48         /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
  49         /// searching, if {@link #getValues} is invoked with a
  50         /// composite (multi-segment) reader, this can easily cause
  51         /// double RAM usage for the values in the FieldCache.  It's
  52         /// best to switch your application to pass only atomic
  53         /// (single segment) readers to this API.  Alternatively, for
  54         /// a short-term fix, you could wrap your ValueSource using
  55         /// {@link MultiValueSource}, which costs more CPU per lookup
  56         /// but will not consume double the FieldCache RAM.<p/>
  57         /// </summary>
  58
  59         [Serializable]
  60         public class ReverseOrdFieldSource:ValueSource
  61         {
  62                 private class AnonymousClassDocValues:DocValues
  63                 {
  64                         public AnonymousClassDocValues(int end, int[] arr, ReverseOrdFieldSource enclosingInstance)
  65                         {
  66                                 InitBlock(end, arr, enclosingInstance);
  67                         }
  68                         private void  InitBlock(int end, int[] arr, ReverseOrdFieldSource enclosingInstance)
  69                         {
  70                                 this.end = end;
  71                                 this.arr = arr;
  72                                 this.enclosingInstance = enclosingInstance;
  73                         }
  74                         private int end;
  75                         private int[] arr;
  76                         private ReverseOrdFieldSource enclosingInstance;
  77                         public ReverseOrdFieldSource Enclosing_Instance
  78                         {
  79                                 get
  80                                 {
  81                                         return enclosingInstance;
  82                                 }
  83
  84                         }
  85                         /*(non-Javadoc) @see Mono.Lucene.Net.Search.Function.DocValues#floatVal(int) */
  86                         public override float FloatVal(int doc)
  87                         {
  88                                 return (float) (end - arr[doc]);
  89                         }
  90                         /* (non-Javadoc) @see Mono.Lucene.Net.Search.Function.DocValues#intVal(int) */
  91                         public override int IntVal(int doc)
  92                         {
  93                                 return end - arr[doc];
  94                         }
  95                         /* (non-Javadoc) @see Mono.Lucene.Net.Search.Function.DocValues#strVal(int) */
  96                         public override System.String StrVal(int doc)
  97                         {
  98                                 // the string value of the ordinal, not the string itself
  99                                 return System.Convert.ToString(IntVal(doc));
 100                         }
 101                         /*(non-Javadoc) @see Mono.Lucene.Net.Search.Function.DocValues#toString(int) */
 102                         public override System.String ToString(int doc)
 103                         {
 104                                 return Enclosing_Instance.Description() + '=' + StrVal(doc);
 105                         }
 106                         /*(non-Javadoc) @see Mono.Lucene.Net.Search.Function.DocValues#getInnerArray() */
 107                         public /*internal*/ override System.Object GetInnerArray()
 108                         {
 109                                 return arr;
 110                         }
 111                 }
 112                 public System.String field;
 113
 114                 /// <summary> Contructor for a certain field.</summary>
 115                 /// <param name="field">field whose values reverse order is used.
 116                 /// </param>
 117                 public ReverseOrdFieldSource(System.String field)
 118                 {
 119                         this.field = field;
 120                 }
 121
 122                 /*(non-Javadoc) @see Mono.Lucene.Net.Search.Function.ValueSource#description() */
 123                 public override System.String Description()
 124                 {
 125                         return "rord(" + field + ')';
 126                 }
 127
 128                 /*(non-Javadoc) @see Mono.Lucene.Net.Search.Function.ValueSource#getValues(Mono.Lucene.Net.Index.IndexReader) */
 129                 public override DocValues GetValues(IndexReader reader)
 130                 {
 131                         Mono.Lucene.Net.Search.StringIndex sindex = Mono.Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetStringIndex(reader, field);
 132
 133                         int[] arr = sindex.order;
 134                         int end = sindex.lookup.Length;
 135
 136                         return new AnonymousClassDocValues(end, arr, this);
 137                 }
 138
 139                 /*(non-Javadoc) @see java.lang.Object#equals(java.lang.Object) */
 140                 public  override bool Equals(System.Object o)
 141                 {
 142                         if (o.GetType() != typeof(ReverseOrdFieldSource))
 143                                 return false;
 144                         ReverseOrdFieldSource other = (ReverseOrdFieldSource) o;
 145                         return this.field.Equals(other.field);
 146                 }
 147
 148                 private static readonly int hcode;
 149
 150                 /*(non-Javadoc) @see java.lang.Object#hashCode() */
 151                 public override int GetHashCode()
 152                 {
 153                         return hcode + field.GetHashCode();
 154                 }
 155                 static ReverseOrdFieldSource()
 156                 {
 157                         hcode = typeof(ReverseOrdFieldSource).GetHashCode();
 158                 }
 159         }
 160 }