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
/*
* 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.
*/
use crate::core::search::field_comparator::FieldComparatorValue;
use crate::core::search::score_doc::{ScoreDoc, ScoreDocLike};
use std::fmt;
pub type FieldsValue = FieldComparatorValue;
/// Expert: A [`ScoreDoc`] which also contains information about how to sort the referenced document.
/// In addition to the document number and score, this object contains an array of values for the
/// document from the field(s) used to sort. For example, if the sort criteria was to sort by fields
/// `"a"`, `"b"` then `"c"`, the `fields` object array will have three elements, corresponding
/// respectively to the term values for the document in fields `"a"`, `"b"` and `"c"`. The type of
/// each element in the array will be a corresponding [`FieldComparatorValue`] variant depending
/// on the value type of each field.
///
/// See also:
/// - [`ScoreDoc`]
/// - [`TopFieldDocs`](crate::core::search::top_field_docs::TopFieldDocs)
#[derive(Clone, Default, Debug)]
pub struct FieldDoc {
pub base: ScoreDoc,
/// Expert: The values which are used to sort the referenced document. The order of these will
/// match the original sort criteria given by a [`Sort`](crate::core::search::sort::Sort) object. Each Object will have been returned
/// from the `value` method corresponding [`FieldComparator`](crate::core::search::field_comparator::FieldComparator) used to sort this field.
///
/// See also:
/// - [`Sort`](crate::core::search::sort::Sort)
/// - [`IndexSearcher::search`](crate::core::search::index_searcher::IndexSearcher::search)
pub fields: Vec<FieldsValue>,
}
impl FieldDoc {
/// Creates one of these objects with empty sort information.
pub fn new(doc: i32, score: f32) -> Self {
Self {
base: ScoreDoc::new(doc, score),
fields: Vec::new(),
}
}
/// Creates one of these objects with the given sort information.
pub fn with_fields<I>(doc: i32, score: f32, fields: I) -> Self
where
I: IntoIterator<Item = FieldsValue>,
{
let fields = fields.into_iter().collect::<Vec<FieldsValue>>();
Self {
base: ScoreDoc::new(doc, score),
fields,
}
}
/// Creates one of these objects with the given sort information and shard_index.
pub fn with_fields_and_shard_index<I>(doc: i32, score: f32, fields: I, shard_index: i32) -> Self
where
I: IntoIterator<Item = FieldsValue>,
{
let fields = fields.into_iter().collect::<Vec<FieldsValue>>();
Self {
base: ScoreDoc::with_shard_index(doc, score, shard_index),
fields,
}
}
}
impl ScoreDocLike for FieldDoc {
fn doc(&self) -> i32 {
self.base.doc
}
fn score(&self) -> f32 {
self.base.score
}
fn shard_index(&self) -> i32 {
self.base.shard_index
}
fn set_shard_index(&mut self, shard_index: i32) {
self.base.shard_index = shard_index;
}
fn set_score(&mut self, score: f32) {
self.base.score = score;
}
}
impl fmt::Display for FieldDoc {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} fields=[", self.base)?;
for (index, value) in self.fields.iter().enumerate() {
if index > 0 {
write!(f, ", ")?;
}
match value {
FieldComparatorValue::Missing => write!(f, "null")?,
FieldComparatorValue::Double(value) => write!(f, "{value}")?,
FieldComparatorValue::Float(value) => write!(f, "{value}")?,
FieldComparatorValue::Int(value) => write!(f, "{value}")?,
FieldComparatorValue::Long(value) => write!(f, "{value}")?,
FieldComparatorValue::TermVal(value) => write!(f, "{value}")?,
}
}
write!(f, "]")
}
}