bitack 0.1.1

Library for defining and manipulating binary formats using declarative bit schemes.
Documentation
use crate::{utils};
use utils::bitmask::BitMaskApplicator;

pub enum BitField {
    Next(u32),
    Skip(u32),
    LeadingZeros(u32),
    LeadingOnes(u32)
}

pub struct Resolver {
    pub applicator: BitMaskApplicator<u32>,
    pub resolver: ResolverType,
}

pub enum ResolverType {
    Base,
    LeadingOnes,
    LeadingZeros,
}

pub struct ResolverOutput {
    pub resolver: Option<Resolver>,
    pub acc: u32
}

impl BitField {
    pub fn resolve(&self, acc: u32) -> ResolverOutput {
        let bits = match self {
            BitField::Next(b)
            | BitField::Skip(b)
            | BitField::LeadingOnes(b)
            | BitField::LeadingZeros(b)
            => *b
        };

        let resolver = match self {
            BitField::Next(..) => ResolverType::Base,
            BitField::LeadingOnes(..) => ResolverType::LeadingOnes,
            BitField::LeadingZeros(..) => ResolverType::LeadingZeros,
            _ => ResolverType::Base
        };

        let resolver = {
            if let BitField::Skip(..) = self { None }
            else { Some(Resolver {
                    applicator: BitMaskApplicator::new(bits as usize, acc),
                    resolver: resolver
                })
            }
        };

        ResolverOutput { 
            resolver,
            acc: acc + bits
        }
    }
}

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

    fn unwrap_resolver_info(resolver: &ResolverOutput) -> u32 {
        if let Some(resolver) = &resolver.resolver {
            return resolver.applicator.mask;
        }

        0
    }

    #[test]
    fn resolver() {
        let cases = vec![
            (BitField::Next(8).resolve(0), 0xFF << 24),
            (BitField::Next(3).resolve(0), 0xE0 << 24),
            (BitField::Next(3).resolve(16), 0xE0 << 8),
            (BitField::LeadingOnes(4).resolve(0), 0xF0 << 24),
            (BitField::LeadingZeros(4).resolve(8), 0xF0 << 16),
        ];
        
        for (resolver, expected_mask) in cases {
            let mask = unwrap_resolver_info(&resolver);
            
            assert_eq!(expected_mask, mask);
        }
    }
}