update i{x} types

Author: andrewgazelka

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bit-struct"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 description = "Define structs which have fields which are assigned to individual bits, not bytes"
 repository = "https://github.com/andrewgazelka/bit-struct"

src/lib.rs

@@ -55,7 +55,7 @@ impl u1 {
     pub fn toggle(self) -> Self {
         match self {
             Self::FALSE => u1::TRUE,
-            _ => Self::FALSE
+            _ => Self::FALSE,
         }
     }
 }
@@ -115,6 +115,18 @@ macro_rules! new_signed_types {
                 }
             }
 
+
+            /// Create a new $name from value
+            /// # Safety
+            /// - value must fit within the number of bits defined in the type
+            pub fn new(value: $signed) -> Option<Self> {
+                if value < Self::MIN || value > Self::MAX {
+                    None
+                } else {
+                    Some(unsafe {Self::new_unchecked(value)})
+                }
+            }
+
             pub fn inner_raw(self) -> $inner {
                 self.0
             }
@@ -251,65 +263,65 @@ macro_rules! new_unsigned_types {
 }
 
 new_signed_types!(
-    i2  (2, u8, i8)   => [i8, i16, i32, i64, i128],
-    i3  (3, u8, i8)   => [i8, i16, i32, i64, i128],
-    i4  (4, u8, i8)   => [i8, i16, i32, i64, i128],
-    i5  (5, u8, i8)   => [i8, i16, i32, i64, i128],
-    i6  (6, u8, i8)   => [i8, i16, i32, i64, i128],
-    i7  (7, u8, i8)   => [i8, i16, i32, i64, i128],
-    i9  (9, u16, i16)  => [i16, i32, i64, i128],
-    i10 (10, u16, i16) => [i16, i32, i64, i128],
-    i11 (11, u16, i16) => [i16, i32, i64, i128],
-    i12 (12, u16, i16) => [i16, i32, i64, i128],
-    i13 (13, u16, i16) => [i16, i32, i64, i128],
-    i14 (14, u16, i16) => [i16, i32, i64, i128],
-    i15 (15, u16, i16) => [i16, i32, i64, i128],
-    i17 (17, u32, i32) => [i32, i64, i128],
-    i18 (18, u32, i32) => [i32, i64, i128],
-    i19 (19, u32, i32) => [i32, i64, i128],
-    i20 (20, u32, i32) => [i32, i64, i128],
-    i21 (21, u32, i32) => [i32, i64, i128],
-    i22 (22, u32, i32) => [i32, i64, i128],
-    i23 (23, u32, i32) => [i32, i64, i128],
-    i24 (24, u32, i32) => [i32, i64, i128],
-    i25 (25, u32, i32) => [i32, i64, i128],
-    i26 (26, u32, i32) => [i32, i64, i128],
-    i27 (27, u32, i32) => [i32, i64, i128],
-    i28 (28, u32, i32) => [i32, i64, i128],
-    i29 (29, u32, i32) => [i32, i64, i128],
-    i30 (30, u32, i32) => [i32, i64, i128],
-    i31 (31, u32, i32) => [i32, i64, i128],
-    i33 (33, u64, i64) => [i64, i128],
-    i34 (34, u64, i64) => [i64, i128],
-    i35 (35, u64, i64) => [i64, i128],
-    i36 (36, u64, i64) => [i64, i128],
-    i37 (37, u64, i64) => [i64, i128],
-    i38 (38, u64, i64) => [i64, i128],
-    i39 (39, u64, i64) => [i64, i128],
-    i40 (40, u64, i64) => [i64, i128],
-    i41 (41, u64, i64) => [i64, i128],
-    i42 (42, u64, i64) => [i64, i128],
-    i43 (43, u64, i64) => [i64, i128],
-    i44 (44, u64, i64) => [i64, i128],
-    i45 (45, u64, i64) => [i64, i128],
-    i46 (46, u64, i64) => [i64, i128],
-    i47 (47, u64, i64) => [i64, i128],
-    i48 (48, u64, i64) => [i64, i128],
-    i49 (49, u64, i64) => [i64, i128],
-    i50 (50, u64, i64) => [i64, i128],
-    i51 (51, u64, i64) => [i64, i128],
-    i52 (52, u64, i64) => [i64, i128],
-    i53 (53, u64, i64) => [i64, i128],
-    i54 (54, u64, i64) => [i64, i128],
-    i55 (55, u64, i64) => [i64, i128],
-    i56 (56, u64, i64) => [i64, i128],
-    i57 (57, u64, i64) => [i64, i128],
-    i58 (58, u64, i64) => [i64, i128],
-    i59 (59, u64, i64) => [i64, i128],
-    i60 (60, u64, i64) => [i64, i128],
-    i61 (61, u64, i64) => [i64, i128],
-    i62 (62, u64, i64) => [i64, i128],
-    i63 (63, u64, i64) => [i64, i128]
+    i2  (2, u8, i8)   => [u8, u16, u32, u64, u128],
+    i3  (3, u8, i8)   => [u8, u16, u32, u64, u128],
+    i4  (4, u8, i8)   => [u8, u16, u32, u64, u128],
+    i5  (5, u8, i8)   => [u8, u16, u32, u64, u128],
+    i6  (6, u8, i8)   => [u8, u16, u32, u64, u128],
+    i7  (7, u8, i8)   => [u8, u16, u32, u64, u128],
+    i9  (9, u16, i16)  => [u16, u32, u64, u128],
+    i10 (10, u16, i16) => [u16, u32, u64, u128],
+    i11 (11, u16, i16) => [u16, u32, u64, u128],
+    i12 (12, u16, i16) => [u16, u32, u64, u128],
+    i13 (13, u16, i16) => [u16, u32, u64, u128],
+    i14 (14, u16, i16) => [u16, u32, u64, u128],
+    i15 (15, u16, i16) => [u16, u32, u64, u128],
+    i17 (17, u32, i32) => [u32, u64, u128],
+    i18 (18, u32, i32) => [u32, u64, u128],
+    i19 (19, u32, i32) => [u32, u64, u128],
+    i20 (20, u32, i32) => [u32, u64, u128],
+    i21 (21, u32, i32) => [u32, u64, u128],
+    i22 (22, u32, i32) => [u32, u64, u128],
+    i23 (23, u32, i32) => [u32, u64, u128],
+    i24 (24, u32, i32) => [u32, u64, u128],
+    i25 (25, u32, i32) => [u32, u64, u128],
+    i26 (26, u32, i32) => [u32, u64, u128],
+    i27 (27, u32, i32) => [u32, u64, u128],
+    i28 (28, u32, i32) => [u32, u64, u128],
+    i29 (29, u32, i32) => [u32, u64, u128],
+    i30 (30, u32, i32) => [u32, u64, u128],
+    i31 (31, u32, i32) => [u32, u64, u128],
+    i33 (33, u64, i64) => [u64, u128],
+    i34 (34, u64, i64) => [u64, u128],
+    i35 (35, u64, i64) => [u64, u128],
+    i36 (36, u64, i64) => [u64, u128],
+    i37 (37, u64, i64) => [u64, u128],
+    i38 (38, u64, i64) => [u64, u128],
+    i39 (39, u64, i64) => [u64, u128],
+    i40 (40, u64, i64) => [u64, u128],
+    i41 (41, u64, i64) => [u64, u128],
+    i42 (42, u64, i64) => [u64, u128],
+    i43 (43, u64, i64) => [u64, u128],
+    i44 (44, u64, i64) => [u64, u128],
+    i45 (45, u64, i64) => [u64, u128],
+    i46 (46, u64, i64) => [u64, u128],
+    i47 (47, u64, i64) => [u64, u128],
+    i48 (48, u64, i64) => [u64, u128],
+    i49 (49, u64, i64) => [u64, u128],
+    i50 (50, u64, i64) => [u64, u128],
+    i51 (51, u64, i64) => [u64, u128],
+    i52 (52, u64, i64) => [u64, u128],
+    i53 (53, u64, i64) => [u64, u128],
+    i54 (54, u64, i64) => [u64, u128],
+    i55 (55, u64, i64) => [u64, u128],
+    i56 (56, u64, i64) => [u64, u128],
+    i57 (57, u64, i64) => [u64, u128],
+    i58 (58, u64, i64) => [u64, u128],
+    i59 (59, u64, i64) => [u64, u128],
+    i60 (60, u64, i64) => [u64, u128],
+    i61 (61, u64, i64) => [u64, u128],
+    i62 (62, u64, i64) => [u64, u128],
+    i63 (63, u64, i64) => [u64, u128]
 );
 
 new_unsigned_types!(

tests/doc_tests.rs

@@ -44,16 +44,24 @@ fn full_test() {
     assert_eq!(bit_struct.color().start(), 8);
     assert_eq!(bit_struct.color().stop(), 10);
 
-    assert_eq!(format!("{:?}", bit_struct), "BitStruct1 { a: 0, variant: Zero, animal: Cat, color: Orange }");
+    assert_eq!(
+        format!("{:?}", bit_struct),
+        "BitStruct1 { a: 0, variant: Zero, animal: Cat, color: Orange }"
+    );
     assert_eq!(bit_struct.raw(), 4096);
 
     let reverse_bit_struct = BitStruct1::try_from(4096);
-    assert_eq!(format!("{:?}", reverse_bit_struct), "Ok(BitStruct1 { a: 0, variant: Zero, animal: Cat, color: Orange })");
-
+    assert_eq!(
+        format!("{:?}", reverse_bit_struct),
+        "Ok(BitStruct1 { a: 0, variant: Zero, animal: Cat, color: Orange })"
+    );
 
     // u3! macro provides a static assert that the number is not too large
     let mut other_struct = BitStruct2::new(Color::Green, bit_struct::u3!(0b101));
-    assert_eq!(format!("{:?}", other_struct), "BitStruct2 { a_color: Green, b: 5 }");
+    assert_eq!(
+        format!("{:?}", other_struct),
+        "BitStruct2 { a_color: Green, b: 5 }"
+    );
 
     assert_eq!(other_struct.a_color().get(), Color::Green);
 

tests/integration.rs

@@ -44,7 +44,6 @@ fn test_toggle() {
     assert_eq!(v.toggle().toggle(), u1::TRUE);
 }
 
-
 #[test]
 fn test_enum_froms() {
     macro_rules! froms {
@@ -145,7 +144,6 @@ fn test_new_signed_types() {
     assert_eq!(i2!(0).signed(), 0);
     assert_eq!(i2!(1).signed(), 1);
 
-
     assert_eq!(i3!(-4).inner_raw(), 0b100);
     assert_eq!(i3!(-3).inner_raw(), 0b101);
     assert_eq!(i3!(-2).inner_raw(), 0b110);
@@ -164,16 +162,16 @@ fn test_new_signed_types() {
     assert_eq!(i3!(2).inner_raw(), 0b010);
     assert_eq!(i3!(3).inner_raw(), 0b011);
 
-    assert!(i3::try_from(-5_i8).is_err());
-    assert!(i3::try_from(-4_i8).is_ok());
-    assert!(i3::try_from(-3_i8).is_ok());
-    assert!(i3::try_from(-2_i8).is_ok());
-    assert!(i3::try_from(-1_i8).is_ok());
-    assert!(i3::try_from(0_i8).is_ok());
-    assert!(i3::try_from(1_i8).is_ok());
-    assert!(i3::try_from(2_i8).is_ok());
-    assert!(i3::try_from(3_i8).is_ok());
-    assert!(i3::try_from(4_i8).is_err());
+    assert!(i3::new(-5).is_none());
+    assert!(i3::new(-4).is_some());
+    assert!(i3::new(-3).is_some());
+    assert!(i3::new(-2).is_some());
+    assert!(i3::new(-1).is_some());
+    assert!(i3::new(0).is_some());
+    assert!(i3::new(1).is_some());
+    assert!(i3::new(2).is_some());
+    assert!(i3::new(3).is_some());
+    assert!(i3::new(4).is_none());
 }
 
 #[test]