Vendor dependencies for 0.3.0 release

vendor/slotmap/examples/doubly_linked_list.rs

@@ -0,0 +1,135 @@
+// A simple doubly linked list example using slotmap.
+
+use slotmap::{new_key_type, Key, SlotMap};
+
+new_key_type! {
+    pub struct ListKey;
+}
+
+#[derive(Copy, Clone)]
+struct Node<T> {
+    value: T,
+    prev: ListKey,
+    next: ListKey,
+}
+
+pub struct List<T> {
+    sm: SlotMap<ListKey, Node<T>>,
+    head: ListKey,
+    tail: ListKey,
+}
+
+impl<T> List<T> {
+    pub fn new() -> Self {
+        Self {
+            sm: SlotMap::with_key(),
+            head: ListKey::null(),
+            tail: ListKey::null(),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.sm.len()
+    }
+
+    pub fn push_head(&mut self, value: T) -> ListKey {
+        let k = self.sm.insert(Node {
+            value,
+            prev: ListKey::null(),
+            next: self.head,
+        });
+
+        if let Some(old_head) = self.sm.get_mut(self.head) {
+            old_head.prev = k;
+        } else {
+            self.tail = k;
+        }
+        self.head = k;
+        k
+    }
+
+    pub fn push_tail(&mut self, value: T) -> ListKey {
+        let k = self.sm.insert(Node {
+            value,
+            prev: self.tail,
+            next: ListKey::null(),
+        });
+
+        if let Some(old_tail) = self.sm.get_mut(self.tail) {
+            old_tail.next = k;
+        } else {
+            self.head = k;
+        }
+        self.tail = k;
+        k
+    }
+
+    pub fn pop_head(&mut self) -> Option<T> {
+        self.sm.remove(self.head).map(|old_head| {
+            self.head = old_head.next;
+            old_head.value
+        })
+    }
+
+    pub fn pop_tail(&mut self) -> Option<T> {
+        self.sm.remove(self.tail).map(|old_tail| {
+            self.tail = old_tail.prev;
+            old_tail.value
+        })
+    }
+
+    pub fn remove(&mut self, key: ListKey) -> Option<T> {
+        self.sm.remove(key).map(|node| {
+            if let Some(prev_node) = self.sm.get_mut(node.prev) {
+                prev_node.next = node.next;
+            } else {
+                self.head = node.next;
+            }
+
+            if let Some(next_node) = self.sm.get_mut(node.next) {
+                next_node.prev = node.prev;
+            } else {
+                self.tail = node.prev;
+            }
+
+            node.value
+        })
+    }
+
+    pub fn head(&self) -> ListKey {
+        self.head
+    }
+
+    pub fn tail(&self) -> ListKey {
+        self.tail
+    }
+
+    pub fn get(&self, key: ListKey) -> Option<&T> {
+        self.sm.get(key).map(|node| &node.value)
+    }
+
+    pub fn get_mut(&mut self, key: ListKey) -> Option<&mut T> {
+        self.sm.get_mut(key).map(|node| &mut node.value)
+    }
+}
+
+fn main() {
+    let mut dll = List::new();
+    dll.push_head(5);
+    dll.push_tail(6);
+    let k = dll.push_head(3);
+    dll.push_tail(7);
+    dll.push_head(4);
+
+    assert_eq!(dll.len(), 4);
+    assert_eq!(dll.pop_head(), Some(4));
+    assert_eq!(dll.pop_head(), Some(5));
+    assert_eq!(dll.head(), k);
+    dll.push_head(10);
+    assert_eq!(dll.remove(k), Some(3));
+    assert_eq!(dll.pop_tail(), Some(7));
+    assert_eq!(dll.pop_tail(), Some(6));
+    assert_eq!(dll.pop_head(), Some(10));
+    assert_eq!(dll.pop_head(), None);
+    assert_eq!(dll.pop_tail(), None);
+}

vendor/slotmap/examples/rand_meld_heap.rs

@@ -0,0 +1,174 @@
+// Randomized meldable heap.
+// https://en.wikipedia.org/wiki/Randomized_meldable_heap
+
+use slotmap::{new_key_type, Key, SlotMap};
+
+new_key_type! {
+    struct HeapKey;
+}
+
+#[derive(Copy, Clone)]
+struct NodeHandle(HeapKey);
+
+#[derive(Copy, Clone)]
+struct Node<T> {
+    value: T,
+    children: [HeapKey; 2],
+    parent: HeapKey,
+}
+
+struct RandMeldHeap<T: Ord> {
+    sm: SlotMap<HeapKey, Node<T>>,
+    rng: std::num::Wrapping<u32>,
+    root: HeapKey,
+}
+
+impl<T: Ord + std::fmt::Debug> RandMeldHeap<T> {
+    pub fn new() -> Self {
+        Self {
+            sm: SlotMap::with_key(),
+            rng: std::num::Wrapping(0xdead_beef),
+            root: HeapKey::null(),
+        }
+    }
+
+    pub fn coinflip(&mut self) -> bool {
+        // Simple LCG for top speed - random quality barely matters.
+        self.rng += (self.rng << 8) + std::num::Wrapping(1);
+        self.rng >> 31 > std::num::Wrapping(0)
+    }
+
+    pub fn insert(&mut self, value: T) -> NodeHandle {
+        let k = self.sm.insert(Node {
+            value,
+            children: [HeapKey::null(), HeapKey::null()],
+            parent: HeapKey::null(),
+        });
+
+        let root = self.root;
+        self.root = self.meld(k, root);
+
+        NodeHandle(k)
+    }
+
+    pub fn pop(&mut self) -> Option<T> {
+        self.sm.remove(self.root).map(|root| {
+            self.root = self.meld(root.children[0], root.children[1]);
+            if let Some(new_root) = self.sm.get_mut(self.root) {
+                new_root.parent = HeapKey::null();
+            }
+
+            root.value
+        })
+    }
+
+    pub fn remove_key(&mut self, node: NodeHandle) -> T {
+        let node = node.0;
+        self.unlink_node(node);
+        self.sm.remove(node).unwrap().value
+    }
+
+    pub fn update_key(&mut self, node: NodeHandle, value: T) {
+        let node = node.0;
+
+        // Unlink and re-insert.
+        self.unlink_node(node);
+        self.sm[node] = Node {
+            value,
+            children: [HeapKey::null(), HeapKey::null()],
+            parent: HeapKey::null(),
+        };
+        let root = self.root;
+        self.root = self.meld(node, root);
+    }
+
+    fn unlink_node(&mut self, node: HeapKey) {
+        // Remove node from heap by merging children and placing them where
+        // node used to be.
+        let children = self.sm[node].children;
+        let parent_key = self.sm[node].parent;
+
+        let melded_children = self.meld(children[0], children[1]);
+        if let Some(mc) = self.sm.get_mut(melded_children) {
+            mc.parent = parent_key;
+        }
+
+        if let Some(parent) = self.sm.get_mut(parent_key) {
+            if parent.children[0] == node {
+                parent.children[0] = melded_children;
+            } else {
+                parent.children[1] = melded_children;
+            }
+        } else {
+            self.root = melded_children;
+        }
+    }
+
+    fn meld(&mut self, mut a: HeapKey, mut b: HeapKey) -> HeapKey {
+        if a.is_null() {
+            return b;
+        }
+        if b.is_null() {
+            return a;
+        }
+
+        if self.sm[a].value > self.sm[b].value {
+            std::mem::swap(&mut a, &mut b);
+        }
+
+        let ret = a;
+
+        // From this point parent and trickle are assumed to be valid keys.
+        let mut parent = a;
+        let mut trickle = b;
+
+        loop {
+            // If a child spot is free, put our trickle there.
+            let children = self.sm[parent].children;
+            if children[0].is_null() {
+                self.sm[parent].children[0] = trickle;
+                self.sm[trickle].parent = parent;
+                break;
+            } else if children[1].is_null() {
+                self.sm[parent].children[1] = trickle;
+                self.sm[trickle].parent = parent;
+                break;
+            }
+
+            // No spot free, choose a random child.
+            let c = self.coinflip() as usize;
+            let child = children[c];
+            if self.sm[child].value > self.sm[trickle].value {
+                self.sm[parent].children[c] = trickle;
+                self.sm[trickle].parent = parent;
+                parent = trickle;
+                trickle = child;
+            } else {
+                parent = child;
+            }
+        }
+
+        ret
+    }
+
+    pub fn len(&self) -> usize {
+        self.sm.len()
+    }
+}
+
+fn main() {
+    let mut rhm = RandMeldHeap::new();
+    let the_answer = rhm.insert(-2);
+    let big = rhm.insert(999);
+
+    for k in (0..10).rev() {
+        rhm.insert(k * k);
+    }
+
+    rhm.update_key(the_answer, 42);
+    rhm.remove_key(big);
+
+    while rhm.len() > 0 {
+        println!("{}", rhm.pop().unwrap());
+    }
+}