feat: v0.1.1

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bin-encode-decode"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 authors = ["ltpp-universe <root@ltpp.vip>"] 
 license = "MIT"

src/common/error.rs

@@ -6,7 +6,6 @@ pub enum EncodeError {
 }
 
 impl fmt::Display for EncodeError {
-    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             EncodeError::CharsetError => write!(
@@ -24,7 +23,6 @@ pub enum DecodeError {
 }
 
 impl fmt::Display for DecodeError {
-    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             DecodeError::CharsetError => write!(

src/common/impl.rs

@@ -1,15 +1,13 @@
 use crate::*;
 
 impl<'a> Default for Endecode<'a> {
-    #[inline]
     fn default() -> Self {
         Endecode { charset: "" }
     }
 }
 
 impl<'a> Endecode<'a> {
     /// Creates a new instance of `Endecode` with a default charset.
-    #[inline]
     pub fn new() -> Self {
         Endecode::default()
     }
@@ -18,7 +16,6 @@ impl<'a> Endecode<'a> {
     ///
     /// # Returns
     /// Returns `true` if `charset` contains `CHARSET_LEN` unique characters, otherwise returns `false`.
-    #[inline]
     pub(crate) fn judge_charset_safe(charset: &str) -> bool {
         let mut hash_set: HashSet<char> = HashSet::new();
         for tmp_char in charset.chars() {
@@ -37,7 +34,6 @@ impl<'a> Endecode<'a> {
     ///
     /// # Returns
     /// Returns a mutable reference to `Self` for method chaining.
-    #[inline]
     pub fn charset<'b>(&mut self, charset: &'b str) -> &mut Self
     where
         'b: 'a,
@@ -52,23 +48,21 @@ impl<'a> Endecode<'a> {
     /// encodes a string based on the current `charset`.
     ///
     /// # Parameters
-    /// - `encode_str`: The string slice to be encodeed.
+    /// - `encode_str`: The string slice to be encoded.
     ///
     /// # Returns
-    /// Returns a `Result` containing the encodeed `String` if successful, or a `EncodeError` if the charset is invalid.
-    #[inline]
+    /// Returns a `Result` containing the encoded `String` if successful, or a `EncodeError` if the charset is invalid.
     pub fn encode(&self, encode_str: &str) -> Result<String, EncodeError> {
         encode(self.charset, encode_str)
     }
 
     /// decodes a string based on the current `charset`.
     ///
     /// # Parameters
-    /// - `decode_str`: The string slice to be decodeed.
+    /// - `decode_str`: The string slice to be decoded.
     ///
     /// # Returns
-    /// Returns a `Result` containing the decodeed `String` if successful, or a `DecodeError` if the charset is invalid.
-    #[inline]
+    /// Returns a `Result` containing the decoded `String` if successful, or a `DecodeError` if the charset is invalid.
     pub fn decode(&self, decode_str: &str) -> Result<String, DecodeError> {
         decode(self.charset, decode_str)
     }

src/decode/func.rs

@@ -11,7 +11,7 @@ use crate::*;
 ///   the provided `charset`.
 ///
 /// # Returns
-/// Returns a `Result` containing the decodeed `String` if successful, or a `DecodeError` if the charset is invalid.
+/// Returns a `Result` containing the decoded `String` if successful, or a `DecodeError` if the charset is invalid.
 ///
 /// # Example
 /// ```
@@ -22,7 +22,6 @@ use crate::*;
 /// let decoded_str = decode(charset, encoded_str);
 /// assert_eq!(decoded_str.unwrap(), "test");
 /// ```
-#[inline]
 pub fn decode(charset: &str, decode_str: &str) -> Result<String, DecodeError> {
     if !Endecode::judge_charset_safe(charset) {
         return Err(DecodeError::CharsetError);

src/encode/func.rs

@@ -10,7 +10,7 @@ use crate::*;
 ///   in 3-byte chunks.
 ///
 /// # Returns
-/// Returns a `Result` containing the encodeed `String` if successful, or a `EncodeError` if the charset is invalid.
+/// Returns a `Result` containing the encoded `String` if successful, or a `EncodeError` if the charset is invalid.
 ///
 /// # Example
 /// ```
@@ -21,7 +21,6 @@ use crate::*;
 /// let encoded_str = encode(charset, original_str);
 /// assert_eq!(encoded_str.unwrap(), "aab0aabLaabZaab0");
 /// ```
-#[inline]
 pub fn encode(charset: &str, encode_str: &str) -> Result<String, EncodeError> {
     if !Endecode::judge_charset_safe(charset) {
         return Err(EncodeError::CharsetError);