Initial commit

Author: tomaka

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

.travis.yml

@@ -0,0 +1 @@
+language: rust

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+
+name = "ids_container"
+version = "0.1.0"
+authors = ["Pierre Krieger <[email protected]>"]
+description = "Container which automatically assigns keys when you insert in it"
+repository = "https://github.com/tomaka/rust-ids-container"
+license = "Apache-2.0"

README.md

@@ -0,0 +1,6 @@
+# ids_container
+
+```rust
+[dependencies]
+ids_container = "*"
+```

src/lib.rs

@@ -0,0 +1,104 @@
+use std::collections::hash_map::{self, HashMap};
+
+pub struct IdsContainer<T> {
+    data: HashMap<u32, T>,
+    next_id: u32
+}
+
+#[derive(Copy, Clone, Show, PartialEq, Eq, Hash)]
+pub struct Id {
+    value: u32,
+}
+
+pub struct Iter<'a, T: 'a> {
+    iter: hash_map::Iter<'a, u32, T>,
+}
+
+pub struct IterMut<'a, T: 'a> {
+    iter: hash_map::IterMut<'a, u32, T>,
+}
+
+impl<T> IdsContainer<T> {
+    pub fn new() -> IdsContainer<T> {
+        IdsContainer {
+            data: HashMap::new(),
+            next_id: 1,
+        }
+    }
+
+    /// Returns an iterator for all the keys and values in the container.
+    pub fn get<'a>(&'a self, id: &Id) -> Option<&'a T> {
+        self.data.get(&id.value)
+    }
+
+    /// Returns an iterator for all the keys and values in the container.
+    pub fn get_mut<'a>(&'a mut self, id: &Id) -> Option<&'a mut T> {
+        self.data.get_mut(&id.value)
+    }
+
+    /// Returns an iterator for all the keys and values in the container.
+    pub fn iter(&self) -> Iter<T> {
+        Iter {
+            iter: self.data.iter()
+        }
+    }
+
+    /// Returns an iterator for all the keys and values in the container.
+    pub fn iter_mut(&mut self) -> IterMut<T> {
+        IterMut {
+            iter: self.data.iter_mut()
+        }
+    }
+
+    /// Returns an iterator for all the values in the container.
+    pub fn values(&self) -> hash_map::Values<u32, T> {
+        self.data.values()
+    }
+
+    /// Returns the number of elements.
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    /// Returns true if the container is empty.
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    /// Inserts a new element and returns its identifier.
+    pub fn insert(&mut self, value: T) -> Id {
+        let new_id = self.next_id.clone();
+        self.next_id += 1;
+
+        self.data.insert(new_id, value);
+
+        Id {
+            value: new_id
+        }
+    }
+
+    /// Removes an element from the container.
+    ///
+    /// # Panic
+    ///
+    /// Panics if the `id` was already removed.
+    pub fn remove(&mut self, id: Id) {
+        self.data.remove(&id.value).unwrap();
+    }
+}
+
+impl<'a, T: 'a> Iterator for Iter<'a, T> {
+    type Item = (Id, &'a T);
+
+    fn next(&mut self) -> Option<(Id, &'a T)> {
+        self.iter.next().map(|(id, value)| (Id { value: id.clone() }, value))
+    }
+}
+
+impl<'a, T: 'a> Iterator for IterMut<'a, T> {
+    type Item = (Id, &'a mut T);
+
+    fn next(&mut self) -> Option<(Id, &'a mut T)> {
+        self.iter.next().map(|(id, value)| (Id { value: id.clone() }, value))
+    }
+}

tests/tests.rs

@@ -0,0 +1,92 @@
+extern crate ids_container;
+
+use ids_container::IdsContainer;
+
+#[test]
+fn different_ids() {
+    let mut container = IdsContainer::new();
+
+    let id1 = container.insert(5);
+    let id2 = container.insert(5);
+    let id3 = container.insert(7);
+    let id4 = container.insert(12);
+
+    assert!(id1 != id2);
+    assert!(id2 != id3);
+    assert!(id3 != id4);
+}
+
+#[test]
+fn get() {
+    let mut container = IdsContainer::new();
+
+    let id1 = container.insert(5);
+    let id2 = container.insert(8);
+
+    assert_eq!(container.get(&id1), Some(&5));
+    assert_eq!(container.get(&id2), Some(&8));
+
+    let id3 = container.insert(12);
+    container.remove(id3.clone());
+    assert_eq!(container.get(&id3), None);
+}
+
+#[test]
+fn len() {
+    let mut container = IdsContainer::new();
+    assert_eq!(container.len(), 0);
+
+    let id1 = container.insert(5);
+    assert_eq!(container.len(), 1);
+
+    let id2 = container.insert(5);
+    assert_eq!(container.len(), 2);
+
+    let id3 = container.insert(7);
+    assert_eq!(container.len(), 3);
+
+    let id4 = container.insert(12);
+    assert_eq!(container.len(), 4);
+
+    container.remove(id2);
+    assert_eq!(container.len(), 3);
+
+    container.remove(id1);
+    assert_eq!(container.len(), 2);
+
+    container.remove(id4);
+    assert_eq!(container.len(), 1);
+
+    container.remove(id3);
+    assert_eq!(container.len(), 0);
+}
+
+#[test]
+fn is_empty() {
+    let mut container = IdsContainer::new();
+    assert!(container.is_empty());
+
+    let id1 = container.insert(5);
+    assert!(!container.is_empty());
+
+    let id2 = container.insert(5);
+    assert!(!container.is_empty());
+
+    let id3 = container.insert(7);
+    assert!(!container.is_empty());
+
+    let id4 = container.insert(12);
+    assert!(!container.is_empty());
+
+    container.remove(id2);
+    assert!(!container.is_empty());
+
+    container.remove(id1);
+    assert!(!container.is_empty());
+
+    container.remove(id4);
+    assert!(!container.is_empty());
+
+    container.remove(id3);
+    assert!(container.is_empty());
+}