sonnerie 0.9.1

An easy timeseries database
Documentation 
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

#[cfg(feature = "by-key")]
use crate::bykey::*;
use crate::Record;
use crate::*;
use ::rayon::iter::plumbing::*;
use ::rayon::prelude::*;

struct RecordProducer<'k> {
	reader: DatabaseRecordReader<'k>,
}

impl<'k> ParallelIterator for DatabaseRecordReader<'k> {
	type Item = Record;

	fn drive_unindexed<C>(self, consumer: C) -> C::Result
	where
		C: UnindexedConsumer<Self::Item>,
	{
		bridge_unindexed(RecordProducer { reader: self }, consumer)
	}
}

impl<'k> UnindexedProducer for RecordProducer<'k> {
	type Item = Record;

	fn split(self) -> (RecordProducer<'k>, Option<RecordProducer<'k>>) {
		if let Some((first, second)) = self.reader.split() {
			(
				RecordProducer { reader: first },
				Some(RecordProducer { reader: second }),
			)
		} else {
			(
				RecordProducer {
					reader: self.reader,
				},
				None,
			)
		}
	}

	fn fold_with<F>(self, folder: F) -> F
	where
		F: Folder<Self::Item>,
	{
		folder.consume_iter(self.reader)
	}
}

#[cfg(feature = "by-key")]
struct KeyProducer<'k> {
	reader: DatabaseKeyReader<'k>,
}

#[cfg(feature = "by-key")]
impl<'k> ParallelIterator for DatabaseKeyReader<'k> {
	type Item = KeyRecordReader<'k>;

	fn drive_unindexed<C>(self, consumer: C) -> C::Result
	where
		C: UnindexedConsumer<Self::Item>,
	{
		bridge_unindexed(KeyProducer { reader: self }, consumer)
	}
}

#[cfg(feature = "by-key")]
impl<'k> UnindexedProducer for KeyProducer<'k> {
	type Item = KeyRecordReader<'k>;

	fn split(self) -> (KeyProducer<'k>, Option<KeyProducer<'k>>) {
		if let Some((first, second)) = self.reader.split() {
			(
				KeyProducer { reader: first },
				Some(KeyProducer { reader: second }),
			)
		} else {
			(
				KeyProducer {
					reader: self.reader,
				},
				None,
			)
		}
	}

	fn fold_with<F>(self, folder: F) -> F
	where
		F: Folder<Self::Item>,
	{
		folder.consume_iter(self.reader)
	}
}