Vin result port and passes

src/client/result/ResultParser.rs

@@ -37,7 +37,7 @@ use super::{
     BookmarkDoCoMoResultParser, EmailAddressResultParser, EmailDoCoMoResultParser, GeoResultParser,
     ISBNResultParser, ParsedClientResult, ParsedRXingResult, ProductResultParser,
     SMSMMSResultParser, SMTPResultParser, TelResultParser, TextParsedRXingResult, URIResultParser,
-    URLTOResultParser, WifiResultParser,
+    URLTOResultParser, VINResultParser, WifiResultParser,
 };
 
 /**
@@ -104,7 +104,7 @@ pub fn getMassagedText(result: &RXingResult) -> String {
 }
 
 pub fn parseRXingResult(theRXingResult: &RXingResult) -> ParsedClientResult {
-    let PARSERS: [&ParserFunction; 13] = [
+    let PARSERS: [&ParserFunction; 14] = [
         &BookmarkDoCoMoResultParser::parse,
         //     new AddressBookDoCoMoRXingResultParser(),
         &EmailDoCoMoResultParser::parse,
@@ -124,7 +124,7 @@ pub fn parseRXingResult(theRXingResult: &RXingResult) -> ParsedClientResult {
         &ISBNResultParser::parse,
         &ProductResultParser::parse,
         //     new ExpandedProductRXingResultParser(),
-        //     new VINRXingResultParser(),
+        &VINResultParser::parse,
     ];
 
     for parser in PARSERS {

src/client/result/VINParsedResult.rs

@@ -14,96 +14,110 @@
  * limitations under the License.
  */
 
-
 // package com.google.zxing.client.result;
 
+use super::{ParsedRXingResult, ParsedRXingResultType};
+
 /**
  * Represents a parsed result that encodes a Vehicle Identification Number (VIN).
  */
 pub struct VINParsedRXingResult {
+    vin: String,
+    world_manufacturer_id: String,
+    vehicle_descriptor_section: String,
+    vehicle_identifier_section: String,
+    country_code: String,
+    vehicle_attributes: String,
+    model_year: u32,
+    plant_code: char,
+    sequentialNumber: String,
+}
 
