Macro layout

macro_rules! layout {
    (item = DualView; [] -> [$($output:tt)*]) => { ... };
    (item = DualView; [$m:literal $d:literal, $($input:tt)*] -> [$($output:tt)*]) => { ... };
    (item = DualView; [$m:literal, $($input:tt)*] -> [$($output:tt)*]) => { ... };
    (DualView; $(#[$meta:meta])* $vis:vis $ident:ident $name:ident($value:tt); $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr;) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; Undefined, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; Unknown, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; ShouldBe1, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; ShouldBe0, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; $m:literal: $n:expr, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; $m:literal $d:literal, $($input:tt)*) => { ... };
    (item = FlagType; array = $a:expr; index = $i:expr; $m:literal, $($input:tt)*) => { ... };
    (FlagType; $(#[$meta:meta])* $vis:vis $ident:ident $name:ident($value:tt); $($input:tt)*) => { ... };
    (@as_expr $expr:expr) => { ... };
    (@as_ty $ty:ty) => { ... };
    (@count_bytes u8) => { ... };
    (@count_bytes u16) => { ... };
    (@count_bytes u32) => { ... };
    (@count_bytes u64) => { ... };
    (@count_bytes u128) => { ... };
    (@count_bytes [u8; $n:expr]) => { ... };
}

Fast defining of useful types

This macro helps to implement crate::BitFieldLayout trait and create associated const layout. Macro may be used for following data types:

• DualView
• FlagType

DualView

// Data created by macro
let macro_data = {
    layout!(
        DualView;
        struct Letters(u8);
        "a",
        "b" "B",
        "c",
        "d",
        "e",
        "f" "F",
        "g" "G",
        "h" "H",
    );

    Letters(42).flags()
};
// Expands to:
let manual_data = {
    struct Letters(u8);
    impl Letters {
        const LAYOUT: [DualView<'static>; 8] = [
            DualView("a", "a"),
            DualView("b", "B"),
            DualView("c", "c"),
            DualView("d", "d"),
            DualView("e", "e"),
            DualView("f", "F"),
            DualView("g", "G"),
            DualView("h", "H"),
        ];
    }
     
    impl Layout for Letters {
        type Layout = slice::Iter<'static, DualView<'static>>;
        fn layout() -> Self::Layout { Letters::LAYOUT.iter() }
    }
    impl BitFieldLayout for Letters {
        type Value = u8;
        fn get(&self) -> Self::Value { self.0 }
        fn set(&mut self, new: Self::Value) { self.0 = new; }
    }

    Letters(42).flags()
};

assert_eq!(macro_data.collect::<Vec<_>>(), manual_data.collect::<Vec<_>>());

FlagType

let macro_data = {
    layout!(
        FlagType;
        struct EightFlags(u8);
        "Significant: meaning",
        "Significant: meaning" "Significant: description",
        "Reserved: 2 bits": 2,
        "Reserved: shouldn't exists": 0,
        ShouldBe0,
        ShouldBe1,
        Unknown,
        Undefined,
    );

    EightFlags(73).flags()
};
// Expands to:
let manual_data = {
    struct EightFlags(u8);
    impl EightFlags {
        const LAYOUT: [FlagType<'static>; 8] = [
            FlagType::Significant("Significant: meaning", "Significant: meaning"),
            FlagType::Significant("Significant: meaning", "Significant: description"),
            FlagType::Reserved("Reserved: 2 bits"),
            FlagType::Reserved("Reserved: 2 bits"),
            FlagType::ShouldBe0,
            FlagType::ShouldBe1,
            FlagType::Unknown,
            FlagType::Undefined,
        ];
    }
     
    impl Layout for EightFlags {
        type Layout = slice::Iter<'static, FlagType<'static>>;
        fn layout() -> Self::Layout { EightFlags::LAYOUT.iter() }
    }
    impl BitFieldLayout for EightFlags {
        type Value = u8;
        fn get(&self) -> Self::Value { self.0 }
        fn set(&mut self, new: Self::Value) { self.0 = new; }
    }

    EightFlags(73).flags()
};

assert_eq!(macro_data.collect::<Vec<_>>(), manual_data.collect::<Vec<_>>());