disklru 0.3.3

// Copyright (C) 2024 Christian Mauduit <ufoot@ufoot.org>

use crate::error::*;
use crate::store::*;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::fmt;

/// Iterator over a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// for item in store.iter() {
///     match item {
///         Ok(kv) => println!("key: {}, value: {}", kv.0, kv.1),
///         Err(e) => panic!("ERROR: {}", e),
///     }
/// }
/// ```
#[derive(Debug)]
pub struct Iter<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) pos: Option<K>,
    pub(crate) done: usize,
    pub(crate) store: &'a Store<K, V>,
}

impl<K, V> fmt::Display for Iter<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}/{}", self.done, self.store.len())
    }
}

impl<'a, K, V> Iterator for Iter<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = Result<(K, V)>;

    fn next(&mut self) -> Option<Result<(K, V)>> {
        if self.done >= self.store.len() {
            return None;
        }
        // Always increment, even if we get error, else we could loop forever.
        self.done += 1;
        if self.done == 1 && self.store.len > 0 {
            self.pos = match self.store.find_tail() {
                Ok(tail) => match tail {
                    Some(tail) => Some(tail),
                    None => return Some(Err(Error::report_bug("unable to iterate, no tail"))),
                },
                Err(e) => {
                    return Some(Err(Error::report_bug(&format!(
                        "error getting tail: {}",
                        e
                    ))))
                }
            }
        }
        match &self.pos {
            Some(pos) => match self.store.peek_node(&pos) {
                Ok(node) => match node {
                    Some(node) => {
                        // Walk "backwards", we usually want to iterate,
                        // either to display or use, from LRU to MRU
                        // but following next we'd go from MRU to LRU.
                        self.pos = Some(node.link.prev);
                        Some(Ok((node.data.key, node.data.value)))
                    }
                    None => None,
                },
                Err(e) => Some(Err(e)),
            },
            None => Some(Err(Error::report_bug("iterated value could not be found"))),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        if self.done < self.store.len() {
            let size = self.store.len() - self.done;
            (size, Some(size))
        } else {
            (0, Some(0))
        }
    }
}

/// Iterator over the keys of a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// for item in store.keys() {
///     match item {
///         Ok(k) => println!("key: {}", k),
///         Err(e) => panic!("ERROR: {}", e),
///     }
/// }
/// ```
#[derive(Debug)]
pub struct Keys<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) iter: Iter<'a, K, V>,
}

impl<K, V> fmt::Display for Keys<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.iter)
    }
}

impl<'a, K, V> Iterator for Keys<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = Result<K>;

    fn next(&mut self) -> Option<Result<K>> {
        match self.iter.next() {
            Some(item) => match item {
                Ok(item) => Some(Ok(item.0)),
                Err(e) => Some(Err(e)),
            },
            None => None,
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

/// Iterator over the values of a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// for item in store.values() {
///     match item {
///         Ok(v) => println!("value: {}", v),
///         Err(e) => panic!("ERROR: {}", e),
///     }
/// }
/// ```
#[derive(Debug)]
pub struct Values<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) iter: Iter<'a, K, V>,
}

impl<K, V> fmt::Display for Values<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.iter)
    }
}

impl<'a, K, V> Iterator for Values<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = Result<V>;

    fn next(&mut self) -> Option<Result<V>> {
        match self.iter.next() {
            Some(item) => match item {
                Ok(item) => Some(Ok(item.1)),
                Err(e) => Some(Err(e)),
            },
            None => None,
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

/// Export a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// The difference with a standard iterator is that this iterator
/// will panic if there is some I/O problem. OTOH it offers a simpler,
/// friendly interface without the need to handle errors on each iteration.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// store.export().map(|kv| println!("key: {}, value: {}", kv.0, kv.1));
///
/// let mut export = store.export();
/// match export.try_next() {
///     Ok(item) => assert_eq!(Some((String::from("x"), 1)), item),
///     Err(e) => panic!("ERROR: {}", e),
/// }
/// ```
#[derive(Debug)]
pub struct Export<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) pos: Option<K>,
    pub(crate) done: usize,
    pub(crate) store: &'a Store<K, V>,
}

impl<K, V> fmt::Display for Export<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}/{}", self.done, self.store.len())
    }
}

impl<'a, K, V> Export<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub fn try_next(&mut self) -> Result<Option<(K, V)>> {
        if self.done >= self.store.len() {
            return Ok(None);
        }
        // Always increment, even if we get error, else we could loop forever.
        self.done += 1;
        if self.done == 1 && self.store.len > 0 {
            self.pos = self.store.find_tail()?;
        }
        match &self.pos {
            Some(pos) => {
                let node = self.store.peek_node(&pos)?;
                match node {
                    Some(node) => {
                        // Walk "backwards", we usually want to iterate,
                        // either to display or use, from LRU to MRU
                        // but following next we'd go from MRU to LRU.
                        self.pos = Some(node.link.prev);
                        Ok(Some((node.data.key, node.data.value)))
                    }
                    None => Err(Error::report_bug("exported item could not be found")),
                }
            }
            None => Ok(None),
        }
    }
}

