Added concurrency, pointers, oop

2 files changed, 241 insertions, 0 deletions

diff --git a/smart-pointers/Cargo.toml b/smart-pointers/Cargo.toml
new file mode 100644
index 0000000..0dcde9f
--- /dev/null
+++ b/smart-pointers/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "smart-pointers"
+version = "0.1.0"
+authors = ["Adam Carpenter <53hornet@gmail.com>"]
+edition = "2018"
+
+[dependencies]
diff --git a/smart-pointers/src/main.rs b/smart-pointers/src/main.rs
new file mode 100644
index 0000000..5a59f52
--- /dev/null
+++ b/smart-pointers/src/main.rs
@@ -0,0 +1,234 @@
+use List::{Cons, Nil};
+use std::cell::RefCell;
+use std::ops::Deref;
+use std::rc::{Rc, Weak};
+
+//enum List {
+//    Cons(i32, Rc<List>),
+//    Nil,
+//}
+
+//#[derive(Debug)]
+//enum List {
+//    Cons(Rc<RefCell<i32>>, Rc<List>),
+//    Nil,
+//}
+
+#[derive(Debug)]
+enum List {
+    Cons(i32, RefCell<Rc<List>>),
+    Nil,
+}
+
+impl List {
+    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
+        match self {
+            Cons(_, item) => Some(item),
+            Nil => None,
+        }
+    }
+}
+
+//enum List {
+//    Cons(i32, Box<List>),
+//    Nil,
+//}
+
+struct MyBox<T>(T);
+
+impl<T> MyBox<T> {
+    fn new(x: T) -> MyBox<T> {
+        MyBox(x)
+    }
+}
+
+impl<T> Deref for MyBox<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+struct CustomSmartPointer {
+    data: String,
+}
+
+impl Drop for CustomSmartPointer {
+    fn drop(&mut self) {
+        println!("Dropped `{}`", self.data);
+    }
+}
+
+#[derive(Debug)]
+struct Node {
+    value: i32,
+    parent: RefCell<Weak<Node>>,
+    children: RefCell<Vec<Rc<Node>>>,
+}
+
+fn main() {
+//    let x = 5;
+//    let y = MyBox::new(x);
+//
+//    assert_eq!(5, x);
+//    assert_eq!(5, *y);
+
+//    let m = MyBox::new(String::from("world"));
+//    hello(&m);
+
+//    let c = CustomSmartPointer { data: String::from("my stuff") };
+//    drop(c);
+//    let d = CustomSmartPointer { data: String::from("other stuff") };
+//    println!("created.");
+
+//    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
+//    dbg!(Rc::strong_count(&a));
+//    let b = Cons(3, Rc::clone(&a));
+//    dbg!(Rc::strong_count(&a));
+//    {
+//        let c = Cons(4, Rc::clone(&a));
+//        dbg!(Rc::strong_count(&a));
+//    }
+//    dbg!(Rc::strong_count(&a));
+
+//    let value = Rc::new(RefCell::new(5));
+//
+//    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
+//
+//    let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a));
+//    let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a));
+//
+//    *value.borrow_mut() += 10;
+//
+//    dbg!(a);
+//    dbg!(b);
+//    dbg!(c);
+
+//    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
+//    dbg!(Rc::strong_count(&a));
+//    dbg!(a.tail());
+//    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
+//    dbg!(Rc::strong_count(&a));
+//    dbg!(Rc::strong_count(&b));
+//    dbg!(b.tail());
+//    
+//    if let Some(link) = a.tail() {
+//        *link.borrow_mut() = Rc::clone(&b);
+//    }
+//
+//    dbg!(Rc::strong_count(&b));
+//    dbg!(Rc::strong_count(&a));
+
+    //dbg!(a.tail()); // stack overflow
+
+    let leaf = Rc::new(Node {
+        value: 3, 
+        parent: RefCell::new(Weak::new()),
+        children: RefCell::new(vec![]),
+    });
+
+    println!("leaf strong = {}, weak = {}", 
+             Rc::strong_count(&leaf), 
+             Rc::weak_count(&leaf),);
+
+    {
+        let branch = Rc::new(Node {
+            value: 5,
+            parent: RefCell::new(Weak::new()),
+            children: RefCell::new(vec![Rc::clone(&leaf)]),
+        });
+
+        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
+
+        println!(
+            "branch strong = {}, weak = {}",
+            Rc::strong_count(&branch),
+            Rc::weak_count(&branch),
+        );
+
+        println!(
+            "leaf strong = {}, weak = {}",
+            Rc::strong_count(&leaf),
+            Rc::weak_count(&leaf),
+        );
+    }
+
+    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
+    println!(
+        "leaf strong = {}, weak = {}",
+        Rc::strong_count(&leaf),
+        Rc::weak_count(&leaf),
+    );
+}
+
+fn hello(name: &str) {
+    println!("hiya {}", name);
+}
+
+pub trait Messenger {
+    fn send(&self, msg: &str);
+}
+
+pub struct LimitTracker<'a, T: 'a + Messenger> {
+    messenger: &'a T,
+    value: usize,
+    max: usize,
+}
+
+impl<'a, T> LimitTracker<'a, T> where T: Messenger {
+    pub fn new(messenger: &T, max: usize) -> LimitTracker<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("over quota");
+        }
+        else if percentage_of_max >= 0.9 {
+            self.messenger.send("90% of quota");
+        }
+        else if percentage_of_max >= 0.75 {
+            self.messenger.send("75% of 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 sends_75() {
+        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);
+    }
+}