linked list in progress

src/lib.rs

@@ -1 +1,3 @@
-pub mod linked_list;
+mod models;
+
+pub mod linked_list;

src/linked_list.rs

@@ -1,30 +1,20 @@
-use std::rc::Rc;
-
-enum Node<T> {
-    Header {
-        first: Option<Rc<Node<T>>>,
-        last: Option<Rc<Node<T>>>,
-    },
-    Child {
-        elem: T,
-        next: Rc<Node<T>>,
-        prev: Rc<Node<T>>,
-    },
-}
+use std::{cell::RefCell, rc::Rc};
+use crate::models::linked_list::{Node, SharedNode};
 
 pub struct DoublyLinkedList<T> {
     length: u64,
-    root: Node<T>,
+    root: Rc<RefCell<Node<T>>>,
 }
 
 impl<T> DoublyLinkedList<T> {
     pub fn new() -> Self {
         DoublyLinkedList {
             length: 0,
-            root: Node::Header {
-                first: None,
-                last: None,
-            },
+            root: Rc::new(RefCell::new(Node::new_head())),
         }
     }
+
+    pub fn length(&self) -> u64 {
+        self.length
+    }
 }

src/models/linked_list.rs

@@ -0,0 +1,45 @@
+use std::{cell::RefCell, rc::Rc};
+
+pub type SharedNode<T> = Rc<RefCell<Option<Node<T>>>>;
+
+#[allow(dead_code)]
+pub struct Node<T> {
+    elem: Option<T>,
+    next: SharedNode<T>,
+    prev: SharedNode<T>,
+}
+
+#[allow(dead_code)]
+impl<T> Node<T> {
+    pub fn new(value: T, next: &SharedNode<T>, prev: &SharedNode<T>) -> Self {
+        Node {
+            elem: Some(value),
+            next: Rc::clone(next),
+            prev: Rc::clone(prev),
+        }
+    }
+
+    pub fn new_head() -> Self {
+        Node {
+            elem: None,
+            next: Rc::new(RefCell::new(None)),
+            prev: Rc::new(RefCell::new(None)),
+        }
+    }
+
+    pub fn elem(&self) -> Option<&T> {
+        self.elem.as_ref()
+    }
+
+    pub fn elem_mut(&mut self) -> Option<&mut T> {
+        self.elem.as_mut()
+    }
+
+    pub fn next(&self) -> SharedNode<T> {
+        Rc::clone(&self.next)
+    }
+
+    pub fn prev(&self) -> SharedNode<T> {
+        Rc::clone(&self.prev)
+    }
+}

src/models/mod.rs

@@ -0,0 +1 @@
+pub mod linked_list;