pddbmap.rs

use pddb::Pddb;
use std::io::Read;
use std::io::Write;
use xous::Error;

pub struct PddbMap {
    basis_name: String,
    dict_name: String,
    pddb_inst: pddb::Pddb,
}

#[derive(Debug)]
pub enum MapError {
    KeyNotFound(String),
}

impl PddbMap {
    pub fn new(basis_name: &str, dict_name: &str) -> Self {
        PddbMap {
            basis_name: String::from(basis_name),
            dict_name: String::from(dict_name),
            pddb_inst: Pddb::new(),
        }
    }

    pub fn set_dict(&mut self, dict_name: &str) {
        self.dict_name = String::from(dict_name);
    }

    pub fn set(&mut self, key: &str, value: &[u8]) {
        let mut key = self
            .pddb_inst
            .get(
                &self.dict_name,
                key,
                Some(&self.basis_name),
                true,
                true,
                None,
                None::<fn()>,
            )
            .expect("cannot create key");

        key.write_all(value)
            .expect("cannot write entirety of value to key")
    }

    pub fn get(&mut self, key: &str) -> Result<Vec<u8>, MapError> {
        let mut pkey = match self.pddb_inst.get(
            &self.dict_name,
            key,
            Some(&self.basis_name),
            false,
            false,
            None,
            None::<fn()>,
        ) {
            Ok(key) => key,
            Err(..) => {
                return Err(MapError::KeyNotFound(String::from(key)));
            }
        };

        let attrs = pkey.attributes().expect("cannot fetch key attributes");
        let mut data = vec![];
        pkey.read_to_end(&mut data);

        Ok(data)
    }
}