finished initial update of rc

Author: BartMassey

rc/examples/04-messages.rs

@@ -0,0 +1,20 @@
+use rc::message::Message;
+use rc::counter::Counter;
+
+/// Make a couple of messages with given message strings.
+pub fn make_messages(m1: &'static str, m2: &'static str)
+                 -> (Message, Message)
+{
+    let counter = Counter::default();
+    let m1 = Message::with_counter(m1, Counter::clone(&counter));
+    let m2 = Message::with_counter(m2, counter);
+    (m1, m2)
+}
+
+fn main() {
+    let (m1, m2) = make_messages("m1", "m2");
+    println!("{} {:?}", m1.text(), m1);
+    println!("{} {:?}", m2.text(), m2);
+    println!("{} {:?}", m1.text(), m1);
+    println!("{} {:?}", m2.text(), m2);
+}

rc/examples/05-cycles.rs

@@ -0,0 +1,97 @@
+// https://doc.rust-lang.org/std/cell/
+mod count;
+mod rcmessage;
+pub use rcmessage::*;
+
+impl Drop for Message {
+    fn drop(&mut self) {
+        println!("dropping {}", self.message);
+    }
+}
+
+#[derive(Clone)]
+struct MessageList<'a> {
+    cur: Message,
+    next: Option<Rc<RefCell<MessageList<'a>>>>,
+}
+
+impl<'a> MessageList<'a> {
+    fn new(cur: Message) -> MessageList<'a> {
+        MessageList { cur, next: None }
+    }
+
+    /// Print the message, then recursively print the
+    /// attached message list.
+    fn print(&self) {
+        self.cur.print();
+        if let Some(ref next) = self.next {
+            print!(" -> ");
+            next.borrow().print();
+        }
+    }
+
+    /// Add a newline.
+    fn println(&self) {
+        self.print();
+        println!();
+    }
+
+    /// Print this message and an indication of the next
+    /// message if any.
+    fn println_abbrev(&self) {
+        self.cur.print();
+        if let Some(ref next) = self.next {
+            print!(" -> ");
+            next.borrow().cur.print();
+        }
+        println!();
+    }
+}
+
+/// Show simple use of messages with shared print counter.
+fn message() {
+    let (m1, m2) = make_messages("m1", "m2");
+    m1.println();
+    m2.println();
+    m1.println();
+    m2.println();
+}
+
+/// Make a couple of message lists with given message
+/// strings and no tail.
+fn make_message_lists<'a>(m1: &'static str, m2: &'static str)
+                 -> (MessageList<'a>, MessageList<'a>)
+{
+    let (m1, m2) = make_messages(m1, m2);
+    let ml1 = MessageList::new(m1);
+    let ml2 = MessageList::new(m2);
+    (ml1, ml2)
+}
+
+/// Show simple use of message lists.
+fn message_list() {
+    let (ml3, ml4) = make_message_lists("m3", "m4");
+    ml3.println();
+    ml4.println();
+}
+
+/// Make a cyclic message list.
+fn message_list_cycle() {
+    let (ml5, ml6) = make_message_lists("m5", "m6");
+    let ml5 = Rc::new(RefCell::new(ml5));
+    let ml6 = Rc::new(RefCell::new(ml6));
+    ml5.borrow_mut().next = Some(ml6.clone());
+    ml6.borrow_mut().next = Some(ml5.clone());
+    ml5.borrow().println_abbrev();
+    ml6.borrow().println_abbrev();
+    //ml5.borrow().println();
+    //ml6.borrow().println();
+}
+
+fn main() {
+    message();
+    println!();
+    message_list();
+    println!();
+    message_list_cycle();
+}

rc/examples/06-ctr.rs

@@ -0,0 +1,14 @@
+use rc::ctr::Ctr;
+
+/// Increment the given counter. Note that this function
+/// takes `counter` by immutable reference.
+fn update_counter(counter: &Ctr) {
+    counter.incr();
+}
+
+fn main() {
+    let counter = Ctr::default();
+    println!("{}", counter.value());
+    update_counter(&counter);
+    println!("{}", counter.value());
+}

rc/src/count.rs

@@ -8,7 +8,7 @@
 //!     assert_eq!(count.value(), 1);
 
 /// A non-negative count.
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct Count(u64);
 
 impl Count {

rc/src/counter.rs

@@ -18,7 +18,7 @@ use std::cell::{RefCell, RefMut};
 use std::rc::Rc;
 
 /// An interior-mutable shared counter over the restricted `Count`.
-#[derive(Default, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct Counter(Rc<RefCell<Count>>);
 
 impl Counter {

rc/src/ctr.rs

@@ -0,0 +1,26 @@
+use std::cell::Cell;
+
+use crate::count::Count;
+
+/// An interior-mutable counter over the restricted `Count`.
+#[derive(Default)]
+pub struct Ctr(Cell<Count>);
+
+impl Ctr {
+    /// Increase the count of the contained counter by one.
+    /// Note that this method takes `self` by immutable
+    /// reference, then changes it anyway.
+    pub fn incr(&self) {
+        let mut count = self.0.replace(Count::default());
+        count.incr();
+        let _ = self.0.replace(count);
+    }
+
+    /// Return the value of the contained counter.
+    pub fn value(&self) -> u64 {
+        let count = self.0.replace(Count::default());
+        let value = count.value();
+        let _ = self.0.replace(count);
+        value
+    }
+}

rc/src/lib.rs

@@ -3,3 +3,4 @@
 pub mod count;
 pub mod counter;
 pub mod message;
+pub mod ctr;

rc/src/message.rs

@@ -14,7 +14,7 @@
 use crate::counter::Counter;
 
 /// Message to print plus usage counter.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Message {
     /// Message text.
     message: &'static str,
@@ -30,6 +30,12 @@ impl Message {
         Message { message, counter: Counter::default() }
     }
 
+    /// Make a new message with provided counter.
+    pub fn with_counter(message: &'static str, counter: Counter) -> Message
+    {
+        Message { message, counter }
+    }
+
     /// Access the message text.
     pub fn text(&self) -> &'static str {
         self.counter.incr();