uuid.rc

#[link(name = "uuid",
       vers = "0.3.0",
       uuid = "3ef20bf5-f609-4c96-bfb5-8e617274e705")];
#[crate_type = "lib"];

extern mod std;

#[cfg(target_os = "macos")]
#[nolink]
extern mod uuid {
    fn uuid_generate(out: &mut UUID);
    fn uuid_generate_random(out: &mut UUID);
    fn uuid_generate_time(out: &mut UUID);

    fn uuid_parse(s: *u8, uuid: &UUID) -> libc::c_int;

    fn uuid_unparse(uuid: &UUID, out: *u8);
    fn uuid_unparse_lower(uuid: &UUID, out: *u8);
    fn uuid_unparse_upper(uuid: &UUID, out: *u8);
}

#[cfg(target_os = "linux")]
#[cfg(target_os = "freebsd")]
extern mod uuid {
    fn uuid_generate(out: &mut UUID);
    fn uuid_generate_random(out: &mut UUID);
    fn uuid_generate_time(out: &mut UUID);

    fn uuid_parse(s: *u8, uuid: &UUID) -> libc::c_int;

    fn uuid_unparse(uuid: &UUID, out: *u8);
    fn uuid_unparse_lower(uuid: &UUID, out: *u8);
    fn uuid_unparse_upper(uuid: &UUID, out: *u8);
}

/// a uuid value
pub struct UUID([u8, .. 36]);

impl UUID {
    /// Create a new uuid
    fn new() -> UUID {
        let mut uuid = UUID([0, ..36]);
        unsafe { uuid::uuid_generate(&mut uuid) };
        uuid
    }

    /// Create a uuid from the current time and mac address
    fn new_random() -> UUID {
        let mut uuid = UUID([0, ..36]);
        unsafe { uuid::uuid_generate_random(&mut uuid) };
        uuid
    }

    /// Create a uuid from a random number generator
    fn new_time() -> UUID {
        let mut uuid = UUID([0, ..36]);
        unsafe { uuid::uuid_generate_time(&mut uuid) };
        uuid
    }
}

impl cmp::Eq for UUID {
    fn eq(&self, other: &UUID) -> bool { **self == **other }
    fn ne(&self, other: &UUID) -> bool { !self.eq(other) }
}

impl cmp::Ord for UUID {
    fn lt(&self, other: &UUID) -> bool { **self < **other }
    fn le(&self, other: &UUID) -> bool { !(*other).lt(self) }
    fn ge(&self, other: &UUID) -> bool { !self.lt(other) }
    fn gt(&self, other: &UUID) -> bool { (*other).lt(self) }
}

/// Convert a uuid to a string
impl ToStr for UUID {
    fn to_str(&self) -> ~str {
        let mut s = str::with_capacity(36);
        do str::as_buf(s) |buf, _| {
            unsafe { uuid::uuid_unparse(self, buf) };
        }
        unsafe { str::raw::set_len(&mut s, 36u); }
        s
    }
}

/// Convert a string to a uuid
impl core::from_str::FromStr for UUID {
    fn from_str(s: &str) -> Option<UUID> {
        assert_eq!(s.len(), 36u);
        let mut uuid = UUID([0, ..36]);

        let r = do str::as_buf(s) |buf, _| {
            unsafe { uuid::uuid_parse(buf, &uuid) }
        };

        if r == 0 { Some(uuid) } else { None }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use core::from_str::FromStr;

    #[test]
    fn test_invalid() {
        let s = "                                    ";
        assert_eq!(FromStr::from_str::<UUID>(s), None);
    }

    #[test]
    fn test_valid() {
        for uint::range(0u, 100000) |_| {
            let uuid = UUID::new();
            assert!(*uuid != [0, ..36]);
            assert!(FromStr::from_str(uuid.to_str()) == Some(uuid));

            let uuid = UUID::new_random();
            assert!(*uuid != [0, ..36]);
            assert!(FromStr::from_str(uuid.to_str()) == Some(uuid));

            let uuid = UUID::new_time();
            assert!(*uuid != [0, ..36]);
            assert!(FromStr::from_str(uuid.to_str()) == Some(uuid));
        }
    }

    #[test]
    fn test_ordering() {
        let s1 = "00000000-0000-0000-0000-000000000000";
        let s2 = "00000000-0000-0000-0000-000000000001";

        let u1 = FromStr::from_str::<UUID>(s1).unwrap();
        let u2 = FromStr::from_str::<UUID>(s2).unwrap();

        assert!(u1 < u2);
        assert!(u2 > u1);

        assert!(u1 <= u1);
        assert!(u2 >= u2);
    }
}