Lines Matching refs:Flags
24 //! struct Flags: u32 {
33 //! let e1 = Flags::A | Flags::C;
34 //! let e2 = Flags::B | Flags::C;
35 //! assert_eq!((e1 | e2), Flags::ABC); // union
36 //! assert_eq!((e1 & e2), Flags::C); // intersection
37 //! assert_eq!((e1 - e2), Flags::A); // set difference
38 //! assert_eq!(!e2, Flags::A); // set complement
42 //! See [`example_generated::Flags`](./example_generated/struct.Flags.html) for documentation of code
54 //! struct Flags: u32 {
60 //! impl Flags {
67 //! impl fmt::Display for Flags {
74 //! let mut flags = Flags::A | Flags::B;
78 //! assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
79 //! assert_eq!(format!("{:?}", Flags::B), "B");
126 //! struct Flags: u32 {
208 //! struct Flags: u32 {
216 //! let derived_default: Flags = Default::default();
227 //! struct Flags: u32 {
235 //! impl Default for Flags {
236 //! fn default() -> Flags {
237 //! Flags::A | Flags::C
242 //! let implemented_default: Flags = Default::default();
243 //! assert_eq!(implemented_default, (Flags::A | Flags::C));
247 //! # Zero Flags
249 //! Flags with a value equal to zero will have some strange behavior that one should be aware of.
255 //! struct Flags: u32 {
262 //! let empty = Flags::empty();
263 //! let none = Flags::NONE;
264 //! let some = Flags::SOME;
267 //! assert!(empty.contains(Flags::NONE));
268 //! assert!(none.contains(Flags::NONE));
269 //! assert!(some.contains(Flags::NONE));
294 /// struct Flags: u32 {
303 /// let e1 = Flags::A | Flags::C;
304 /// let e2 = Flags::B | Flags::C;
305 /// assert_eq!((e1 | e2), Flags::ABC); // union
306 /// assert_eq!((e1 & e2), Flags::C); // intersection
307 /// assert_eq!((e1 - e2), Flags::A); // set difference
308 /// assert_eq!(!e2, Flags::A); // set complement
321 /// struct Flags: u32 {
327 /// impl Flags {
334 /// impl fmt::Display for Flags {
341 /// let mut flags = Flags::A | Flags::B;
345 /// assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
346 /// assert_eq!(format!("{:?}", Flags::B), "B");
948 struct Flags: u32 {
984 assert_eq!(Flags::empty().bits(), 0b00000000);
985 assert_eq!(Flags::A.bits(), 0b00000001);
986 assert_eq!(Flags::ABC.bits(), 0b00000111);
996 assert_eq!(Flags::from_bits(0), Some(Flags::empty()));
997 assert_eq!(Flags::from_bits(0b1), Some(Flags::A));
998 assert_eq!(Flags::from_bits(0b10), Some(Flags::B));
999 assert_eq!(Flags::from_bits(0b11), Some(Flags::A | Flags::B));
1000 assert_eq!(Flags::from_bits(0b1000), None);
1013 assert_eq!(Flags::from_bits_truncate(0), Flags::empty());
1014 assert_eq!(Flags::from_bits_truncate(0b1), Flags::A);
1015 assert_eq!(Flags::from_bits_truncate(0b10), Flags::B);
1016 assert_eq!(Flags::from_bits_truncate(0b11), (Flags::A | Flags::B));
1017 assert_eq!(Flags::from_bits_truncate(0b1000), Flags::empty());
1018 assert_eq!(Flags::from_bits_truncate(0b1001), Flags::A);
1031 let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
1032 assert_eq!(unsafe { Flags::from_bits_unchecked(0) }, Flags::empty());
1033 assert_eq!(unsafe { Flags::from_bits_unchecked(0b1) }, Flags::A);
1034 assert_eq!(unsafe { Flags::from_bits_unchecked(0b10) }, Flags::B);
1037 unsafe { Flags::from_bits_unchecked(0b11) },
1038 (Flags::A | Flags::B)
1041 unsafe { Flags::from_bits_unchecked(0b1000) },
1042 (extra | Flags::empty())
1045 unsafe { Flags::from_bits_unchecked(0b1001) },
1046 (extra | Flags::A)
1058 assert!(Flags::empty().is_empty());
1059 assert!(!Flags::A.is_empty());
1060 assert!(!Flags::ABC.is_empty());
1070 assert!(Flags::all().is_all());
1071 assert!(!Flags::A.is_all());
1072 assert!(Flags::ABC.is_all());
1074 let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
1076 assert!(!(Flags::A | extra).is_all());
1077 assert!((Flags::ABC | extra).is_all());
1087 let e1 = Flags::empty();
1088 let e2 = Flags::empty();
1096 let e1 = Flags::empty();
1097 let e2 = Flags::ABC;
1103 let e1 = Flags::A;
1104 let e2 = Flags::B;
1110 let e1 = Flags::A;
1111 let e2 = Flags::A | Flags::B;
1117 let e1 = Flags::A;
1118 let e2 = Flags::A | Flags::B;
1121 assert!(Flags::ABC.contains(e2));
1130 let mut e1 = Flags::A;
1131 let e2 = Flags::A | Flags::B;
1142 let mut e1 = Flags::A | Flags::B;
1143 let e2 = Flags::A | Flags::C;
1145 assert_eq!(e1, Flags::B);
1154 let e1 = Flags::A | Flags::C;
1155 let e2 = Flags::B | Flags::C;
1156 assert_eq!((e1 | e2), Flags::ABC); // union
1157 assert_eq!((e1 & e2), Flags::C); // intersection
1158 assert_eq!((e1 - e2), Flags::A); // set difference
1159 assert_eq!(!e2, Flags::A); // set complement
1160 assert_eq!(e1 ^ e2, Flags::A | Flags::B); // toggle
1163 assert_eq!(e3, Flags::A | Flags::B);
1172 let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
1173 let e1 = Flags::A | Flags::C | extra;
1174 let e2 = Flags::B | Flags::C;
1175 assert_eq!((e1 | e2), (Flags::ABC | extra)); // union
1176 assert_eq!((e1 & e2), Flags::C); // intersection
1177 assert_eq!((e1 - e2), (Flags::A | extra)); // set difference
1178 assert_eq!(!e2, Flags::A); // set complement
1179 assert_eq!(!e1, Flags::B); // set complement
1180 assert_eq!(e1 ^ e2, Flags::A | Flags::B | extra); // toggle
1183 assert_eq!(e3, Flags::A | Flags::B | extra);
1188 let ab = Flags::A.union(Flags::B);
1189 let ac = Flags::A.union(Flags::C);
1190 let bc = Flags::B.union(Flags::C);
1195 assert_eq!(ab, Flags::B.union(Flags::A));
1196 assert_eq!(ac, Flags::C.union(Flags::A));
1197 assert_eq!(bc, Flags::C.union(Flags::B));
1199 assert_eq!(ac, Flags::A | Flags::C);
1200 assert_eq!(bc, Flags::B | Flags::C);
1201 assert_eq!(ab.union(bc), Flags::ABC);
1203 assert_eq!(ac, Flags::A | Flags::C);
1204 assert_eq!(bc, Flags::B | Flags::C);
1207 assert_eq!(ac.union(bc), Flags::ABC);
1208 assert_eq!(bc.union(ac), Flags::ABC);
1211 assert_eq!(ac.intersection(bc), Flags::C);
1212 assert_eq!(bc.intersection(ac), Flags::C);
1216 assert_eq!(ac.difference(bc), Flags::A);
1217 assert_eq!(bc.difference(ac), Flags::B);
1220 assert_eq!(bc.complement(), Flags::A);
1221 assert_eq!(ac.symmetric_difference(bc), Flags::A.union(Flags::B));
1222 assert_eq!(bc.symmetric_difference(ac), Flags::A.union(Flags::B));
1229 const INTERSECT: Flags = Flags::all().intersection(Flags::C);
1230 const UNION: Flags = Flags::A.union(Flags::C);
1231 const DIFFERENCE: Flags = Flags::all().difference(Flags::A);
1232 const COMPLEMENT: Flags = Flags::C.complement();
1233 const SYM_DIFFERENCE: Flags = UNION.symmetric_difference(DIFFERENCE);
1234 assert_eq!(INTERSECT, Flags::C);
1235 assert_eq!(UNION, Flags::A | Flags::C);
1236 assert_eq!(DIFFERENCE, Flags::all() - Flags::A);
1237 assert_eq!(COMPLEMENT, !Flags::C);
1238 assert_eq!(SYM_DIFFERENCE, (Flags::A | Flags::C) ^ (Flags::all() - Flags::A));
1243 let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
1244 let e1 = Flags::A.union(Flags::C).union(extra);
1245 let e2 = Flags::B.union(Flags::C);
1247 assert_eq!(e1.union(e2), (Flags::ABC | extra));
1248 assert_eq!(e1.intersection(e2), Flags::C);
1249 assert_eq!(e1.difference(e2), Flags::A | extra);
1250 assert_eq!(e2.difference(e1), Flags::B);
1251 assert_eq!(e2.complement(), Flags::A);
1252 assert_eq!(e1.complement(), Flags::B);
1253 assert_eq!(e1.symmetric_difference(e2), Flags::A | Flags::B | extra); // toggle
1370 let mut e1 = Flags::A | Flags::C;
1371 e1.set(Flags::B, true);
1372 e1.set(Flags::C, false);
1374 assert_eq!(e1, Flags::A | Flags::B);
1379 let mut m1 = Flags::empty();
1380 let e1 = Flags::A | Flags::C;
1382 m1 |= Flags::A;
1383 assert_eq!(m1, Flags::A);
1386 assert_eq!(m1, Flags::A);
1389 assert_eq!(m1, Flags::empty());
1397 const _M1: Flags = Flags::empty();
1399 const M2: Flags = Flags::A;
1400 assert_eq!(M2, Flags::A);
1402 const M3: Flags = Flags::C;
1403 assert_eq!(M3, Flags::C);
1410 flags = Flags::empty();
1412 assert_eq!(flags, Flags::empty());
1414 flags = Flags::empty();
1415 flags.extend([Flags::A, Flags::B].iter().cloned());
1416 assert_eq!(flags, Flags::A | Flags::B);
1418 flags = Flags::A;
1419 flags.extend([Flags::A, Flags::B].iter().cloned());
1420 assert_eq!(flags, Flags::A | Flags::B);
1422 flags = Flags::B;
1423 flags.extend([Flags::A, Flags::ABC].iter().cloned());
1424 assert_eq!(flags, Flags::ABC);
1429 assert_eq!([].iter().cloned().collect::<Flags>(), Flags::empty());
1431 [Flags::A, Flags::B].iter().cloned().collect::<Flags>(),
1432 Flags::A | Flags::B
1435 [Flags::A, Flags::ABC].iter().cloned().collect::<Flags>(),
1436 Flags::ABC
1442 let mut a = Flags::empty();
1443 let mut b = Flags::empty();
1446 b = Flags::B;
1448 a = Flags::C;
1450 b = Flags::C | Flags::B;
1456 let mut a = Flags::empty();
1457 let mut b = Flags::empty();
1460 a = Flags::A;
1463 b = Flags::B;
1476 let mut x = Flags::empty();
1477 let mut y = Flags::empty();
1479 x = Flags::all();
1480 y = Flags::ABC;
1486 assert_eq!(Flags::empty(), Flags::default());
1491 assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
1492 assert_eq!(format!("{:?}", Flags::empty()), "(empty)");
1493 assert_eq!(format!("{:?}", Flags::ABC), "A | B | C | ABC");
1494 let extra = unsafe { Flags::from_bits_unchecked(0xb8) };
1496 assert_eq!(format!("{:?}", Flags::A | extra), "A | 0xb8");
1499 format!("{:?}", Flags::ABC | extra),
1508 assert_eq!(format!("{:b}", Flags::ABC), "111");
1509 assert_eq!(format!("{:#b}", Flags::ABC), "0b111");
1510 let extra = unsafe { Flags::from_bits_unchecked(0b1010000) };
1511 assert_eq!(format!("{:b}", Flags::ABC | extra), "1010111");
1512 assert_eq!(format!("{:#b}", Flags::ABC | extra), "0b1010111");
1571 struct Flags: foo::Bar {
1584 struct Flags: u8 {
1590 assert_eq!(Flags::all(), Flags::A);
1591 assert_eq!(format!("{:?}", Flags::A), "A");
1649 struct Flags: u32 {
1655 assert!(Flags::empty().contains(Flags::NONE));
1656 assert!(Flags::SOME.contains(Flags::NONE));
1657 assert!(Flags::NONE.is_empty());
1659 assert_eq!(format!("{:?}", Flags::empty()), "NONE");
1660 assert_eq!(format!("{:?}", Flags::SOME), "SOME");