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
use super::*;
use itertools::Itertools;
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct Document {
field_values: Vec<FieldValue>,
}
impl PartialEq for Document {
fn eq(&self, other: &Document) -> bool {
let mut self_field_values = self.field_values.clone();
let mut other_field_values = other.field_values.clone();
self_field_values.sort();
other_field_values.sort();
self_field_values.eq(&other_field_values)
}
}
impl Eq for Document {}
impl Document {
pub fn new() -> Document {
Document::default()
}
pub fn len(&self) -> usize {
self.field_values.len()
}
pub fn is_empty(&self) -> bool {
self.field_values.is_empty()
}
pub fn add_text(&mut self, field: Field, text: &str) {
let value = Value::Str(String::from(text));
self.add(FieldValue::new(field, value));
}
pub fn add_u64(&mut self, field: Field, value: u64) {
self.add(FieldValue::new(field, Value::U64(value)));
}
pub fn add_i64(&mut self, field: Field, value: i64) {
self.add(FieldValue::new(field, Value::I64(value)));
}
pub fn add(&mut self, field_value: FieldValue) {
self.field_values.push(field_value);
}
pub fn field_values(&self) -> &[FieldValue] {
&self.field_values
}
pub fn get_sorted_field_values(&self) -> Vec<(Field, Vec<&FieldValue>)> {
let mut field_values: Vec<&FieldValue> = self.field_values().iter().collect();
field_values.sort_by_key(|field_value| field_value.field());
field_values
.into_iter()
.group_by(|field_value| field_value.field())
.into_iter()
.map(|(key, group)| (key, group.into_iter().collect()))
.collect::<Vec<(Field, Vec<&FieldValue>)>>()
}
pub fn get_all(&self, field: Field) -> Vec<&Value> {
self.field_values
.iter()
.filter(|field_value| field_value.field() == field)
.map(|field_value| field_value.value())
.collect()
}
pub fn get_first(&self, field: Field) -> Option<&Value> {
self.field_values
.iter()
.find(|field_value| field_value.field() == field)
.map(|field_value| field_value.value())
}
}
impl From<Vec<FieldValue>> for Document {
fn from(field_values: Vec<FieldValue>) -> Document {
Document { field_values: field_values }
}
}
#[cfg(test)]
mod tests {
use schema::*;
#[test]
fn test_doc() {
let mut schema_builder = SchemaBuilder::default();
let text_field = schema_builder.add_text_field("title", TEXT);
let mut doc = Document::default();
doc.add_text(text_field, "My title");
assert_eq!(doc.field_values().len(), 1);
}
}