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

use crate::{
    iters::{KeyIterator, KeyValueIterator, KeyValueRangeIterator},
    serde::ReadResult,
    types::Deser,
};
use anyhow::{anyhow, Result};
use std::any;
use std::io::BufReader;
use std::io::{Read, Seek};
use std::marker::PhantomData;

pub struct KeyValueReader<R, K, V> {
    r: BufReader<R>,
    _phant: PhantomData<(K, V)>,
}
impl<R, K, V> From<R> for KeyValueReader<R, K, V>
where
    R: Read,
{
    fn from(r: R) -> Self {
        Self {
            r: BufReader::new(r),
            _phant: PhantomData,
        }
    }
}
impl<RS, K, V> KeyValueReader<RS, K, V>
where
    RS: Read + Seek,
    K: Deser,
    V: Deser,
{
    pub fn deser_k(&mut self) -> Result<ReadResult<K>> {
        K::deser(&mut self.r)
    }
    pub fn skip_k(&mut self) -> Result<ReadResult<()>> {
        K::skip(&mut self.r)
    }
    pub fn deser_v(&mut self) -> Result<(usize, V)> {
        match V::deser(&mut self.r)? {
            ReadResult::EOF => Err(anyhow!(
                "EOF where a `V` typed {} is expected.",
                any::type_name::<V>()
            )),
            ReadResult::Some(r_len, v) => Ok((r_len, v)),
        }
    }
    pub fn skip_v(&mut self) -> Result<usize> {
        match V::skip(&mut self.r)? {
            ReadResult::EOF => Err(anyhow!(
                "EOF where a `V` typed {} is expected.",
                any::type_name::<V>()
            )),
            ReadResult::Some(r_len, ()) => Ok(r_len),
        }
    }

    pub fn deser_kv(&mut self) -> Result<ReadResult<(K, V)>> {
        let (mut r_len, k) = match self.deser_k()? {
            ReadResult::EOF => return Ok(ReadResult::EOF),
            ReadResult::Some(r_len, k) => (r_len, k),
        };

        let (delta_r_len, v) = self.deser_v()?;
        r_len += delta_r_len;

        Ok(ReadResult::Some(r_len, (k, v)))
    }
    pub fn deser_k_skip_v(&mut self) -> Result<ReadResult<K>> {
        let (mut r_len, k) = match self.deser_k()? {
            ReadResult::EOF => return Ok(ReadResult::EOF),
            ReadResult::Some(r_len, k) => (r_len, k),
        };

        let delta_r_len = self.skip_v()?;
        r_len += delta_r_len;

        Ok(ReadResult::Some(r_len, k))
    }
    pub fn skip_kv(&mut self) -> Result<ReadResult<()>> {
        let mut r_len = match self.skip_k()? {
            ReadResult::EOF => return Ok(ReadResult::EOF),
            ReadResult::Some(r_len, ()) => r_len,
        };

        let delta_r_len = self.skip_v()?;
        r_len += delta_r_len;

        Ok(ReadResult::Some(r_len, ()))
    }

    pub fn into_iter_kv(self) -> KeyValueIterator<RS, K, V> {
        KeyValueIterator::from(self)
    }
    pub fn into_iter_k(self) -> KeyIterator<RS, K, V> {
        KeyIterator::from(self)
    }
    pub fn into_iter_kv_range<'q, Q>(
        self,
        q_lo: Option<&'q Q>,
        q_hi: Option<&'q Q>,
    ) -> KeyValueRangeIterator<'q, RS, K, V, Q>
    where
        K: PartialOrd<Q>,
    {
        KeyValueRangeIterator::new(self, q_lo, q_hi)
    }
}