port code_128 reader

src/oned/itf_writer.rs

@@ -20,109 +20,115 @@ use crate::BarcodeFormat;
 
 use super::OneDimensionalCodeWriter;
 
-
 /**
  * This object renders a ITF code as a {@link BitMatrix}.
  *
  * @author erik.barbara@gmail.com (Erik Barbara)
  */
 #[derive(OneDWriter)]
-pub struct ITFWriter; 
+pub struct ITFWriter;
 
 impl Default for ITFWriter {
     fn default() -> Self {
-        Self {  }
+        Self {}
     }
 }
 
 impl OneDimensionalCodeWriter for ITFWriter {
     fn encode_oned(&self, contents: &str) -> Result<Vec<bool>, Exceptions> {
-      let length = contents.chars().count();
-      if length % 2 != 0 {
-        return Err(Exceptions::IllegalArgumentException("The length of the input should be even".to_owned()));
-      }
-      if length > 80 {
-        return Err(Exceptions::IllegalArgumentException(format!("Requested contents should be less than 80 digits long, but got {}" , length)));
-      }
-    
-      Self::checkNumeric(contents)?;
-    
-      let mut result = vec![false;9 + 9 * length];
-      let mut pos = Self::appendPattern(&mut result, 0, &START_PATTERN, true) as usize;
-      let mut i = 0;
-      while i < length {
-      // for (int i = 0; i < length; i += 2) {
-        let one = contents.chars().nth(i).unwrap().to_digit(10).unwrap() as usize;
-        let two = contents.chars().nth(i + 1).unwrap().to_digit(10).unwrap() as usize;
-        let mut encoding = [0;10];//new int[10];
-        for j in 0..5 {
-        // for (int j = 0; j < 5; j++) {
-          encoding[2 * j] = PATTERNS[one][j];
-          encoding[2 * j + 1] = PATTERNS[two][j];
+        let length = contents.chars().count();
+        if length % 2 != 0 {
+            return Err(Exceptions::IllegalArgumentException(
+                "The length of the input should be even".to_owned(),
+            ));
+        }
+        if length > 80 {
+            return Err(Exceptions::IllegalArgumentException(format!(
+                "Requested contents should be less than 80 digits long, but got {}",
+                length
+            )));
         }
-        pos += Self::appendPattern(&mut result, pos, &encoding, true) as usize;
 
-        i+=2;
-      }
-      Self::appendPattern(&mut result, pos, &END_PATTERN, true);
-    
-      Ok( result)
+        Self::checkNumeric(contents)?;
+
+        let mut result = vec![false; 9 + 9 * length];
+        let mut pos = Self::appendPattern(&mut result, 0, &START_PATTERN, true) as usize;
+        let mut i = 0;
+        while i < length {
+            // for (int i = 0; i < length; i += 2) {
+            let one = contents.chars().nth(i).unwrap().to_digit(10).unwrap() as usize;
+            let two = contents.chars().nth(i + 1).unwrap().to_digit(10).unwrap() as usize;
+            let mut encoding = [0; 10]; //new int[10];
+            for j in 0..5 {
+                // for (int j = 0; j < 5; j++) {
+                encoding[2 * j] = PATTERNS[one][j];
+                encoding[2 * j + 1] = PATTERNS[two][j];
+            }
+            pos += Self::appendPattern(&mut result, pos, &encoding, true) as usize;
+
+            i += 2;
+        }
+        Self::appendPattern(&mut result, pos, &END_PATTERN, true);
+
+        Ok(result)
     }
     fn getSupportedWriteFormats(&self) -> Option<Vec<crate::BarcodeFormat>> {
         Some(vec![BarcodeFormat::ITF])
     }
-
-    
 }
 
-const START_PATTERN : [usize;4]= [1, 1, 1, 1];
-  const END_PATTERN :[usize;3]= [3, 1, 1];
+const START_PATTERN: [usize; 4] = [1, 1, 1, 1];
+const END_PATTERN: [usize; 3] = [3, 1, 1];
 
-  const W : usize= 3; // Pixel width of a 3x wide line
-  const N :usize= 1; // Pixed width of a narrow line
+const W: usize = 3; // Pixel width of a 3x wide line
+const N: usize = 1; // Pixed width of a narrow line
 
-  // See ITFReader.PATTERNS
+// See ITFReader.PATTERNS
 
-  const PATTERNS : [[usize;5];10]= [
-      [N, N, W, W, N], // 0
-      [W, N, N, N, W], // 1
-      [N, W, N, N, W], // 2
-      [W, W, N, N, N], // 3
-      [N, N, W, N, W], // 4
-      [W, N, W, N, N], // 5
-      [N, W, W, N, N], // 6
-      [N, N, N, W, W], // 7
-      [W, N, N, W, N], // 8
-      [N, W, N, W, N]  // 9
-  ];
+const PATTERNS: [[usize; 5]; 10] = [
+    [N, N, W, W, N], // 0
+    [W, N, N, N, W], // 1
+    [N, W, N, N, W], // 2
+    [W, W, N, N, N], // 3
+    [N, N, W, N, W], // 4
+    [W, N, W, N, N], // 5
+    [N, W, W, N, N], // 6
+    [N, N, N, W, W], // 7
+    [W, N, N, W, N], // 8
+    [N, W, N, W, N], // 9
+];
 
 /**
  * Tests {@link ITFWriter}.
  */
 #[cfg(test)]
 mod ITFWriterTestCase {
-    use crate::{Writer, BarcodeFormat, common::BitMatrixTestCase};
+    use crate::{common::BitMatrixTestCase, BarcodeFormat, Writer};
 
     use super::ITFWriter;
 
+    #[test]
+    fn testEncode() {
+        doTest(
+            "00123456789012",
+            "0000010101010111000111000101110100010101110001110111010001010001110100011\
+100010101000101011100011101011101000111000101110100010101110001110100000",
+        );
+    }
 
-  #[test]
-  fn testEncode() {
-    doTest("00123456789012",
-           "0000010101010111000111000101110100010101110001110111010001010001110100011\
-100010101000101011100011101011101000111000101110100010101110001110100000");
-  }
-
-  fn doTest( input:&str, expected:&str) {
-    let result =  ITFWriter::default().encode(input, &BarcodeFormat::ITF, 0, 0).expect("encode");
-    assert_eq!(expected, BitMatrixTestCase::matrix_to_string(&result));
-  }
-
-  //@Test(expected = IllegalArgumentException.class)
-  #[test]
-  #[should_panic]
-  fn testEncodeIllegalCharacters() {
-     ITFWriter::default().encode("00123456789abc", &BarcodeFormat::ITF, 0, 0).expect("should fail");
-  }
+    fn doTest(input: &str, expected: &str) {
+        let result = ITFWriter::default()
+            .encode(input, &BarcodeFormat::ITF, 0, 0)
+            .expect("encode");
+        assert_eq!(expected, BitMatrixTestCase::matrix_to_string(&result));
+    }
 
+    //@Test(expected = IllegalArgumentException.class)
+    #[test]
+    #[should_panic]
+    fn testEncodeIllegalCharacters() {
+        ITFWriter::default()
+            .encode("00123456789abc", &BarcodeFormat::ITF, 0, 0)
+            .expect("should fail");
+    }
 }