1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

///Helper macro for auto_bitflags, don't call this directly.
#[macro_export]
macro_rules! auto_bitflags_h {
   (u16, $shift_num:expr, $flag_name:ident) => {
        const $flag_name: u16 = 1 << $shift_num;
   };
   
   (u32, $shift_num:expr, $flag_name:ident) => {
        const $flag_name: u32 = 1 << $shift_num;
   };
   
   (u64, $shift_num:expr, $flag_name:ident) => {
        const $flag_name: u64 = 1 << $shift_num;
   };
}

///Logarithmic identifier counting macro.
#[macro_export]
macro_rules! count_idents {
    ()        => {0usize};
    ($one:ident) => {1usize};
    ($($pairs:ident, $_p:ident), *) => {
        count_idents!($($pairs), *) << 1usize
    };
    ($odd:ident, $($rest:ident), *) => {
        count_idents!($($rest), *) | 1usize
    };
}

///The auto_bitflags! macros generates const bitflags,
///the values are assigned in descending order.
///
///# Examples
///
///```
///# #[macro_use] extern crate auto_bitflags;
///auto_bitflags!(u32, FLAG_FLAG1, FLAG_FLAG2);
///# fn main() {
///assert_eq!(0b11, FLAG_FLAG1 | FLAG_FLAG2);
///let flag12 = FLAG_FLAG1 | FLAG_FLAG2;
///assert_eq!(0b1, flag12 & FLAG_FLAG2);
///assert_eq!(0b10, flag12 & FLAG_FLAG1);
///# }
///```
#[macro_export]
macro_rules! auto_bitflags {
    (u16, $flag:ident, $($flagrest:ident), *) => {
        auto_bitflags_h!(u16, count_idents!($($flagrest),*), $flag);
        auto_bitflags!(u16, $($flagrest), *);
    };
    (u16, $flag:ident) => {
        auto_bitflags_h!(u16, 0, $flag);
    };

    (u32, $flag:ident, $($flagrest:ident), *) => {
        auto_bitflags_h!(u32, count_idents!($($flagrest),*), $flag);
        auto_bitflags!(u32, $($flagrest), *);
    };
    (u32, $flag:ident) => {
        auto_bitflags_h!(u32, 0, $flag);
    };

    (u64, $flag:ident, $($flagrest:ident), *) => {
        auto_bitflags_h!(u64, count_idents!($($flagrest),*), $flag);
        auto_bitflags!(u64, $($flagrest), *);
    };
    (u64, $flag:ident) => {
        auto_bitflags_h!(u64, 0, $flag);
    };
}

#[cfg(test)]
mod tests {
    auto_bitflags!(u16, FLAG_T1_16, FLAG_T2_16);
    #[test]
    fn test_u16() {
        assert_eq!(0b11, FLAG_T1_16 | FLAG_T2_16);
    }

    auto_bitflags!(u32, FLAG_T1_32, FLAG_T2_32);
    #[test]
    fn test_u32() {
        assert_eq!(0b11, FLAG_T1_32 | FLAG_T2_32);
    }

    auto_bitflags!(u64, FLAG_T1_64, FLAG_T2_64);
    #[test]
    fn test_u64() {
        assert_eq!(0b11, FLAG_T1_64 | FLAG_T2_64);
    }
}