refactor to use exception helper factories

src/aztec/encoder/aztec_encoder.rs

@@ -53,7 +53,7 @@ pub const WORD_SIZE: [u32; 33] = [
 pub fn encode_simple(data: &str) -> Result<AztecCode, Exceptions> {
     let Ok(bytes) = encoding::all::ISO_8859_1
         .encode(data, encoding::EncoderTrap::Replace) else {
-            return Err(Exceptions::IllegalArgumentException(Some(format!("'{data}' cannot be encoded as ISO_8859_1"))));
+            return Err(Exceptions::illegalArgument(format!("'{data}' cannot be encoded as ISO_8859_1")));
         };
     encode_bytes_simple(&bytes)
 }
@@ -75,9 +75,9 @@ pub fn encode(
     if let Ok(bytes) = encoding::all::ISO_8859_1.encode(data, encoding::EncoderTrap::Strict) {
         encode_bytes(&bytes, minECCPercent, userSpecifiedLayers)
     } else {
-        Err(Exceptions::IllegalArgumentException(Some(format!(
+        Err(Exceptions::illegalArgument(format!(
             "'{data}' cannot be encoded as ISO_8859_1"
-        ))))
+        )))
     }
 }
 
@@ -102,9 +102,9 @@ pub fn encode_with_charset(
     if let Ok(bytes) = charset.encode(data, encoding::EncoderTrap::Strict) {
         encode_bytes_with_charset(&bytes, minECCPercent, userSpecifiedLayers, charset)
     } else {
-        Err(Exceptions::IllegalArgumentException(Some(format!(
+        Err(Exceptions::illegalArgument(format!(
             "'{data}' cannot be encoded as ISO_8859_1"
-        ))))
+        )))
     }
 }
 
@@ -178,24 +178,24 @@ pub fn encode_bytes_with_charset(
                 MAX_NB_BITS
             })
         {
-            return Err(Exceptions::IllegalArgumentException(Some(format!(
+            return Err(Exceptions::illegalArgument(format!(
                 "Illegal value {user_specified_layers} for layers"
-            ))));
+            )));
         }
         total_bits_in_layer_var = total_bits_in_layer(layers, compact);
         word_size = WORD_SIZE[layers as usize];
         let usable_bits_in_layers = total_bits_in_layer_var - (total_bits_in_layer_var % word_size);
         stuffed_bits = stuffBits(&bits, word_size as usize)?;
         if stuffed_bits.getSize() as u32 + ecc_bits > usable_bits_in_layers {
-            return Err(Exceptions::IllegalArgumentException(Some(
+            return Err(Exceptions::illegalArgument(
                 "Data to large for user specified layer".to_owned(),
-            )));
+            ));
         }
         if compact && stuffed_bits.getSize() as u32 > word_size * 64 {
             // Compact format only allows 64 data words, though C4 can hold more words than that
-            return Err(Exceptions::IllegalArgumentException(Some(
+            return Err(Exceptions::illegalArgument(
                 "Data to large for user specified layer".to_owned(),
-            )));
+            ));
         }
     } else {
         word_size = 0;
@@ -207,9 +207,9 @@ pub fn encode_bytes_with_charset(
         loop {
             // for (int i = 0; ; i++) {
             if i > MAX_NB_BITS {
-                return Err(Exceptions::IllegalArgumentException(Some(
+                return Err(Exceptions::illegalArgument(
                     "Data too large for an Aztec code".to_owned(),
-                )));
+                ));
             }
             compact = i <= 3;
             layers = if compact { i + 1 } else { i };
@@ -482,9 +482,9 @@ fn getGF(wordSize: usize) -> Result<GenericGFRef, Exceptions> {
         8 => Ok(get_predefined_genericgf(PredefinedGenericGF::AztecData8)),
         10 => Ok(get_predefined_genericgf(PredefinedGenericGF::AztecData10)),
         12 => Ok(get_predefined_genericgf(PredefinedGenericGF::AztecData12)),
-        _ => Err(Exceptions::IllegalArgumentException(Some(format!(
+        _ => Err(Exceptions::illegalArgument(format!(
             "Unsupported word size {wordSize}"
-        )))),
+        ))),
     }
 }
 

src/aztec/encoder/high_level_encoder.rs

@@ -248,9 +248,9 @@ impl HighLevelEncoder {
                 initial_state = initial_state.appendFLGn(CharacterSetECI::getValue(&eci))?;
             }
         } else {
-            return Err(Exceptions::IllegalArgumentException(Some(
+            return Err(Exceptions::illegalArgument(
                 "No ECI code for character set".to_owned(),
-            )));
+            ));
         }
         // if self.charset != null {
         //   CharacterSetECI eci = CharacterSetECI.getCharacterSetECI(charset);

src/aztec/encoder/state.rs

@@ -80,15 +80,15 @@ impl State {
             token.add(0, 3); // 0: FNC1
         } else */
         if eci > 999999 {
-            return Err(Exceptions::IllegalArgumentException(Some(
+            return Err(Exceptions::illegalArgument(
                 "ECI code must be between 0 and 999999".to_owned(),
-            )));
+            ));
             // throw new IllegalArgumentException("ECI code must be between 0 and 999999");
         } else {
             let Ok(eci_digits) = encoding::all::ISO_8859_1
                 .encode(&format!("{eci}"), encoding::EncoderTrap::Strict)
                  else {
-                    return Err(Exceptions::IllegalArgumentException(None))
+                    return Err(Exceptions::illegalArgumentEmpty())
                  };
             // let eciDigits = Integer.toString(eci).getBytes(StandardCharsets.ISO_8859_1);
             token.add(eci_digits.len() as i32, 3); // 1-6: number of ECI digits

src/aztec/encoder/token.rs

@@ -31,9 +31,9 @@ impl TokenType {
         match self {
             TokenType::Simple(a) => a.appendTo(bit_array, text),
             TokenType::BinaryShift(a) => a.appendTo(bit_array, text),
-            TokenType::Empty => Err(Exceptions::IllegalStateException(Some(String::from(
+            TokenType::Empty => Err(Exceptions::illegalState(String::from(
                 "cannot appendTo on Empty final item",
-            )))),
+            ))),
         }
     }
 }