Radish alpha
r
Radicle terminal user interface
Radicle
Git (anonymous pull)
Log in to clone via SSH
lib: Unify buffered values
Erik Kundt committed 1 year ago
commit dd5e3e8c23218c3001750605d7c2b18e4fc279e1
parent d47adcb3064683239fd8c7739718ff2da96f9589
3 files changed +102 -204
modified src/store.rs
@@ -102,105 +102,3 @@ where
        Ok(result)
    }
}
-

-
/// A `StateValue` that writes updates to an internal
-
/// buffer. This buffer can be applied or reset.
-
///
-
/// Reading from a `StateValue` will return the buffer if it's
-
/// not empty. It will return the actual value otherwise.
-
#[derive(Clone, Debug)]
-
pub struct StateValue<T>
-
where
-
    T: Clone,
-
{
-
    value: T,
-
    buffer: Option<T>,
-
}
-

-
impl<T> StateValue<T>
-
where
-
    T: Clone,
-
{
-
    pub fn new(value: T) -> Self {
-
        Self {
-
            value,
-
            buffer: None,
-
        }
-
    }
-

-
    pub fn apply(&mut self) {
-
        if let Some(buffer) = self.buffer.clone() {
-
            self.value = buffer;
-
        }
-
        self.buffer = None;
-
    }
-

-
    pub fn reset(&mut self) {
-
        self.buffer = None;
-
    }
-

-
    pub fn write(&mut self, value: T) {
-
        self.buffer = Some(value);
-
    }
-

-
    pub fn read(&self) -> T {
-
        if let Some(buffer) = self.buffer.clone() {
-
            buffer
-
        } else {
-
            self.value.clone()
-
        }
-
    }
-
}
-

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

-
    #[test]
-
    fn state_value_read_should_succeed() {
-
        let value = StateValue::new(0);
-
        assert_eq!(value.read(), 0);
-
    }
-

-
    #[test]
-
    fn state_value_read_buffer_should_succeed() {
-
        let mut value = StateValue::new(0);
-
        value.write(1);
-

-
        assert_eq!(value.read(), 1);
-
    }
-

-
    #[test]
-
    fn state_value_apply_should_succeed() {
-
        let mut value = StateValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.apply();
-
        assert_eq!(value.read(), 1);
-
    }
-

-
    #[test]
-
    fn state_value_reset_should_succeed() {
-
        let mut value = StateValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.reset();
-
        assert_eq!(value.read(), 0);
-
    }
-

-
    #[test]
-
    fn state_value_reset_after_apply_should_succeed() {
-
        let mut value = StateValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.apply();
-
        value.reset();
-
        assert_eq!(value.read(), 1);
-
    }
-
}
modified src/ui.rs
@@ -106,3 +106,105 @@ where
{
    fn rows(&self) -> Vec<TreeItem<'_, Id>>;
}
+

+
/// A `BufferedValue` that writes updates to an internal
+
/// buffer. This buffer can be applied or reset.
+
///
+
/// Reading from a `BufferedValue` will return the buffer if it's
+
/// not empty. It will return the actual value otherwise.
+
#[derive(Clone, Debug)]
+
pub struct BufferedValue<T>
+
where
+
    T: Clone,
+
{
+
    value: T,
+
    buffer: Option<T>,
+
}
+

+
impl<T> BufferedValue<T>
+
where
+
    T: Clone,
+
{
+
    pub fn new(value: T) -> Self {
+
        Self {
+
            value,
+
            buffer: None,
+
        }
+
    }
+

+
    pub fn apply(&mut self) {
+
        if let Some(buffer) = self.buffer.clone() {
+
            self.value = buffer;
+
        }
+
        self.buffer = None;
+
    }
+

+
    pub fn reset(&mut self) {
+
        self.buffer = None;
+
    }
+

+
    pub fn write(&mut self, value: T) {
+
        self.buffer = Some(value);
+
    }
+

+
    pub fn read(&self) -> T {
+
        if let Some(buffer) = self.buffer.clone() {
+
            buffer
+
        } else {
+
            self.value.clone()
+
        }
+
    }
+
}
+

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

