forked from apache/lucenenet
-
Notifications
You must be signed in to change notification settings - Fork 3
/
DoubleFieldSource.cs
132 lines (114 loc) · 4.57 KB
/
DoubleFieldSource.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
using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
using Lucene.Net.Util;
using Lucene.Net.Util.Mutable;
using System.Collections;
namespace Lucene.Net.Queries.Function.ValueSources
{
/*
* 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>
/// Obtains <see cref="double"/> field values from <see cref="IFieldCache.GetDoubles(AtomicReader, string, FieldCache.IDoubleParser, bool)"/> and makes
/// those values available as other numeric types, casting as needed.
/// </summary>
public class DoubleFieldSource : FieldCacheSource
{
protected readonly FieldCache.IDoubleParser m_parser;
public DoubleFieldSource(string field)
: this(field, null)
{
}
public DoubleFieldSource(string field, FieldCache.IDoubleParser parser)
: base(field)
{
this.m_parser = parser;
}
public override string GetDescription()
{
return "double(" + m_field + ')';
}
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
var arr = m_cache.GetDoubles(readerContext.AtomicReader, m_field, m_parser, true);
var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
return new DoubleDocValuesAnonymousInnerClassHelper(this, arr, valid);
}
private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
{
private readonly FieldCache.Doubles arr;
private readonly IBits valid;
public DoubleDocValuesAnonymousInnerClassHelper(DoubleFieldSource @this, FieldCache.Doubles arr, IBits valid)
: base(@this)
{
this.arr = arr;
this.valid = valid;
}
public override double DoubleVal(int doc)
{
return arr.Get(doc);
}
public override bool Exists(int doc)
{
return arr.Get(doc) != 0 || valid.Get(doc);
}
public override ValueFiller GetValueFiller()
{
return new ValueFillerAnonymousInnerClassHelper(this);
}
private class ValueFillerAnonymousInnerClassHelper : ValueFiller
{
private readonly DoubleDocValuesAnonymousInnerClassHelper outerInstance;
public ValueFillerAnonymousInnerClassHelper(DoubleDocValuesAnonymousInnerClassHelper outerInstance)
{
this.outerInstance = outerInstance;
mval = new MutableValueDouble();
}
private readonly MutableValueDouble mval;
public override MutableValue Value
{
get
{
return mval;
}
}
public override void FillValue(int doc)
{
mval.Value = outerInstance.arr.Get(doc);
mval.Exists = mval.Value != 0 || outerInstance.valid.Get(doc);
}
}
}
public override bool Equals(object o)
{
var other = o as
DoubleFieldSource;
if (other == null)
{
return false;
}
return base.Equals(other) &&
(this.m_parser == null ? other.m_parser == null : this.m_parser.GetType() == other.m_parser.GetType());
}
public override int GetHashCode()
{
int h = m_parser == null ? typeof(double?).GetHashCode() : m_parser.GetType().GetHashCode();
h += base.GetHashCode();
return h;
}
}
}