-  private final String vin;
+impl ParsedRXingResult for VINParsedRXingResult {
-  private final String worldManufacturerID;
+    fn getType(&self) -> super::ParsedRXingResultType {
-  private final String vehicleDescriptorSection;
+        ParsedRXingResultType::VIN
-  private final String vehicleIdentifierSection;
+    }
-  private final String countryCode;
-  private final String vehicleAttributes;
-  private final int modelYear;
-  private final char plantCode;
-  private final String sequentialNumber;
 
-  impl ParsedRXingResult for VINParsedRXingResult {}
+    fn getDisplayRXingResult(&self) -> String {
+        let mut result = String::with_capacity(50);
+        result.push_str(&self.world_manufacturer_id);
+        result.push(' ');
+        result.push_str(&self.vehicle_descriptor_section);
+        result.push(' ');
+        result.push_str(&self.vehicle_identifier_section);
+        result.push('\n');
+        if !self.country_code.is_empty() {
+            result.push_str(&self.country_code);
+            result.push(' ');
+        }
+        result.push_str(&self.model_year.to_string());
+        result.push(' ');
+        result.push(self.plant_code);
+        result.push(' ');
+        result.push_str(&self.sequentialNumber);
+        result.push('\n');
+
+        result
+    }
+}
 impl VINParsedRXingResult {
-
+    pub fn new(
-  public VINParsedRXingResult(String vin,
+        vin: String,
-                         String worldManufacturerID,
+        worldManufacturerID: String,
-                         String vehicleDescriptorSection,
+        vehicleDescriptorSection: String,
-                         String vehicleIdentifierSection,
+        vehicleIdentifierSection: String,
-                         String countryCode,
+        countryCode: String,
-                         String vehicleAttributes,
+        vehicleAttributes: String,
-                         int modelYear,
+        modelYear: u32,
-                         char plantCode,
+        plantCode: char,
-                         String sequentialNumber) {
+        sequentialNumber: String,
-    super(ParsedRXingResultType.VIN);
+    ) -> Self {
-    this.vin = vin;
+        Self {
-    this.worldManufacturerID = worldManufacturerID;
+            vin,
-    this.vehicleDescriptorSection = vehicleDescriptorSection;
+            world_manufacturer_id: worldManufacturerID,
-    this.vehicleIdentifierSection = vehicleIdentifierSection;
+            vehicle_descriptor_section: vehicleDescriptorSection,
-    this.countryCode = countryCode;
+            vehicle_identifier_section: vehicleIdentifierSection,
-    this.vehicleAttributes = vehicleAttributes;
+            country_code: countryCode,
-    this.modelYear = modelYear;
+            vehicle_attributes: vehicleAttributes,
-    this.plantCode = plantCode;
+            model_year: modelYear,
-    this.sequentialNumber = sequentialNumber;
+            plant_code: plantCode,
+            sequentialNumber,
+        }
     }
 
-  public String getVIN() {
+    pub fn getVIN(&self) -> &str {
-    return vin;
+        &self.vin
     }
 
-  public String getWorldManufacturerID() {
+    pub fn getWorldManufacturerID(&self) -> &str {
-    return worldManufacturerID;
+        &self.world_manufacturer_id
     }
 
-  public String getVehicleDescriptorSection() {
+    pub fn getVehicleDescriptorSection(&self) -> &str {
-    return vehicleDescriptorSection;
+        &self.vehicle_descriptor_section
     }
 
-  public String getVehicleIdentifierSection() {
+    pub fn getVehicleIdentifierSection(&self) -> &str {
-    return vehicleIdentifierSection;
+        &self.vehicle_identifier_section
     }
 
-  public String getCountryCode() {
+    pub fn getCountryCode(&self) -> &str {
-    return countryCode;
+        &self.country_code
     }
 
-  public String getVehicleAttributes() {
+    pub fn getVehicleAttributes(&self) -> &str {
-    return vehicleAttributes;
+        &self.vehicle_attributes
     }
 
-  public int getModelYear() {
+    pub fn getModelYear(&self) -> u32 {
-    return modelYear;
+        self.model_year
     }
 
-  public char getPlantCode() {
+    pub fn getPlantCode(&self) -> char {
-    return plantCode;
+        self.plant_code
     }
 
-  public String getSequentialNumber() {
+    pub fn getSequentialNumber(&self) -> &str {
-    return sequentialNumber;
+        &self.sequentialNumber
-  }
-
-  @Override
-  public String getDisplayRXingResult() {
-    StringBuilder result = new StringBuilder(50);
-    result.append(worldManufacturerID).append(' ');
-    result.append(vehicleDescriptorSection).append(' ');
-    result.append(vehicleIdentifierSection).append('\n');
-    if (countryCode != null) {
-      result.append(countryCode).append(' ');
-    }
-    result.append(modelYear).append(' ');
-    result.append(plantCode).append(' ');
-    result.append(sequentialNumber).append('\n');
-    return result.toString();
     }
 }

src/client/result/VINParsedResultTestCase.rs

@@ -14,57 +14,107 @@
  * limitations under the License.
  */
 
+// package com.google.zxing.client.result;
 
-package com.google.zxing.client.result;
+// import com.google.zxing.BarcodeFormat;
-
+// import com.google.zxing.RXingResult;
-import com.google.zxing.BarcodeFormat;
+// import org.junit.Assert;
-import com.google.zxing.RXingResult;
+// import org.junit.Test;
-import org.junit.Assert;
-import org.junit.Test;
 
 /**
  * Tests {@link VINParsedRXingResult}.
  */
-public final class VINParsedRXingResultTestCase extends Assert {
+// public final class VINParsedRXingResultTestCase extends Assert {
+use crate::{
+    client::result::{ParsedClientResult, ParsedRXingResult, ParsedRXingResultType},
+    BarcodeFormat, RXingResult,
+};
 
-  @Test
+use super::ResultParser;
-  public void testNotVIN() {
+
-    RXingResult fakeRXingResult = new RXingResult("1M8GDM9A1KP042788", null, null, BarcodeFormat.CODE_39);
+#[test]
-    ParsedRXingResult result = RXingResultParser.parseRXingResult(fakeRXingResult);
+fn testNotVIN() {
-    assertEquals(ParsedRXingResultType.TEXT, result.getType());
+    let fakeRXingResult = RXingResult::new(
-    fakeRXingResult = new RXingResult("1M8GDM9AXKP042788", null, null, BarcodeFormat.CODE_128);
+        "1M8GDM9A1KP042788",
-    result = RXingResultParser.parseRXingResult(fakeRXingResult);
+        Vec::new(),
-    assertEquals(ParsedRXingResultType.TEXT, result.getType());
+        Vec::new(),
+        BarcodeFormat::CODE_39,
+    );
+    let result = ResultParser::parseRXingResult(&fakeRXingResult);
+    assert_eq!(ParsedRXingResultType::TEXT, result.getType());
+    let fakeRXingResult = RXingResult::new(
+        "1M8GDM9AXKP042788",
+        Vec::new(),
+        Vec::new(),
+        BarcodeFormat::CODE_128,
+    );
+    let result = ResultParser::parseRXingResult(&fakeRXingResult);
+    assert_eq!(ParsedRXingResultType::TEXT, result.getType());
 }
 
-  @Test
+#[test]
-  public void testVIN() {
+fn testVIN() {
-    doTest("1M8GDM9AXKP042788", "1M8", "GDM9AX", "KP042788", "US", "GDM9A", 1989, 'P', "042788");
+    doTest(
-    doTest("I1M8GDM9AXKP042788", "1M8", "GDM9AX", "KP042788", "US", "GDM9A", 1989, 'P', "042788");
+        "1M8GDM9AXKP042788",
-    doTest("LJCPCBLCX11000237", "LJC", "PCBLCX", "11000237", "CN", "PCBLC", 2001, '1', "000237");
+        "1M8",
+        "GDM9AX",
+        "KP042788",
+        "US",
+        "GDM9A",
+        1989,
+        'P',
+        "042788",
+    );
+    doTest(
+        "I1M8GDM9AXKP042788",
+        "1M8",
+        "GDM9AX",
+        "KP042788",
+        "US",
+        "GDM9A",
+        1989,
+        'P',
+        "042788",
+    );
+    doTest(
+        "LJCPCBLCX11000237",
+        "LJC",
+        "PCBLCX",
+        "11000237",
+        "CN",
+        "PCBLC",
+        2001,
+        '1',
+        "000237",
+    );
 }
 
-  private static void doTest(String contents,
+fn doTest(
-                             String wmi,
+    contents: &str,
-                             String vds,
+    wmi: &str,
-                             String vis,
+    vds: &str,
-                             String country,
+    vis: &str,
-                             String attributes,
+    country: &str,
-                             int year,
+    attributes: &str,
-                             char plant,
+    year: u32,
-                             String sequential) {
+    plant: char,
-    RXingResult fakeRXingResult = new RXingResult(contents, null, null, BarcodeFormat.CODE_39);
+    sequential: &str,
-    ParsedRXingResult result = RXingResultParser.parseRXingResult(fakeRXingResult);
+) {
-    assertSame(ParsedRXingResultType.VIN, result.getType());
+    let fakeRXingResult =
-    VINParsedRXingResult vinRXingResult = (VINParsedRXingResult) result;
+        RXingResult::new(contents, Vec::new(), Vec::new(), BarcodeFormat::CODE_39);
-    assertEquals(wmi, vinRXingResult.getWorldManufacturerID());
+    let result = ResultParser::parseRXingResult(&fakeRXingResult);
-    assertEquals(vds, vinRXingResult.getVehicleDescriptorSection());
+    assert_eq!(ParsedRXingResultType::VIN, result.getType());
-    assertEquals(vis, vinRXingResult.getVehicleIdentifierSection());
+    if let ParsedClientResult::VINResult(vinRXingResult) = result {
-    assertEquals(country, vinRXingResult.getCountryCode());
+        // let vinRXingResult = (VINParsedRXingResult) result;
-    assertEquals(attributes, vinRXingResult.getVehicleAttributes());
+        assert_eq!(wmi, vinRXingResult.getWorldManufacturerID());
-    assertEquals(year, vinRXingResult.getModelYear());
+        assert_eq!(vds, vinRXingResult.getVehicleDescriptorSection());
-    assertEquals(plant, vinRXingResult.getPlantCode());
+        assert_eq!(vis, vinRXingResult.getVehicleIdentifierSection());
-    assertEquals(sequential, vinRXingResult.getSequentialNumber());
+        assert_eq!(country, vinRXingResult.getCountryCode());
+        assert_eq!(attributes, vinRXingResult.getVehicleAttributes());
+        assert_eq!(year, vinRXingResult.getModelYear());
+        assert_eq!(plant, vinRXingResult.getPlantCode());
+        assert_eq!(sequential, vinRXingResult.getSequentialNumber());
+    } else {
+        panic!("Expected VINResult");
     }
-
 }

src/client/result/VINResultParser.rs

@@ -23,7 +23,9 @@
 
 use regex::Regex;
 
-use crate::{RXingResult, BarcodeFormat, exceptions::Exceptions};
+use crate::{
+    client::result::VINParsedRXingResult, exceptions::Exceptions, BarcodeFormat, RXingResult,
+};
 
 use super::ParsedClientResult;
 
@@ -38,37 +40,53 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
     }
     let ioq_matcher = Regex::new(IOQ).unwrap();
     let az09_matcher = Regex::new(AZ09).unwrap();
-  let rawText = result.getText();
+    let rawText_res = result.getText().trim();
-  ioq_matcher.replace_all(result.getText(), "").trim();
+    let rawText = ioq_matcher.replace_all(rawText_res, "").to_string();
     // rawText = IOQ.matcher(rawText).replaceAll("").trim();
-  if let None = az09_matcher.find(rawText){
+    if let None = az09_matcher.find(&rawText) {
         return None;
     }
     // if !AZ09.matcher(rawText).matches() {
     //   return null;
     // }
-  let check_cs = checkChecksum(rawText);
+    let check_cs = checkChecksum(&rawText).unwrap_or(false);
     if !check_cs {
         return None;
     }
     let wmi = &rawText[..3];
-  try {
+    // try {
     // if (!checkChecksum(rawText)) {
     //   return null;
     // }
     // String wmi = rawText.substring(0, 3);
-    return new VINParsedRXingResult(rawText,
+    let country_code = countryCode(wmi).unwrap_or("");
-        wmi,
+    let model_year = modelYear(rawText.chars().nth(9).unwrap_or('_'));
-        rawText.substring(3, 9),
+    if model_year.is_err() {
-        rawText.substring(9, 17),
+        return None;
-        countryCode(wmi),
-        rawText.substring(3, 8),
-        modelYear(rawText.charAt(9)),
-        rawText.charAt(10),
-        rawText.substring(11));
-  } catch (IllegalArgumentException iae) {
-    return null;
     }
+    Some(ParsedClientResult::VINResult(VINParsedRXingResult::new(
+        rawText.to_owned(),
+        wmi.to_owned(),
+        rawText[3..9].to_owned(),
+        rawText[9..17].to_owned(),
+        country_code.to_owned(),
+        rawText[3..8].to_owned(),
+        model_year.unwrap(),
+        rawText.chars().nth(10).unwrap(),
+        rawText[11..].to_owned(),
+    )))
+    //   return new VINParsedRXingResult(rawText,
+    //       wmi,
+    //       rawText.substring(3, 9),
+    //       rawText.substring(9, 17),
+    //       countryCode(wmi),
+    //       rawText.substring(3, 8),
+    //       modelYear(rawText.charAt(9)),
+    //       rawText.charAt(10),
+    //       rawText.substring(11));
+    // } catch (IllegalArgumentException iae) {
+    //   return null;
+    // }
 }
 
 const IOQ: &'static str = "[IOQ]";
@@ -78,7 +96,7 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
     let mut sum = 0;
     for i in 0..vin.len() {
         // for (int i = 0; i < vin.length(); i++) {
-      sum += vinPositionWeight(i + 1)? * vinCharValue(vin.chars().nth(i).unwrap())?;
+        sum += vinPositionWeight(i + 1)? as u32 * vinCharValue(vin.chars().nth(i).unwrap())?;
     }
     let checkToChar = vin.chars().nth(8).unwrap();
     let expectedCheckChar = checkChar((sum % 11) as u8)?;
@@ -86,19 +104,30 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
 }
 
 fn vinCharValue(c: char) -> Result<u32, Exceptions> {
-    if c >= 'A' && c <= 'I' {
+    match c {
-      return Ok((c as u8 as u32 - 'A' as u8 as u32) + 1);
+        'A'..='I' => Ok((c as u8 as u32 - 'A' as u8 as u32) + 1),
+        'J'..='R' => Ok((c as u8 as u32 - 'J' as u8 as u32) + 1),
+        'S'..='Z' => Ok((c as u8 as u32 - 'S' as u8 as u32) + 2),
+        '0'..='9' => Ok(c as u8 as u32 - '0' as u8 as u32),
+        _ => Err(Exceptions::IllegalArgumentException(
+            "vin char out of range".to_owned(),
+        )),
     }
-    if c >= 'J' && c <= 'R' {
+    // if c >= 'A' && c <= 'I' {
-      return Ok((c as u8 as u32 - 'J' as u8 as u32) + 1);
+    //     return Ok((c as u8 as u32 - 'A' as u8 as u32) + 1);
-    }
+    // }
-    if c >= 'S' && c <= 'Z' {
+    // if c >= 'J' && c <= 'R' {
-      return Ok((c  as u8 as u32- 'S' as u8 as u32) + 2);
+    //     return Ok((c as u8 as u32 - 'J' as u8 as u32) + 1);
-    }
+    // }
-    if c >= '0' && c <= '9' {
+    // if c >= 'S' && c <= 'Z' {
-      return Ok(c as u8 as u32 - '0' as u8 as u32);
+    //     return Ok((c as u8 as u32 - 'S' as u8 as u32) + 2);
-    }
+    // }
-    Err( Exceptions::IllegalArgumentException("vin char out of range".to_owned()))
+    // if c >= '0' && c <= '9' {
+    //     return Ok(c as u8 as u32 - '0' as u8 as u32);
+    // }
+    // Err(Exceptions::IllegalArgumentException(
+    //     "vin char out of range".to_owned(),
+    // ))
 }
 
 fn vinPositionWeight(position: usize) -> Result<usize, Exceptions> {
@@ -107,7 +136,9 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
         8 => Ok(10),
         9 => Ok(0),
         10..=17 => Ok(19 - position),
-      _ => Err(Exceptions::IllegalArgumentException("vin position weight out of bounds".to_owned())),
+        _ => Err(Exceptions::IllegalArgumentException(
+            "vin position weight out of bounds".to_owned(),
+        )),
     }
     // if position >= 1 && position <= 7 {
     //   return 9 - position;
@@ -125,38 +156,59 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
 }
 
 fn checkChar(remainder: u8) -> Result<char, Exceptions> {
-    if remainder < 10 {
+    match remainder {
-      return Ok( ('0' as u8 + remainder) as char );
+        0..=9 => Ok(('0' as u8 + remainder) as char),
+        10 => Ok('X'),
+        _ => Err(Exceptions::IllegalArgumentException(
+            "remainder too high".to_owned(),
+        )),
     }
-    if remainder == 10 {
+    // if remainder < 10 {
-      return Ok('X');
+    //     return Ok(('0' as u8 + remainder) as char);
-    }
+    // }
-    Err(Exceptions::IllegalArgumentException("remainder too high".to_owned()))
+    // if remainder == 10 {
+    //     return Ok('X');
+    // }
+    // Err(Exceptions::IllegalArgumentException(
+    //     "remainder too high".to_owned(),
+    // ))
 }
 
 fn modelYear(c: char) -> Result<u32, Exceptions> {
-    if (c >= 'E' && c <= 'H') {
+    match c {
-      return (c - 'E') + 1984;
+        'E'..='H' => Ok((c as u8 as u32 - 'E' as u8 as u32) + 1984),
+        'J'..='N' => Ok((c as u8 as u32 - 'J' as u8 as u32) + 1988),
+        'P' => Ok(1993),
+        'R'..='T' => Ok((c as u8 as u32 - 'R' as u8 as u32) + 1994),
+        'V'..='Y' => Ok((c as u8 as u32 - 'V' as u8 as u32) + 1997),
+        '1'..='9' => Ok((c as u8 as u32 - '1' as u8 as u32) + 2001),
+        'A'..='D' => Ok((c as u8 as u32 - 'A' as u8 as u32) + 2010),
+        _ => Err(Exceptions::IllegalArgumentException(String::from(
+            "model year argument out of range",
+        ))),
     }
-    if (c >= 'J' && c <= 'N') {
+    // if c >= 'E' && c <= 'H' {
-      return (c - 'J') + 1988;
+    //   return (c - 'E') + 1984;
-    }
+    // }
-    if (c == 'P') {
+    // if c >= 'J' && c <= 'N' {
-      return 1993;
+    //   return (c - 'J') + 1988;
-    }
+    // }
-    if (c >= 'R' && c <= 'T') {
+    // if c == 'P' {
-      return (c - 'R') + 1994;
+    //   return 1993;
-    }
+    // }
-    if (c >= 'V' && c <= 'Y') {
+    // if c >= 'R' && c <= 'T' {
-      return (c - 'V') + 1997;
+    //   return (c - 'R') + 1994;
-    }
+    // }
-    if (c >= '1' && c <= '9') {
+    // if c >= 'V' && c <= 'Y' {
-      return (c - '1') + 2001;
+    //   return (c - 'V') + 1997;
-    }
+    // }
-    if (c >= 'A' && c <= 'D') {
+    // if c >= '1' && c <= '9' {
-      return (c - 'A') + 2010;
+    //   return (c - '1') + 2001;
-    }
+    // }
-    throw new IllegalArgumentException();
+    // if c >= 'A' && c <= 'D' {
+    //   return (c - 'A') + 2010;
+    // }
+    // throw new IllegalArgumentException();
 }
 
 fn countryCode(wmi: &str) -> Option<&'static str> {
@@ -178,6 +230,6 @@ pub fn parse(result: &RXingResult) -> Option<ParsedClientResult> {
         'W' => Some("DE"),
         'X' if (c2 == '0' || (c2 >= '3' && c2 <= '9')) => Some("RU"),
         'Z' if (c2 >= 'A' && c2 <= 'R') => Some("IT"),
-_ => None
+        _ => None,
     }
 }