bookdata/io/object/
chunks.rs

1use std::{marker::PhantomData, mem::replace};
2
3use anyhow::Result;
4
5use super::ObjectWriter;
6
7/// Wrap an object writer so it can receive chunks.
8pub struct ChunkWriter<T, W>
9where
10    W: ObjectWriter<T>,
11{
12    _phantom: PhantomData<T>,
13    delegate: W,
14}
15
16impl<T, W> ChunkWriter<T, W>
17where
18    W: ObjectWriter<T>,
19{
20    pub fn new(delegate: W) -> ChunkWriter<T, W> {
21        ChunkWriter {
22            _phantom: PhantomData,
23            delegate,
24        }
25    }
26}
27
28impl<T, W> ObjectWriter<Vec<T>> for ChunkWriter<T, W>
29where
30    W: ObjectWriter<T>,
31{
32    fn write_object(&mut self, chunk: Vec<T>) -> Result<()> {
33        self.delegate.write_all_objects(chunk.into_iter())?;
34        Ok(())
35    }
36
37    fn finish(self) -> Result<usize> {
38        self.delegate.finish()
39    }
40}
41
42/// Wrap a writer of chunks to take individual values.
43pub struct UnchunkWriter<T, W>
44where
45    W: ObjectWriter<Vec<T>>,
46{
47    delegate: W,
48    chunk: Vec<T>,
49    chunk_size: usize,
50}
51
52impl<T, W> UnchunkWriter<T, W>
53where
54    W: ObjectWriter<Vec<T>>,
55{
56    #[allow(dead_code)]
57    pub fn new(delegate: W) -> UnchunkWriter<T, W> {
58        UnchunkWriter::with_size(delegate, 1024)
59    }
60
61    pub fn with_size(delegate: W, size: usize) -> UnchunkWriter<T, W> {
62        UnchunkWriter {
63            delegate,
64            chunk: Vec::with_capacity(size),
65            chunk_size: size,
66        }
67    }
68}
69
70impl<T, W> ObjectWriter<T> for UnchunkWriter<T, W>
71where
72    W: ObjectWriter<Vec<T>>,
73{
74    fn write_object(&mut self, obj: T) -> Result<()> {
75        self.chunk.push(obj);
76        if self.chunk.len() >= self.chunk_size {
77            let chunk = replace(&mut self.chunk, Vec::with_capacity(self.chunk_size));
78            self.delegate.write_object(chunk)?;
79        }
80        Ok(())
81    }
82
83    fn finish(mut self) -> Result<usize> {
84        if self.chunk.len() > 0 {
85            self.delegate.write_object(self.chunk)?;
86        }
87        self.delegate.finish()
88    }
89}