dd5e3e8 lib: Unify buffered values — radicle-tui

Radicle terminal user interface

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);
     }
 }