impl<'a, K, V> Iterator for Export<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = (K, V);

    fn next(&mut self) -> Option<(K, V)> {
        match self.try_next() {
            Ok(kv) => kv,
            Err(e) => panic!("can not export next item: {}", e),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        if self.done < self.store.len() {
            let size = self.store.len() - self.done;
            (size, Some(size))
        } else {
            (0, Some(0))
        }
    }
}

/// Export the keys of a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// The difference with a standard iterator is that this iterator
/// will panic if there is some I/O problem. OTOH it offers a simpler,
/// friendly interface without the need to handle errors on each iteration.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// store.export_keys().map(|k| println!("key: {}", k));
///
/// let mut export = store.export_keys();
/// match export.try_next() {
///     Ok(key) => assert_eq!(Some(String::from("x")), key),
///     Err(e) => panic!("ERROR: {}", e),
/// }
/// ```
#[derive(Debug)]
pub struct ExportKeys<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) export: Export<'a, K, V>,
}

impl<K, V> fmt::Display for ExportKeys<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.export)
    }
}

impl<'a, K, V> ExportKeys<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub fn try_next(&mut self) -> Result<Option<K>> {
        match self.export.try_next() {
            Ok(item) => match item {
                Some(kv) => Ok(Some(kv.0)),
                None => Ok(None),
            },
            Err(e) => Err(e),
        }
    }
}

impl<'a, K, V> Iterator for ExportKeys<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = K;

    fn next(&mut self) -> Option<K> {
        match self.try_next() {
            Ok(k) => k,
            Err(e) => panic!("can not export next key: {}", e),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.export.size_hint()
    }
}

/// Export the values of a LRU store.
///
/// The order of the iterated entries is guaranteed, it starts
/// from the oldest (LRU) entry, and finishes by the most recent (MRU) entry.
///
/// The difference with a standard iterator is that this iterator
/// will panic if there is some I/O problem. OTOH it offers a simpler,
/// friendly interface without the need to handle errors on each iteration.
///
/// # Examples
///
/// ```
/// use disklru::Store;
///
/// let mut store: Store<String, usize> = Store::open_temporary(10).unwrap();
/// store.insert(&String::from("x"), &1);
/// store.insert(&String::from("y"), &10);
/// store.insert(&String::from("z"), &100);
///
/// store.export_values().map(|v| println!("value: {}", v));
///
/// let mut export = store.export_values();
/// match export.try_next() {
///     Ok(value) => assert_eq!(Some(1), value),
///     Err(e) => panic!("ERROR: {}", e),
/// }
/// ```
#[derive(Debug)]
pub struct ExportValues<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub(crate) export: Export<'a, K, V>,
}

impl<K, V> fmt::Display for ExportValues<'_, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.export)
    }
}

impl<'a, K, V> ExportValues<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    pub fn try_next(&mut self) -> Result<Option<V>> {
        match self.export.try_next() {
            Ok(item) => match item {
                Some(kv) => Ok(Some(kv.1)),
                None => Ok(None),
            },
            Err(e) => Err(e),
        }
    }
}

impl<'a, K, V> Iterator for ExportValues<'a, K, V>
where
    K: Serialize + DeserializeOwned + Eq,
    V: Serialize + DeserializeOwned,
{
    type Item = V;

    fn next(&mut self) -> Option<V> {
        match self.try_next() {
            Ok(k) => k,
            Err(e) => panic!("can not export next value: {}", e),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.export.size_hint()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_iter_1() {
        let mut store: Store<usize, usize> = Store::open_temporary(10).unwrap();
        assert_eq!(10, store.capacity());
        assert_eq!(0, store.len());

        {
            let mut iter = store.export();
            assert_eq!(None, iter.next());
        }

        assert_eq!(None, store.insert(&1, &10).unwrap());

        {
            let mut iter = store.export();
            assert_eq!(Some((1, 10)), iter.next());
            assert_eq!(None, iter.next());
        }
    }

    #[test]
    fn test_iter() {
        let mut store: Store<usize, usize> = Store::open_temporary(3).unwrap();
        assert_eq!(3, store.capacity());
        assert_eq!(0, store.len());

        for i in 0..100 as usize {
            store.push(&i, &(i * 10)).unwrap();
        }
        let mut iter = store.export();
        assert_eq!(Some((97, 970)), iter.next());
        assert_eq!(Some((98, 980)), iter.next());
        assert_eq!(Some((99, 990)), iter.next());
        assert_eq!(None, iter.next());
        assert_eq!(None, iter.next());
    }
}