diff --git a/src/datamatrix/decoder/Version.java b/src/datamatrix/decoder/Version.java
deleted file mode 100644
index 2a13326..0000000
--- a/src/datamatrix/decoder/Version.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright 2007 ZXing authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.zxing.datamatrix.decoder;
-
-import com.google.zxing.FormatException;
-
-/**
- * The Version object encapsulates attributes about a particular
- * size Data Matrix Code.
- *
- * @author bbrown@google.com (Brian Brown)
- */
-public final class Version {
-
-  private static final Version[] VERSIONS = buildVersions();
-
-  private final int versionNumber;
-  private final int symbolSizeRows;
-  private final int symbolSizeColumns;
-  private final int dataRegionSizeRows;
-  private final int dataRegionSizeColumns;
-  private final ECBlocks ecBlocks;
-  private final int totalCodewords;
-
-  private Version(int versionNumber,
-                  int symbolSizeRows,
-                  int symbolSizeColumns,
-                  int dataRegionSizeRows,
-                  int dataRegionSizeColumns,
-                  ECBlocks ecBlocks) {
-    this.versionNumber = versionNumber;
-    this.symbolSizeRows = symbolSizeRows;
-    this.symbolSizeColumns = symbolSizeColumns;
-    this.dataRegionSizeRows = dataRegionSizeRows;
-    this.dataRegionSizeColumns = dataRegionSizeColumns;
-    this.ecBlocks = ecBlocks;
-
-    // Calculate the total number of codewords
-    int total = 0;
-    int ecCodewords = ecBlocks.getECCodewords();
-    ECB[] ecbArray = ecBlocks.getECBlocks();
-    for (ECB ecBlock : ecbArray) {
-      total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);
-    }
-    this.totalCodewords = total;
-  }
-
-  public int getVersionNumber() {
-    return versionNumber;
-  }
-
-  public int getSymbolSizeRows() {
-    return symbolSizeRows;
-  }
-
-  public int getSymbolSizeColumns() {
-    return symbolSizeColumns;
-  }
-
-  public int getDataRegionSizeRows() {
-    return dataRegionSizeRows;
-  }
-
-  public int getDataRegionSizeColumns() {
-    return dataRegionSizeColumns;
-  }
-
-  public int getTotalCodewords() {
-    return totalCodewords;
-  }
-
-  ECBlocks getECBlocks() {
-    return ecBlocks;
-  }
-
-  /**
-   * <p>Deduces version information from Data Matrix dimensions.</p>
-   *
-   * @param numRows Number of rows in modules
-   * @param numColumns Number of columns in modules
-   * @return Version for a Data Matrix Code of those dimensions
-   * @throws FormatException if dimensions do correspond to a valid Data Matrix size
-   */
-  public static Version getVersionForDimensions(int numRows, int numColumns) throws FormatException {
-    if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
-      throw FormatException.getFormatInstance();
-    }
-
-    for (Version version : VERSIONS) {
-      if (version.symbolSizeRows == numRows && version.symbolSizeColumns == numColumns) {
-        return version;
-      }
-    }
-
-    throw FormatException.getFormatInstance();
-  }
-
-  /**
-   * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
-   * use blocks of differing sizes within one version, so, this encapsulates the parameters for
-   * each set of blocks. It also holds the number of error-correction codewords per block since it
-   * will be the same across all blocks within one version.</p>
-   */
-  static final class ECBlocks {
-    private final int ecCodewords;
-    private final ECB[] ecBlocks;
-
-    private ECBlocks(int ecCodewords, ECB ecBlocks) {
-      this.ecCodewords = ecCodewords;
-      this.ecBlocks = new ECB[] { ecBlocks };
-    }
-
-    private ECBlocks(int ecCodewords, ECB ecBlocks1, ECB ecBlocks2) {
-      this.ecCodewords = ecCodewords;
-      this.ecBlocks = new ECB[] { ecBlocks1, ecBlocks2 };
-    }
-
-    int getECCodewords() {
-      return ecCodewords;
-    }
-
-    ECB[] getECBlocks() {
-      return ecBlocks;
-    }
-  }
-
-  /**
-   * <p>Encapsulates the parameters for one error-correction block in one symbol version.
-   * This includes the number of data codewords, and the number of times a block with these
-   * parameters is used consecutively in the Data Matrix code version's format.</p>
-   */
-  static final class ECB {
-    private final int count;
-    private final int dataCodewords;
-
-    private ECB(int count, int dataCodewords) {
-      this.count = count;
-      this.dataCodewords = dataCodewords;
-    }
-
-    int getCount() {
-      return count;
-    }
-
-    int getDataCodewords() {
-      return dataCodewords;
-    }
-  }
-
-  @Override
-  public String toString() {
-    return String.valueOf(versionNumber);
-  }
-
-  /**
-   * See ISO 16022:2006 5.5.1 Table 7
-   */
-  private static Version[] buildVersions() {
-    return new Version[]{
-        new Version(1, 10, 10, 8, 8,
-            new ECBlocks(5, new ECB(1, 3))),
-        new Version(2, 12, 12, 10, 10,
-            new ECBlocks(7, new ECB(1, 5))),
-        new Version(3, 14, 14, 12, 12,
-            new ECBlocks(10, new ECB(1, 8))),
-        new Version(4, 16, 16, 14, 14,
-            new ECBlocks(12, new ECB(1, 12))),
-        new Version(5, 18, 18, 16, 16,
-            new ECBlocks(14, new ECB(1, 18))),
-        new Version(6, 20, 20, 18, 18,
-            new ECBlocks(18, new ECB(1, 22))),
-        new Version(7, 22, 22, 20, 20,
-            new ECBlocks(20, new ECB(1, 30))),
-        new Version(8, 24, 24, 22, 22,
-            new ECBlocks(24, new ECB(1, 36))),
-        new Version(9, 26, 26, 24, 24,
-            new ECBlocks(28, new ECB(1, 44))),
-        new Version(10, 32, 32, 14, 14,
-            new ECBlocks(36, new ECB(1, 62))),
-        new Version(11, 36, 36, 16, 16,
-            new ECBlocks(42, new ECB(1, 86))),
-        new Version(12, 40, 40, 18, 18,
-            new ECBlocks(48, new ECB(1, 114))),
-        new Version(13, 44, 44, 20, 20,
-            new ECBlocks(56, new ECB(1, 144))),
-        new Version(14, 48, 48, 22, 22,
-            new ECBlocks(68, new ECB(1, 174))),
-        new Version(15, 52, 52, 24, 24,
-            new ECBlocks(42, new ECB(2, 102))),
-        new Version(16, 64, 64, 14, 14,
-            new ECBlocks(56, new ECB(2, 140))),
-        new Version(17, 72, 72, 16, 16,
-            new ECBlocks(36, new ECB(4, 92))),
-        new Version(18, 80, 80, 18, 18,
-            new ECBlocks(48, new ECB(4, 114))),
-        new Version(19, 88, 88, 20, 20,
-            new ECBlocks(56, new ECB(4, 144))),
-        new Version(20, 96, 96, 22, 22,
-            new ECBlocks(68, new ECB(4, 174))),
-        new Version(21, 104, 104, 24, 24,
-            new ECBlocks(56, new ECB(6, 136))),
-        new Version(22, 120, 120, 18, 18,
-            new ECBlocks(68, new ECB(6, 175))),
-        new Version(23, 132, 132, 20, 20,
-            new ECBlocks(62, new ECB(8, 163))),
-        new Version(24, 144, 144, 22, 22,
-            new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))),
-        new Version(25, 8, 18, 6, 16,
-            new ECBlocks(7, new ECB(1, 5))),
-        new Version(26, 8, 32, 6, 14,
-            new ECBlocks(11, new ECB(1, 10))),
-        new Version(27, 12, 26, 10, 24,
-            new ECBlocks(14, new ECB(1, 16))),
-        new Version(28, 12, 36, 10, 16,
-            new ECBlocks(18, new ECB(1, 22))),
-        new Version(29, 16, 36, 14, 16,
-            new ECBlocks(24, new ECB(1, 32))),
-        new Version(30, 16, 48, 14, 22,
-            new ECBlocks(28, new ECB(1, 49))),
-
-        // extended forms as specified in
-        // ISO 21471:2020 (DMRE) 5.5.1 Table 7
-        new Version(31, 8, 48, 6, 22,
-            new ECBlocks(15, new ECB(1, 18))),
-        new Version(32, 8, 64, 6, 14,
-            new ECBlocks(18, new ECB(1, 24))),
-        new Version(33, 8, 80, 6, 18,
-            new ECBlocks(22, new ECB(1, 32))),
-        new Version(34, 8, 96, 6, 22,
-            new ECBlocks(28, new ECB(1, 38))),
-        new Version(35, 8, 120, 6, 18,
-            new ECBlocks(32, new ECB(1, 49))),
-        new Version(36, 8, 144, 6, 22,
-            new ECBlocks(36, new ECB(1, 63))),
-        new Version(37, 12, 64, 10, 14,
-            new ECBlocks(27, new ECB(1, 43))),
-        new Version(38, 12, 88, 10, 20,
-            new ECBlocks(36, new ECB(1, 64))),
-        new Version(39, 16, 64, 14, 14,
-            new ECBlocks(36, new ECB(1, 62))),
-        new Version(40, 20, 36, 18, 16,
-            new ECBlocks(28, new ECB(1, 44))),
-        new Version(41, 20, 44, 18, 20,
-            new ECBlocks(34, new ECB(1, 56))),
-        new Version(42, 20, 64, 18, 14,
-            new ECBlocks(42, new ECB(1, 84))),
-        new Version(43, 22, 48, 20, 22,
-            new ECBlocks(38, new ECB(1, 72))),
-        new Version(44, 24, 48, 22, 22,
-            new ECBlocks(41, new ECB(1, 80))),
-        new Version(45, 24, 64, 22, 14,
-            new ECBlocks(46, new ECB(1, 108))),
-        new Version(46, 26, 40, 24, 18,
-            new ECBlocks(38, new ECB(1, 70))),
-        new Version(47, 26, 48, 24, 22,
-            new ECBlocks(42, new ECB(1, 90))),
-        new Version(48, 26, 64, 24, 14,
-            new ECBlocks(50, new ECB(1, 118)))
-    };
-  }
-
-}
diff --git a/src/datamatrix/decoder/mod.rs b/src/datamatrix/decoder/mod.rs
index 8b13789..2ed4e31 100644
--- a/src/datamatrix/decoder/mod.rs
+++ b/src/datamatrix/decoder/mod.rs
@@ -1 +1,4 @@
 
