bitmatrix ported untested

src/qrcode/decoder/bit_matrix_parser.rs

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-use crate::{Exceptions, common::BitMatrix};
+use crate::{common::BitMatrix, Exceptions};
-
-use super::{Version, FormatInformation, VersionRef, DataMask};
 
+use super::{DataMask, FormatInformation, Version, VersionRef};
 
 /**
  * @author Sean Owen
  */
 pub struct BitMatrixParser {
-
+    bitMatrix: BitMatrix,
-   bitMatrix:BitMatrix,
+    parsedVersion: Option<VersionRef>,
-  parsedVersion:Option<VersionRef>,
+    parsedFormatInfo: Option<FormatInformation>,
-  parsedFormatInfo:Option<FormatInformation>,
+    mirror: bool,
-   mirror:bool,
 }
 
 impl BitMatrixParser {
-
     /**
      * @param bitMatrix {@link BitMatrix} to parse
      * @throws FormatException if dimension is not >= 21 and 1 mod 4
      */
-  pub fn new( bit_matrix:BitMatrix) -> Result<Self, Exceptions> {
+    pub fn new(bit_matrix: BitMatrix) -> Result<Self, Exceptions> {
         let dimension = bit_matrix.getHeight();
         if dimension < 21 || (dimension & 0x03) != 1 {
-      Err(Exceptions::FormatException(format!("{} < 21 || ({} % 0x03) != 1", dimension,dimension)))
+            Err(Exceptions::FormatException(format!(
-    }else {
+                "{} < 21 || ({} % 0x03) != 1",
-      Ok(Self{
+                dimension, dimension
+            )))
+        } else {
+            Ok(Self {
                 bitMatrix: bit_matrix,
                 parsedVersion: None,
                 parsedFormatInfo: None,
-        mirror: false
+                mirror: false,
             })
         }
     }
@@ -57,14 +57,13 @@ impl BitMatrixParser {
      * @throws FormatException if both format information locations cannot be parsed as
      * the valid encoding of format information
      */
-  pub fn readFormatInformation(&self) -> Result<&FormatInformation,Exceptions>{
+    pub fn readFormatInformation(&mut self) -> Result<&FormatInformation, Exceptions> {
-
+        if self.parsedFormatInfo.is_some() {
-    if let Some(pfi) = self.parsedFormatInfo {
+            return Ok(&self.parsedFormatInfo.as_ref().unwrap());
-      return Ok(&pfi)
         }
 
         // Read top-left format info bits
-    let formatInfoBits1 = 0;
+        let mut formatInfoBits1 = 0;
         for i in 0..6 {
             // for (int i = 0; i < 6; i++) {
             formatInfoBits1 = self.copyBit(i, 8, formatInfoBits1);
@@ -81,20 +80,21 @@ impl BitMatrixParser {
 
         // Read the top-right/bottom-left pattern too
         let dimension = self.bitMatrix.getHeight();
-    let formatInfoBits2 = 0;
+        let mut formatInfoBits2 = 0;
         let jMin = dimension - 7;
         for j in (jMin..=dimension).rev() {
             // for (int j = dimension - 1; j >= jMin; j--) {
             formatInfoBits2 = self.copyBit(8, j, formatInfoBits2);
         }
-    for i in (dimension -8)..dimension {
+        for i in (dimension - 8)..dimension {
             // for (int i = dimension - 8; i < dimension; i++) {
             formatInfoBits2 = self.copyBit(i, 8, formatInfoBits2);
         }
 
-    self.parsedFormatInfo = FormatInformation::decodeFormatInformation(formatInfoBits1, formatInfoBits2);
+        self.parsedFormatInfo =
-    if let Some(pfi) = self.parsedFormatInfo {
+            FormatInformation::decodeFormatInformation(formatInfoBits1, formatInfoBits2);
-      return Ok(&pfi)
+        if let Some(pfi) = &self.parsedFormatInfo {
+            return Ok(pfi);
         }
         Err(Exceptions::FormatException("".to_owned()))
     }
@@ -106,57 +106,66 @@ impl BitMatrixParser {
      * @throws FormatException if both version information locations cannot be parsed as
      * the valid encoding of version information
      */
-  pub fn readVersion(&self) -> Result<VersionRef,Exceptions> {
+    pub fn readVersion(&mut self) -> Result<VersionRef, Exceptions> {
-
         if let Some(pv) = self.parsedVersion {
-      return Ok(&pv)
+            return Ok(&pv);
         }
 
         let dimension = self.bitMatrix.getHeight();
 
         let provisionalVersion = (dimension - 17) / 4;
         if provisionalVersion <= 6 {
-      return Version::getVersionForNumber(provisionalVersion)
+            return Version::getVersionForNumber(provisionalVersion);
         }
 
         // Read top-right version info: 3 wide by 6 tall
-    let versionBits = 0;
+        let mut versionBits = 0;
         let ijMin = dimension - 11;
         for j in (0..=5).rev() {
             // for (int j = 5; j >= 0; j--) {
-      for i in (ijMin..(dimension-8)).rev(){
+            for i in (ijMin..(dimension - 8)).rev() {
                 // for (int i = dimension - 9; i >= ijMin; i--) {
                 versionBits = self.copyBit(i, j, versionBits);
             }
         }
 
-    if let Ok(theParsedVersion) = Version::decodeVersionInformation(versionBits){
+        if let Ok(theParsedVersion) = Version::decodeVersionInformation(versionBits) {
             if theParsedVersion.getDimensionForVersion() == dimension {
                 self.parsedVersion = Some(theParsedVersion);
-      return Ok(theParsedVersion)
+                return Ok(theParsedVersion);
-    }}
+            }
+        }
 
         // Hmm, failed. Try bottom left: 6 wide by 3 tall
         versionBits = 0;
-    for i in (0..=5 ).rev() {
+        for i in (0..=5).rev() {
             // for (int i = 5; i >= 0; i--) {
-      for j in (ijMin..(dimension-5)).rev() {
+            for j in (ijMin..(dimension - 5)).rev() {
                 // for (int j = dimension - 9; j >= ijMin; j--) {
                 versionBits = self.copyBit(i, j, versionBits);
             }
         }
 
-    if let Ok(theParsedVersion) = Version::decodeVersionInformation(versionBits){
+        if let Ok(theParsedVersion) = Version::decodeVersionInformation(versionBits) {
             if theParsedVersion.getDimensionForVersion() == dimension {
                 self.parsedVersion = Some(theParsedVersion);
-      return Ok(theParsedVersion)
+                return Ok(theParsedVersion);
-    }}
+            }
+        }
         Err(Exceptions::FormatException("".to_owned()))
     }
 
-  fn copyBit(&self, i:u32,  j:u32,  versionBits:u32) -> u32{
+    fn copyBit(&self, i: u32, j: u32, versionBits: u32) -> u32 {
-    let bit = if self.mirror  {self.bitMatrix.get(j, i)} else {self.bitMatrix.get(i, j)};
+        let bit = if self.mirror {
-    if bit  {(versionBits << 1) | 0x1} else {versionBits << 1}
+            self.bitMatrix.get(j, i)
+        } else {
+            self.bitMatrix.get(i, j)
+        };
+        if bit {
+            (versionBits << 1) | 0x1
+        } else {
+            versionBits << 1
+        }
     }
 
     /**
@@ -167,24 +176,23 @@ impl BitMatrixParser {
      * @return bytes encoded within the QR Code
      * @throws FormatException if the exact number of bytes expected is not read
      */
-  pub fn readCodewords(&self) -> Result<Vec<u8>,Exceptions> {
+    pub fn readCodewords(&mut self) -> Result<Vec<u8>, Exceptions> {
-
+        // let formatInfo = self.readFormatInformation()?;
-    let formatInfo = self.readFormatInformation()?;
         let version = self.readVersion()?;
 
         // Get the data mask for the format used in this QR Code. This will exclude
         // some bits from reading as we wind through the bit matrix.
-    let dataMask :DataMask= formatInfo.getDataMask().try_into()?;//DataMask.values()[formatInfo.getDataMask()];
+        let dataMask: DataMask = self.readFormatInformation()?.getDataMask().try_into()?; //DataMask.values()[formatInfo.getDataMask()];
         let dimension = self.bitMatrix.getHeight();
-    dataMask.unmaskBitMatrix(self.bitMatrix, dimension);
+        dataMask.unmaskBitMatrix(&mut self.bitMatrix, dimension);
 
-    let functionPattern = version.buildFunctionPattern();
+        let functionPattern = version.buildFunctionPattern()?;
 
-    let readingUp = true;
+        let mut readingUp = true;
-    let result = vec![0u8;version.getTotalCodewords() as usize];
+        let mut result = vec![0u8; version.getTotalCodewords() as usize];
-    let resultOffset = 0;
+        let mut resultOffset = 0;
-    let currentByte = 0;
+        let mut currentByte = 0;
-    let bitsRead = 0;
+        let mut bitsRead = 0;
         // Read columns in pairs, from right to left
         let mut j = dimension - 1;
         while j > 0 {
@@ -192,26 +200,30 @@ impl BitMatrixParser {
             if j == 6 {
                 // Skip whole column with vertical alignment pattern;
                 // saves time and makes the other code proceed more cleanly
-        j-=1;
+                j -= 1;
             }
             // Read alternatingly from bottom to top then top to bottom
             for count in 0..dimension {
                 // for (int count = 0; count < dimension; count++) {
-        let i = if readingUp  {dimension - 1 - count} else {count};
+                let i = if readingUp {
+                    dimension - 1 - count
+                } else {
+                    count
+                };
                 for col in 0..2 {
                     // for (int col = 0; col < 2; col++) {
                     // Ignore bits covered by the function pattern
-          if (!functionPattern.get(j - col, i)) {
+                    if !functionPattern.get(j - col, i) {
                         // Read a bit
-            bitsRead+=1;
+                        bitsRead += 1;
                         currentByte <<= 1;
                         if self.bitMatrix.get(j - col, i) {
                             currentByte |= 1;
                         }
                         // If we've made a whole byte, save it off
-            if (bitsRead == 8) {
+                        if bitsRead == 8 {
                             result[resultOffset] = currentByte;
-              resultOffset+=1;
+                            resultOffset += 1;
                             bitsRead = 0;
                             currentByte = 0;
                         }
@@ -223,22 +235,29 @@ impl BitMatrixParser {
             j -= 2;
         }
 
-    if (resultOffset != version.getTotalCodewords()) {
+        if resultOffset != version.getTotalCodewords() as usize {
-      throw FormatException.getFormatInstance();
+            return Err(Exceptions::FormatException("".to_owned()));
         }
-    return result;
+        Ok(result)
     }
 
     /**
      * Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.
      */
-  pub fn remask(&self) {
+    pub fn remask(&mut self) {
-    if self.parsedFormatInfo.is_none() {
+        if let Some(pfi) = &self.parsedFormatInfo {
+            let dataMask: DataMask = pfi.getDataMask().try_into().unwrap(); // DataMask.values()[self.parsedFormatInfo.getDataMask()];
+            let dimension = self.bitMatrix.getHeight();
+            dataMask.unmaskBitMatrix(&mut self.bitMatrix, dimension);
+        } else {
             return; // We have no format information, and have no data mask
         }
-    let dataMask = DataMask.values()[self.parsedFormatInfo.getDataMask()];
+        // if self.parsedFormatInfo.is_none() {
-    let dimension = self.bitMatrix.getHeight();
+        //   return; // We have no format information, and have no data mask
-    dataMask.unmaskBitMatrix(self.bitMatrix, dimension);
+        // }
+        // let dataMask = self.parsedFormatInfo.getDataMask()// DataMask.values()[self.parsedFormatInfo.getDataMask()];
+        // let dimension = self.bitMatrix.getHeight();
+        // dataMask.unmaskBitMatrix(self.bitMatrix, dimension);
     }
 
     /**
@@ -249,24 +268,23 @@ impl BitMatrixParser {
      *
      * @param mirror Whether to read version and format information mirrored.
      */
-  pub fn setMirror(&self,  mirror:bool) {
+    pub fn setMirror(&mut self, mirror: bool) {
         self.parsedVersion = None;
         self.parsedFormatInfo = None;
         self.mirror = mirror;
     }
 
     /** Mirror the bit matrix in order to attempt a second reading. */
-  pub fn mirror(&self) {
+    pub fn mirror(&mut self) {
         for x in 0..self.bitMatrix.getWidth() {
             // for (int x = 0; x < bitMatrix.getWidth(); x++) {
-      for y in (x+1)..self.bitMatrix.getHeight() {
+            for y in (x + 1)..self.bitMatrix.getHeight() {
                 // for (int y = x + 1; y < bitMatrix.getHeight(); y++) {
-        if (self.bitMatrix.get(x, y) != self.bitMatrix.get(y, x)) {
+                if self.bitMatrix.get(x, y) != self.bitMatrix.get(y, x) {
                     self.bitMatrix.flip_coords(y, x);
                     self.bitMatrix.flip_coords(x, y);
                 }
             }
         }
     }
-
 }