Crates.io API Documentation Workflow Status

hexutil

Implement common traits for binary representable data.

Use the impl_hex macro to implement the ToHex, FromHex, Display, FromStr, Serialize and Deserialize traits.

This can be done by returning a reference to some bytes: ```rust struct Test([u8; 42]);

hexutil::impl_hex!(Test, 42, |&self| &self.0, |data| Ok(Self(data))); ```

Or by returning some bytes by value: ```rust struct Test(u128);

hexutil::implhex!(Test, 16, |self| self.0.tolebytes(), |data| Ok(Self( u128::fromle_bytes(data) ))); ```

Example

```rust struct Test(u16);

hexutil::implhex!(Test, 2, |self| self.0.tolebytes(), |data| Ok(Self( u16::fromle_bytes(data) )));

let test = Test(0x1234);

// std::fmt::Display assert_eq!(format!("{}", test), "3412");

// std::string::ToString let hex = test.tostring(); asserteq!(hex, "3412");

// std::convert::FromStr let test: Test = hex.parse().unwrap(); assert_eq!(test, Test(0x1234));

// hexutil::ToHex let hex = test.tohex(); asserteq!(hex, "3412");

// hexutil::FromHex let test = Test::fromhex(hex.asbytes()).unwrap(); assert_eq!(test, Test(0x1234));

// hexutil::ParseHex let test: Test = hex.parsehex().unwrap(); asserteq!(test, Test(0x1234));

// serde::Serialize (with serializer.ishumanreadable() == true) let json = serdejson::tostring(&test).unwrap(); assert_eq!(json, r#""3412""#);

// serde::Deserialize (with deserializer.ishumanreadable() == true) let test: Test = serdejson::fromstr(&json).unwrap(); assert_eq!(test, Test(0x1234));

// serde::Serialize (with serializer.ishumanreadable() == false) let bin = bincode::serialize(&test).unwrap(); assert_eq!(bin, [0x34, 0x12]);

// serde::Deserialize (with deserializer.ishumanreadable() == false) let test: Test = bincode::deserialize(&bin).unwrap(); assert_eq!(test, Test(0x1234)); ```

Presets

You can append a list of presets what do derive:

Name | Desciption -|- default | convert and serde convert | Display and FromStr Display | Implement the std::fmt::Display trait (enables the to_string() method) FromStr | Implement the std::convert::FromStr trait (enables the str.parse() method) serde | Serialize and Deserialize Serialize | Implement the serde::Serialize trait Deserialize | Implement the serde::Deserialize trait

Derive only the ToHex, FromHex, Serialize and Deserialize traits: ```rust struct Test([u8; 42]);

hexutil::impl_hex!(Test, 42, |self| self.0, |data| Ok(Self(data)), [serde]); ```

FromHex Error

The second function returns a Result<Self, FromHexError>: ```rust struct Test([u8; 42]);

hexutil::impl_hex!(Test, 42, |self| self.0, |data| { Err(FromHexError::CustomStr("can't create this from hex")) }); Or use `FromHexError::InvalidValue` to display a default message: rust struct Test([u8; 42]);

hexutil::impl_hex!(Test, 42, |self| self.0, |data| Err( FromHexError::InvalidValue )); ```

One direction only

You can also implement only one direction: ```rust struct Test([u8; 42]);

hexutil::impltohex!(Test, 42, |self| self.0); rust struct Test([u8; 42]);

hexutil::implfromhex!(Test, 42, |data| Ok(Self(data))); ```

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.