+mod version;
+
+pub use version::*;
\ No newline at end of file
diff --git a/src/datamatrix/decoder/version.rs b/src/datamatrix/decoder/version.rs
new file mode 100644
index 0000000..4014bfe
--- /dev/null
+++ b/src/datamatrix/decoder/version.rs
@@ -0,0 +1,254 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use core::fmt;
+use lazy_static::lazy_static;
+
+use crate::Exceptions;
+
+lazy_static! {
+    static ref VERSIONS: Vec<Version> = Version::buildVersions();
+}
+
+/**
+ * The Version object encapsulates attributes about a particular
+ * size Data Matrix Code.
+ *
+ * @author bbrown@google.com (Brian Brown)
+ */
+pub struct Version {
+    versionNumber: u32,
+    symbolSizeRows: u32,
+    symbolSizeColumns: u32,
+    dataRegionSizeRows: u32,
+    dataRegionSizeColumns: u32,
+    ecBlocks: ECBlocks,
+    totalCodewords: u32,
+}
+impl Version {
+    pub fn new(
+        versionNumber: u32,
+        symbolSizeRows: u32,
+        symbolSizeColumns: u32,
+        dataRegionSizeRows: u32,
+        dataRegionSizeColumns: u32,
+        ecBlocks: ECBlocks,
+    ) -> Self {
+        Self {
+            versionNumber,
+            symbolSizeRows,
+            symbolSizeColumns,
+            dataRegionSizeRows,
+            dataRegionSizeColumns,
+            totalCodewords: {
+                // Calculate the total number of codewords
+                let mut total = 0;
+                let ecCodewords = &ecBlocks.getECCodewords();
+                let ecbArray = ecBlocks.getECBlocks();
+                for ecBlock in ecbArray {
+                    total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);
+                }
+
+                total
+            },
+            ecBlocks,
+        }
+    }
+
+    pub fn getVersionNumber(&self) -> u32 {
+        self.versionNumber
+    }
+
+    pub fn getSymbolSizeRows(&self) -> u32 {
+        self.symbolSizeRows
+    }
+
+    pub fn getSymbolSizeColumns(&self) -> u32 {
+        self.symbolSizeColumns
+    }
+
+    pub fn getDataRegionSizeRows(&self) -> u32 {
+        self.dataRegionSizeRows
+    }
+
+    pub fn getDataRegionSizeColumns(&self) -> u32 {
+        self.dataRegionSizeColumns
+    }
+
+    pub fn getTotalCodewords(&self) -> u32 {
+        self.totalCodewords
+    }
+
+    pub fn getECBlocks(&self) -> &ECBlocks {
+        &self.ecBlocks
+    }
+
+    /**
+     * <p>Deduces version information from Data Matrix dimensions.</p>
+     *
+     * @param numRows Number of rows in modules
+     * @param numColumns Number of columns in modules
+     * @return Version for a Data Matrix Code of those dimensions
+     * @throws FormatException if dimensions do correspond to a valid Data Matrix size
+     */
+    pub fn getVersionForDimensions(
+        numRows: u32,
+        numColumns: u32,
+    ) -> Result<&'static Version, Exceptions> {
+        if (numRows & 0x01) != 0 || (numColumns & 0x01) != 0 {
+            return Err(Exceptions::FormatException("".to_owned()));
+        }
+
+        for version in VERSIONS.iter() {
+            if version.symbolSizeRows == numRows && version.symbolSizeColumns == numColumns {
+                return Ok(version);
+            }
+        }
+
+        Err(Exceptions::FormatException("".to_owned()))
+    }
+
+    /**
+     * See ISO 16022:2006 5.5.1 Table 7
+     */
+    fn buildVersions() -> Vec<Version> {
+        vec![
+            Version::new(1, 10, 10, 8, 8, ECBlocks::new(5, ECB::new(1, 3))),
+            Version::new(2, 12, 12, 10, 10, ECBlocks::new(7, ECB::new(1, 5))),
+            Version::new(3, 14, 14, 12, 12, ECBlocks::new(10, ECB::new(1, 8))),
+            Version::new(4, 16, 16, 14, 14, ECBlocks::new(12, ECB::new(1, 12))),
+            Version::new(5, 18, 18, 16, 16, ECBlocks::new(14, ECB::new(1, 18))),
+            Version::new(6, 20, 20, 18, 18, ECBlocks::new(18, ECB::new(1, 22))),
+            Version::new(7, 22, 22, 20, 20, ECBlocks::new(20, ECB::new(1, 30))),
+            Version::new(8, 24, 24, 22, 22, ECBlocks::new(24, ECB::new(1, 36))),
+            Version::new(9, 26, 26, 24, 24, ECBlocks::new(28, ECB::new(1, 44))),
+            Version::new(10, 32, 32, 14, 14, ECBlocks::new(36, ECB::new(1, 62))),
+            Version::new(11, 36, 36, 16, 16, ECBlocks::new(42, ECB::new(1, 86))),
+            Version::new(12, 40, 40, 18, 18, ECBlocks::new(48, ECB::new(1, 114))),
+            Version::new(13, 44, 44, 20, 20, ECBlocks::new(56, ECB::new(1, 144))),
+            Version::new(14, 48, 48, 22, 22, ECBlocks::new(68, ECB::new(1, 174))),
+            Version::new(15, 52, 52, 24, 24, ECBlocks::new(42, ECB::new(2, 102))),
+            Version::new(16, 64, 64, 14, 14, ECBlocks::new(56, ECB::new(2, 140))),
+            Version::new(17, 72, 72, 16, 16, ECBlocks::new(36, ECB::new(4, 92))),
+            Version::new(18, 80, 80, 18, 18, ECBlocks::new(48, ECB::new(4, 114))),
+            Version::new(19, 88, 88, 20, 20, ECBlocks::new(56, ECB::new(4, 144))),
+            Version::new(20, 96, 96, 22, 22, ECBlocks::new(68, ECB::new(4, 174))),
+            Version::new(21, 104, 104, 24, 24, ECBlocks::new(56, ECB::new(6, 136))),
+            Version::new(22, 120, 120, 18, 18, ECBlocks::new(68, ECB::new(6, 175))),
+            Version::new(23, 132, 132, 20, 20, ECBlocks::new(62, ECB::new(8, 163))),
+            Version::new(
+                24,
+                144,
+                144,
+                22,
+                22,
+                ECBlocks::new2(62, ECB::new(8, 156), ECB::new(2, 155)),
+            ),
+            Version::new(25, 8, 18, 6, 16, ECBlocks::new(7, ECB::new(1, 5))),
+            Version::new(26, 8, 32, 6, 14, ECBlocks::new(11, ECB::new(1, 10))),
+            Version::new(27, 12, 26, 10, 24, ECBlocks::new(14, ECB::new(1, 16))),
+            Version::new(28, 12, 36, 10, 16, ECBlocks::new(18, ECB::new(1, 22))),
+            Version::new(29, 16, 36, 14, 16, ECBlocks::new(24, ECB::new(1, 32))),
+            Version::new(30, 16, 48, 14, 22, ECBlocks::new(28, ECB::new(1, 49))),
+            // extended forms as specified in
+            // ISO 21471:2020 (DMRE) 5.5.1 Table 7
+            Version::new(31, 8, 48, 6, 22, ECBlocks::new(15, ECB::new(1, 18))),
+            Version::new(32, 8, 64, 6, 14, ECBlocks::new(18, ECB::new(1, 24))),
+            Version::new(33, 8, 80, 6, 18, ECBlocks::new(22, ECB::new(1, 32))),
+            Version::new(34, 8, 96, 6, 22, ECBlocks::new(28, ECB::new(1, 38))),
+            Version::new(35, 8, 120, 6, 18, ECBlocks::new(32, ECB::new(1, 49))),
+            Version::new(36, 8, 144, 6, 22, ECBlocks::new(36, ECB::new(1, 63))),
+            Version::new(37, 12, 64, 10, 14, ECBlocks::new(27, ECB::new(1, 43))),
+            Version::new(38, 12, 88, 10, 20, ECBlocks::new(36, ECB::new(1, 64))),
+            Version::new(39, 16, 64, 14, 14, ECBlocks::new(36, ECB::new(1, 62))),
+            Version::new(40, 20, 36, 18, 16, ECBlocks::new(28, ECB::new(1, 44))),
+            Version::new(41, 20, 44, 18, 20, ECBlocks::new(34, ECB::new(1, 56))),
+            Version::new(42, 20, 64, 18, 14, ECBlocks::new(42, ECB::new(1, 84))),
+            Version::new(43, 22, 48, 20, 22, ECBlocks::new(38, ECB::new(1, 72))),
+            Version::new(44, 24, 48, 22, 22, ECBlocks::new(41, ECB::new(1, 80))),
+            Version::new(45, 24, 64, 22, 14, ECBlocks::new(46, ECB::new(1, 108))),
+            Version::new(46, 26, 40, 24, 18, ECBlocks::new(38, ECB::new(1, 70))),
+            Version::new(47, 26, 48, 24, 22, ECBlocks::new(42, ECB::new(1, 90))),
+            Version::new(48, 26, 64, 24, 14, ECBlocks::new(50, ECB::new(1, 118))),
+        ]
+    }
+}
+
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.versionNumber)
+    }
+}
+
+/**
+ * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.</p>
+ */
+pub struct ECBlocks {
+    ecCodewords: u32,
+    ecBlocks: Vec<ECB>,
+}
+impl ECBlocks {
+    pub fn new(ecCodewords: u32, ecBlocks: ECB) -> Self {
+        Self {
+            ecCodewords,
+            ecBlocks: vec![ecBlocks],
+        }
+    }
+
+    pub fn new2(ecCodewords: u32, ecBlocks1: ECB, ecBlocks2: ECB) -> Self {
+        Self {
+            ecCodewords,
+            ecBlocks: vec![ecBlocks1, ecBlocks2],
+        }
+    }
+
+    pub fn getECCodewords(&self) -> u32 {
+        self.ecCodewords
+    }
+
+    pub fn getECBlocks(&self) -> &[ECB] {
+        &self.ecBlocks
+    }
+}
+
+/**
+ * <p>Encapsulates the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the Data Matrix code version's format.</p>
+ */
+pub struct ECB {
+    count: u32,
+    dataCodewords: u32,
+}
+impl ECB {
+    pub fn new(count: u32, dataCodewords: u32) -> Self {
+        Self {
+            count,
+            dataCodewords,
+        }
+    }
+
+    pub fn getCount(&self) -> u32 {
+        self.count
+    }
+
+    pub fn getDataCodewords(&self) -> u32 {
+        self.dataCodewords
+    }
+}