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
use serde::ser::{Serialize, Serializer, SerializeSeq};
use bit_vec::BitVec;
pub enum MaybeNa<T> {
Na,
Exists(T)
}
#[derive(Debug, Clone)]
pub struct MaskedData<T> {
mask: BitVec,
data: Vec<T>
}
impl<T> MaskedData<T> {
pub fn len(&self) -> usize {
assert_eq!(self.mask.len(), self.data.len());
self.data.len()
}
pub fn get(&self, index: usize) -> Option<MaybeNa<&T>> {
if index >= self.data.len() {
None
} else {
if self.mask[index] {
Some(MaybeNa::Exists(&self.data[index]))
} else {
Some(MaybeNa::Na)
}
}
}
}
impl<T: Default> MaskedData<T> {
pub fn new_with_elem(value: MaybeNa<T>) -> MaskedData<T> {
if let MaybeNa::Exists(v) = value {
MaskedData {
data: vec!(v),
mask: BitVec::from_elem(1, true)
}
} else {
MaskedData {
data: vec![T::default()],
mask: BitVec::from_elem(1, false)
}
}
}
pub fn push(&mut self, value: MaybeNa<T>) {
if let MaybeNa::Exists(v) = value {
self.data.push(v);
self.mask.push(true);
} else {
self.data.push(T::default());
self.mask.push(false);
}
}
}
impl<T: Serialize> Serialize for MaskedData<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
let mut seq = serializer.serialize_seq(Some(self.data.len()))?;
for (mask, elem) in self.mask.iter().zip(self.data.iter()) {
if mask {
seq.serialize_element(elem)?;
} else {
seq.serialize_element("null")?;
}
}
seq.end()
}
}
pub enum FieldData<'a> {
Unsigned(&'a MaskedData<u64>),
Signed(&'a MaskedData<i64>),
Text(&'a MaskedData<String>),
Boolean(&'a MaskedData<bool>),
Float(&'a MaskedData<f64>),
}
impl<'a> FieldData<'a> {
pub fn len(&self) -> usize {
match *self {
FieldData::Unsigned(v) => v.data.len(),
FieldData::Signed(v) => v.data.len(),
FieldData::Text(v) => v.data.len(),
FieldData::Boolean(v) => v.data.len(),
FieldData::Float(v) => v.data.len(),
}
}
}
impl<'a> Serialize for FieldData<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self {
FieldData::Unsigned(v) => v.serialize(serializer),
FieldData::Signed(v) => v.serialize(serializer),
FieldData::Text(v) => v.serialize(serializer),
FieldData::Boolean(v) => v.serialize(serializer),
FieldData::Float(v) => v.serialize(serializer),
}
}
}