+
    #[test]
+
    fn state_value_read_should_succeed() {
+
        let value = BufferedValue::new(0);
+
        assert_eq!(value.read(), 0);
+
    }
+

+
    #[test]
+
    fn state_value_read_buffer_should_succeed() {
+
        let mut value = BufferedValue::new(0);
+
        value.write(1);
+

+
        assert_eq!(value.read(), 1);
+
    }
+

+
    #[test]
+
    fn state_value_apply_should_succeed() {
+
        let mut value = BufferedValue::new(0);
+

+
        value.write(1);
+
        assert_eq!(value.read(), 1);
+

+
        value.apply();
+
        assert_eq!(value.read(), 1);
+
    }
+

+
    #[test]
+
    fn state_value_reset_should_succeed() {
+
        let mut value = BufferedValue::new(0);
+

+
        value.write(1);
+
        assert_eq!(value.read(), 1);
+

+
        value.reset();
+
        assert_eq!(value.read(), 0);
+
    }
+

+
    #[test]
+
    fn state_value_reset_after_apply_should_succeed() {
+
        let mut value = BufferedValue::new(0);
+

+
        value.write(1);
+
        assert_eq!(value.read(), 1);
+

+
        value.apply();
+
        value.reset();
+
        assert_eq!(value.read(), 1);
+
    }
+
}
modified src/ui/im.rs
@@ -517,105 +517,3 @@ where
            .ui(self, frame)
    }
}
-

-
/// A `BufferedValue` that writes updates to an internal
-
/// buffer. This buffer can be applied or reset.
-
///
-
/// Reading from a `BufferedValue` will return the buffer if it's
-
/// not empty. It will return the actual value otherwise.
-
#[derive(Clone, Debug)]
-
pub struct BufferedValue<T>
-
where
-
    T: Clone,
-
{
-
    value: T,
-
    buffer: Option<T>,
-
}
-

-
impl<T> BufferedValue<T>
-
where
-
    T: Clone,
-
{
-
    pub fn new(value: T) -> Self {
-
        Self {
-
            value,
-
            buffer: None,
-
        }
-
    }
-

-
    pub fn apply(&mut self) {
-
        if let Some(buffer) = self.buffer.clone() {
-
            self.value = buffer;
-
        }
-
        self.buffer = None;
-
    }
-

-
    pub fn reset(&mut self) {
-
        self.buffer = None;
-
    }
-

-
    pub fn write(&mut self, value: T) {
-
        self.buffer = Some(value);
-
    }
-

-
    pub fn read(&self) -> T {
-
        if let Some(buffer) = self.buffer.clone() {
-
            buffer
-
        } else {
-
            self.value.clone()
-
        }
-
    }
-
}
-

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

-
    #[test]
-
    fn state_value_read_should_succeed() {
-
        let value = BufferedValue::new(0);
-
        assert_eq!(value.read(), 0);
-
    }
-

-
    #[test]
-
    fn state_value_read_buffer_should_succeed() {
-
        let mut value = BufferedValue::new(0);
-
        value.write(1);
-

-
        assert_eq!(value.read(), 1);
-
    }
-

-
    #[test]
-
    fn state_value_apply_should_succeed() {
-
        let mut value = BufferedValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.apply();
-
        assert_eq!(value.read(), 1);
-
    }
-

-
    #[test]
-
    fn state_value_reset_should_succeed() {
-
        let mut value = BufferedValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.reset();
-
        assert_eq!(value.read(), 0);
-
    }
-

-
    #[test]
-
    fn state_value_reset_after_apply_should_succeed() {
-
        let mut value = BufferedValue::new(0);
-

-
        value.write(1);
-
        assert_eq!(value.read(), 1);
-

-
        value.apply();
-
        value.reset();
-
        assert_eq!(value.read(), 1);
-
    }
-
}