andrewhickman / id-map Goto Github PK

#![forbid(unsafe_code)]

use id_map::IdMap;
use id_set::IdSet;

struct DropDetector(u32);

impl Drop for DropDetector {
    fn drop(&mut self) {
        println!("Dropping {}", self.0);
    }
}
impl Clone for DropDetector {
    fn clone(&self) -> Self { panic!("Panic on clone!"); }
}

fn main() {
    //clone_from_panic_will_drop_invalid_memory();
    //get_or_insert_with_leaves_state_inconsistent();
    remove_set_leaves_state_inconsistent_if_drop_panics();
}

fn clone_from_panic_will_drop_invalid_memory() {
    let mut map = IdMap::new();
    map.insert(DropDetector(1));

    let mut map_2 = IdMap::new();
    map_2.insert(DropDetector(2));
    map_2.clone_from(&map);
}

fn get_or_insert_with_leaves_state_inconsistent() {
    let mut map : IdMap<DropDetector> = IdMap::with_capacity(0);
    map.get_or_insert_with(0, || panic!("Panic in insertion function!"));
}

struct PanicsOnDrop(u32, bool);

impl Drop for PanicsOnDrop {
    fn drop(&mut self) {
        println!("Dropping {}", self.0);

        if (self.1) {
            self.1 = false;
            panic!("Panicking on drop");
        }
    }
}

fn remove_set_leaves_state_inconsistent_if_drop_panics() {
    let mut map = IdMap::new();
    map.insert(PanicsOnDrop(1, true));

    map.remove_set(&IdSet::new_filled(1));
}

extern crate id_map;

use id_map::IdMap;

fn main() {
    // test 1
    let mut map1 = IdMap::new();
    for _ in 0..10 {
        map1.insert("foo");
    }
    // remove all odd ids
    for i in 0..5 {
        map1.remove(i*2+1);
    }
    // prints {0, 2, 4, 6, 8}
    println!("{:?}", map1.as_set());
    // prints 1
    println!("{}", map1.next_id());

    // test2
    let mut map2 = IdMap::new();
    for _ in 0..10 {
        map2.insert("foo");
    }
    // remove all odd ids
    map2.retain(|id, _| id%2 == 0);
    // prints {0, 2, 4, 6, 8}
    println!("{:?}", map2.as_set());
    // prints 10
    println!("{}", map2.next_id());
}