forked from apache/lucenenet
/
Term.cs
204 lines (185 loc) · 6.97 KB
/
Term.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
using Lucene.Net.Support;
using System;
using System.Text;
namespace Lucene.Net.Index
{
/*
* 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.
*/
using BytesRef = Lucene.Net.Util.BytesRef;
/// <summary>
/// A <see cref="Term"/> represents a word from text. This is the unit of search. It is
/// composed of two elements, the text of the word, as a string, and the name of
/// the field that the text occurred in.
/// <para/>
/// Note that terms may represent more than words from text fields, but also
/// things like dates, email addresses, urls, etc.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
#endif
public sealed class Term : IComparable<Term>, IEquatable<Term> // LUCENENET specific - class implements IEquatable<T>
{
/// <summary>
/// Constructs a <see cref="Term"/> with the given field and bytes.
/// <para/>Note that a null field or null bytes value results in undefined
/// behavior for most Lucene APIs that accept a Term parameter.
///
/// <para/>WARNING: the provided <see cref="BytesRef"/> is not copied, but used directly.
/// Therefore the bytes should not be modified after construction, for
/// example, you should clone a copy by <see cref="BytesRef.DeepCopyOf(BytesRef)"/>
/// rather than pass reused bytes from a <see cref="TermsEnum"/>.
/// </summary>
public Term(string fld, BytesRef bytes)
{
Field = fld;
Bytes = bytes;
}
/// <summary>
/// Constructs a <see cref="Term"/> with the given field and text.
/// <para/>Note that a <c>null</c> field or null text value results in undefined
/// behavior for most Lucene APIs that accept a <see cref="Term"/> parameter.
/// </summary>
public Term(string fld, string text)
: this(fld, new BytesRef(text))
{
}
/// <summary>
/// Constructs a <see cref="Term"/> with the given field and empty text.
/// this serves two purposes: 1) reuse of a <see cref="Term"/> with the same field.
/// 2) pattern for a query.
/// </summary>
/// <param name="fld"> field's name </param>
public Term(string fld)
: this(fld, new BytesRef())
{
}
/// <summary>
/// Returns the field of this term. The field indicates
/// the part of a document which this term came from.
/// </summary>
public string Field { get; internal set; }
/// <summary>
/// Returns the text of this term. In the case of words, this is simply the
/// text of the word. In the case of dates and other types, this is an
/// encoding of the object as a string.
/// </summary>
public string Text()
{
return ToString(Bytes);
}
/// <summary>
/// Returns human-readable form of the term text. If the term is not unicode,
/// the raw bytes will be printed instead.
/// </summary>
public static string ToString(BytesRef termText)
{
// the term might not be text, but usually is. so we make a best effort
Encoding decoder = new UTF8Encoding(false, true);
try
{
return decoder.GetString(termText.Bytes, termText.Offset, termText.Length);
}
catch
{
return termText.ToString();
}
}
/// <summary>
/// Returns the bytes of this term.
/// </summary>
public BytesRef Bytes { get; internal set; }
public override bool Equals(object obj)
{
Term t = obj as Term;
return this.Equals(t);
}
public override int GetHashCode()
{
const int prime = 31;
int result = 1;
result = prime * result + ((Field == null) ? 0 : Field.GetHashCode());
result = prime * result + ((Bytes == null) ? 0 : Bytes.GetHashCode());
return result;
}
/// <summary>
/// Compares two terms, returning a negative integer if this
/// term belongs before the argument, zero if this term is equal to the
/// argument, and a positive integer if this term belongs after the argument.
/// <para/>
/// The ordering of terms is first by field, then by text.
/// </summary>
public int CompareTo(Term other)
{
int compare = Field.CompareToOrdinal(other.Field);
if (compare == 0)
{
return Bytes.CompareTo(other.Bytes);
}
else
{
return compare;
}
}
/// <summary>
/// Resets the field and text of a <see cref="Term"/>.
/// <para/>WARNING: the provided <see cref="BytesRef"/> is not copied, but used directly.
/// Therefore the bytes should not be modified after construction, for
/// example, you should clone a copy rather than pass reused bytes from
/// a TermsEnum.
/// </summary>
internal void Set(string fld, BytesRef bytes)
{
Field = fld;
this.Bytes = bytes;
}
public bool Equals(Term other)
{
if (object.ReferenceEquals(null, other))
{
return object.ReferenceEquals(null, this);
}
if (object.ReferenceEquals(this, other))
{
return true;
}
if (this.GetType() != other.GetType())
{
return false;
}
if (string.Compare(this.Field, other.Field, StringComparison.Ordinal) != 0)
{
return false;
}
if (Bytes == null)
{
if (other.Bytes != null)
{
return false;
}
}
else if (!Bytes.Equals(other.Bytes))
{
return false;
}
return true;
}
public override string ToString()
{
return Field + ":" + Text();
}
}
}