#![feature(asm)]
#![feature(test)]

#[derive(Default)]
struct A {
    data: Vec<u8>,
}

impl A {
    fn find_or_insert_unsafe(&mut self, x: &u8) -> &u8 {
        if let Some(n) = self
            .data
            .iter()
            .enumerate()
            .find(|&(_, i)| i == x)
            .map(|(n, _)| n)
        {
            unsafe { self.data.get_unchecked(n) }
        } else {
            self.data.push(*x);
            self.data.last().unwrap()
        }
    }
    fn find_or_insert(&mut self, x: &u8) -> &u8 {
        if let Some(n) = self
            .data
            .iter()
            .enumerate()
            .find(|&(_, i)| i == x)
            .map(|(n, _)| n)
        {
            &self.data[n]
        } else {
            self.data.push(*x);
            self.data.last().unwrap()
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    extern crate test;
    use self::test::Bencher;

    #[inline(never)]
    fn black_box<T>(dummy: T) -> T {
        unsafe { asm!("" : : "r"(&dummy)) }
        dummy
    }

    #[inline(never)]
    fn a() -> A {
        let mut a = black_box(A{data: black_box(vec![1; 1_000_000])});
        a.data[999_999] = 77;
        a
    }

    #[bench]
    fn bench_safe(b: &mut Bencher) {
        let mut a = a();
        b.iter(|| {
            let c = a.find_or_insert(&77);
            black_box(c);
        });
        //println!("{:?}", b.bench().sum);
    }
    #[bench]
    fn bench_unsafe(b: &mut Bencher) {
        let mut a = a();
        b.iter(|| {
            let c = a.find_or_insert_unsafe(&77);
            black_box(c);
        });
        //println!("{:?}", b.bench().sum);
    }
}