lib.rs

#[macro_use]
extern crate bitflags;

pub mod appendlog {
    pub const SOFTWARE_VERSION: u8 = 0b00000001;
    bitflags! {
        flags InternalEntryFlags: u64 {
            const FLAG_HAS_CHECKSUM = 0b00000000_00000000_00000000_00000000_00000000_00000000_00000001_00000000,

            const FLAG_VERSION_MASK = 0b00000000_11111111_11111111_11111111_11111111_11111111_11111111_11111111,
            const FLAG_CHECKSUM_SIZE__MASK = 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_00000000,

            const FLAG_DYNAMIC_MASK = FLAG_VERSION_MASK.bits & FLAG_CHECKSUM_SIZE__MASK.bits,
        }
    }
    type LogFlags = EntryFlags;
    pub struct EntryFlags {
        raw_flags: InternalEntryFlags,
    }
    impl EntryFlags {
        pub fn new() -> EntryFlags {
            EntryFlags {
                raw_flags: InternalEntryFlags::empty(),
            }
        }
        pub fn is_empty(&self) -> bool {
            self.raw_flags & FLAG_DYNAMIC_MASK == InternalEntryFlags::empty()
        }
        fn slap_version(&mut self, version: u8) {
            self.raw_flags |= InternalEntryFlags::from_bits((version as u64) << 56).unwrap();
        }
        fn version(&self) -> u8 {
            (self.raw_flags.bits() >> 56) as u8
        }
    }
    pub struct Appendlog {
        flags: LogFlags,
        entries: Vec<AppendlogEntry>,
    }
    impl Appendlog {
        pub fn new() -> Appendlog {
            let mut flags = LogFlags::new();
            flags.slap_version(SOFTWARE_VERSION);
            Appendlog {
                flags: flags,
                entries: Vec::new(),
            }
        }
        pub fn version(&self) -> u8 {
            self.flags.version()
        }
        pub fn new_entry(&mut self) -> &AppendlogEntry {
            let entry = AppendlogEntry::new(&self);
            self.entries.push(entry);
            self.entries.last().unwrap()
        }
    }
    pub struct AppendlogEntry {
        flags: EntryFlags,
    }
    impl AppendlogEntry {
        pub fn new(log: &Appendlog) -> AppendlogEntry {
            let mut flags = EntryFlags::new();
            flags.slap_version(log.version());
            AppendlogEntry {
                flags: flags,
            }
        }
        pub fn version(&self) -> u8 {
            self.flags.version()
        }
    }
    #[cfg(test)]
    #[test]
    fn new_append_log_has_no_flags_but_right_version() {
        let log = Appendlog::new();
        assert!(log.flags.is_empty());
        assert_eq!(SOFTWARE_VERSION, log.version());
    }
    #[cfg(test)]
    #[test]
    fn new_log_entry_inherits_log_version() {
        let mut log = Appendlog::new();
        let entry = log.new_entry();
        assert_eq!(log.version(), entry.version());
    }
}
#[cfg(test)]
mod tests {
    // use appendlog;
}