interior mutability

Author: monnetchr

Cargo.lock

@@ -1,3 +1,3 @@
 [workspace]
 resolver = "3"
-members = ["basics","course", "guessgame", "myutils"]
+members = ["basics","course", "guessgame", "intmut", "myutils"]

Cargo.toml

@@ -6,4 +6,5 @@ edition = "2024"
 [dependencies]
 basics = { path = "../basics" }
 myutils = { path = "../myutils" }
-guessgame = { path = "../guessgame" }
+guessgame = { path = "../guessgame" }
+intmut = { path = "../intmut" }

course/Cargo.toml

@@ -1,7 +1,7 @@
 use basics;
 use myutils::stuff;
 use myutils::testing;
-use guessgame;
+//use guessgame
 
 fn main() {
     basics::basics();
@@ -10,6 +10,7 @@ fn main() {
     stuff::lifetimes();
     testing::add(2, 2);
     println!();
-    stuff::error_handling();
-    guessgame::guess_game();
+    //stuff::error_handling();
+    //guessgame::guess_game();
+    intmut::intmut();
 }

course/src/main.rs

@@ -0,0 +1,6 @@
+[package]
+name = "intmut"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

intmut/Cargo.toml

@@ -0,0 +1,97 @@
+use std::{cell::RefCell, rc::Rc};
+use List::{Cons, Nil};
+
+#[derive(Debug)]
+enum List {
+    Cons(Rc<RefCell<i32>>, Rc<List>),
+    Nil,
+}
+
+pub fn intmut() {
+    let value = Rc::new(RefCell::new(5));
+
+    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
+    println!("a before = {a:?}");
+
+    let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
+    let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
+
+    *value.borrow_mut() += 10;
+
+    println!("a after = {a:?}");
+    println!("b after = {b:?}");
+    println!("c after = {c:?}");
+}
+
+pub trait Messenger {
+    fn send(&self, msg: &str);
+}
+
+pub struct LimitTracker<'a, T: Messenger> {
+    messenger: &'a T,
+    value: usize,
+    max: usize,
+}
+
+impl<'a, T> LimitTracker<'a, T>
+where
+    T: Messenger,
+{
+    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
+        LimitTracker {
+            messenger,
+            value: 0,
+            max,
+        }
+    }
+
+    pub fn set_value(&mut self, value: usize) {
+        self.value = value;
+
+        let percentage_of_max = self.value as f64 / self.max as f64;
+
+        if percentage_of_max >= 1.0 {
+            self.messenger.send("Error: You are over your quota!");
+        } else if percentage_of_max >= 0.9 {
+            self.messenger
+                .send("Urgent warning: You've used up over 90% of your quota!");
+        } else if percentage_of_max >= 0.75 {
+            self.messenger
+                .send("Warning: You've used up over 75% of your quota!");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::RefCell;
+
+    struct MockMessenger {
+        sent_messages: RefCell<Vec<String>>,
+    }
+
+    impl MockMessenger {
+        fn new() -> MockMessenger {
+            MockMessenger {
+                sent_messages: RefCell::new(vec![]),
+            }
+        }
+    }
+
+    impl Messenger for MockMessenger {
+        fn send(&self, message: &str) {
+            self.sent_messages.borrow_mut().push(String::from(message));
+        }
+    }
+
+    #[test]
+    fn it_sends_an_over_75_percent_warning_message() {
+        let mock_messenger = MockMessenger::new();
+        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
+
+        limit_tracker.set_value(80);
+
+        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
+    }
+}