From 0b673e5f5d0410d397f5ad3adb6af15efe57dedd Mon Sep 17 00:00:00 2001
From: diogo464 <diogo464@d464.sh>
Date: Fri, 8 Aug 2025 19:27:20 +0100
Subject: remove _hex from function names

---
 src/lib.rs | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index ca878a4..c23352b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,7 @@
 //! # Examples
 //!```
 //!let hex_string = "1a2b3c";
-//!let data = hex::decode_hex(&hex_string).unwrap();
+//!let data = hex::decode(&hex_string).unwrap();
 //!```
 
 use std::fmt::Write;
@@ -121,11 +121,11 @@ fn append_byte_hex_to_string(byte: u8, string: &mut String) {
 ///
 ///```
 ///let hex_string = "12ffbc";
-///for byte in hex::decode_hex_iter(&hex_string) {
+///for byte in hex::decode_iter(&hex_string) {
 /// //do something
 ///}
 ///```
-pub fn decode_hex_iter<T>(string: &T) -> impl Iterator<Item = u8> + '_
+pub fn decode_iter<T>(string: &T) -> impl Iterator<Item = u8> + '_
 where
     T: AsRef<[u8]> + ?Sized,
 {
@@ -137,11 +137,11 @@ where
 ///
 ///```
 ///let data = &[0x11, 0xbc, 0x22];
-///for c in hex::encode_hex_iter(&data) {
+///for c in hex::encode_iter(&data) {
 /// //do something with c
 ///}
 ///```
-pub fn encode_hex_iter<T>(data: &T) -> impl Iterator<Item = char> + '_
+pub fn encode_iter<T>(data: &T) -> impl Iterator<Item = char> + '_
 where
     T: AsRef<[u8]> + ?Sized,
 {
@@ -152,9 +152,9 @@ where
 ///
 ///```
 ///let hex_string = "ffaa11";
-///let data = hex::decode_hex(&hex_string).unwrap();
+///let data = hex::decode(&hex_string).unwrap();
 ///```
-pub fn decode_hex<T: AsRef<[u8]>>(string: T) -> Result<Vec<u8>, HexDecodeError> {
+pub fn decode<T: AsRef<[u8]>>(string: T) -> Result<Vec<u8>, HexDecodeError> {
     let chars = string.as_ref();
     if chars.len() % 2 != 0 {
         return Err(HexDecodeError::InvalidByteCount);
@@ -177,10 +177,10 @@ pub fn decode_hex<T: AsRef<[u8]>>(string: T) -> Result<Vec<u8>, HexDecodeError>
 ///
 ///```
 ///let data = &[0x11, 0x12, 0x13];
-///let string = hex::encode_hex(&data);
+///let string = hex::encode(&data);
 ///assert_eq!(string, "111213");
 ///```
-pub fn encode_hex<T: AsRef<[u8]>>(data: T) -> String {
+pub fn encode<T: AsRef<[u8]>>(data: T) -> String {
     let mut string = String::new();
     let data_ref = data.as_ref();
     for b in data_ref.iter() {
@@ -196,7 +196,7 @@ where
     T: AsRef<[u8]>,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for c in encode_hex_iter(self.0.as_ref()) {
+        for c in encode_iter(self.0.as_ref()) {
             f.write_char(c)?;
         }
         Ok(())
@@ -214,14 +214,14 @@ mod tests {
     #[test]
     fn decode_zero_bytes_test() {
         let string = "";
-        let data = decode_hex(&string).unwrap();
+        let data = decode(&string).unwrap();
         assert_eq!(0, data.len());
     }
 
     #[test]
     fn decode_one_byte_test() {
         let string = "ff";
-        let data = decode_hex(&string).unwrap();
+        let data = decode(&string).unwrap();
         assert_eq!(1, data.len());
         assert_eq!(0xff, data[0]);
     }
@@ -229,7 +229,7 @@ mod tests {
     #[test]
     fn decode_multiple_bytes_test() {
         let string = "ffaabbccdd1122";
-        let data = decode_hex(&string).unwrap();
+        let data = decode(&string).unwrap();
         assert_eq!(7, data.len());
         assert_eq!(&[0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0x11, 0x22], data.as_slice());
     }
@@ -237,7 +237,7 @@ mod tests {
     #[test]
     fn decode_invalid_character_test() {
         let string = "ffaabz";
-        match decode_hex(&string) {
+        match decode(&string) {
             Err(HexDecodeError::InvalidHexCharacter) => {}
             _ => panic!("Invalid result returned"),
         }
@@ -246,7 +246,7 @@ mod tests {
     #[test]
     fn decode_invalid_character_length() {
         let string = "ffaab";
-        match decode_hex(&string) {
+        match decode(&string) {
             Err(HexDecodeError::InvalidByteCount) => {}
             _ => panic!("Invalid result returned"),
         }
@@ -255,21 +255,21 @@ mod tests {
     #[test]
     fn encode_zero_bytes() {
         let data: &[u8; 0] = &[];
-        let string = encode_hex(&data);
+        let string = encode(&data);
         assert_eq!(string, "");
     }
 
     #[test]
     fn encode_one_byte() {
         let data: &[u8; 1] = &[0xa1];
-        let string = encode_hex(&data);
+        let string = encode(&data);
         assert_eq!(string, "a1");
     }
 
     #[test]
     fn encode_multiple_bytes() {
         let data: &[u8; 5] = &[0xaa, 0xbb, 0xcc, 0xdd, 0xee];
-        let string = encode_hex(&data);
+        let string = encode(&data);
         assert_eq!(string, "aabbccddee");
     }
 
@@ -277,21 +277,21 @@ mod tests {
     fn owned_string_decode() {
         //this test just needs to compile
         let string = String::from("aabbccddee");
-        let _ = decode_hex(&string);
-        let _ = decode_hex(string);
+        let _ = decode(&string);
+        let _ = decode(string);
     }
 
     #[test]
     fn iter_decode_test() {
         let string = "aabbcc";
-        let data: Vec<u8> = decode_hex_iter(&string).collect();
+        let data: Vec<u8> = decode_iter(&string).collect();
         assert_eq!(&[0xaa, 0xbb, 0xcc], data.as_slice());
     }
 
     #[test]
     fn iter_encode_test() {
         let data = &[0xff, 0xaa, 0x12, 0x45];
-        let string: String = encode_hex_iter(&data).collect();
+        let string: String = encode_iter(&data).collect();
         assert_eq!(string, "ffaa1245");
     }
 
-- 
cgit