ak/rxing
1
0
Fork 0
mirror of https://github.com/starovoid/rxing.git synced 2026-07-27 21:02:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

fairly major reorganization and clippy cleanup

Browse Source
This commit is contained in:
Henry
2023-01-10 15:28:36 -06:00
parent 59183a5383
commit a32de48f34
42 changed files with 199 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/aztec/DetectorTest.rs
View File

@@ -79,8 +79,9 @@ fn test_aztec_rxing_result_sample() {
// Test that we can tolerate errors in the parameter locator bits
fn test_error_in_parameter_locator(data: &str) {
let aztec = encoder::encoder::encode(data, 25, encoder::encoder::DEFAULT_AZTEC_LAYERS)
.expect("encode should create");
let aztec =
encoder::aztec_encoder::encode(data, 25, encoder::aztec_encoder::DEFAULT_AZTEC_LAYERS)
.expect("encode should create");
// dbg!(aztec.getMatrix().to_string());
let mut random = rand::thread_rng(); //Random(aztec.getMatrix().hashCode()); // pseudo-random, but deterministic
let layers = aztec.getLayers();

42
src/aztec/EncoderTest.rs
View File

@@ -28,7 +28,7 @@ use crate::{
BarcodeFormat, EncodeHintType, EncodeHintValue, RXingResultPoint,
};
use super::{encoder::encoder, AztecWriter};
use super::{encoder::aztec_encoder, AztecWriter};
use crate::Writer;
@@ -180,10 +180,10 @@ fn testAztecWriter() {
let matrix = writer
.encode(data, &BarcodeFormat::AZTEC, 0, 0)
.expect("matrix must exist");
let aztec = encoder::encode(
let aztec = aztec_encoder::encode(
data,
encoder::DEFAULT_EC_PERCENT,
encoder::DEFAULT_AZTEC_LAYERS,
aztec_encoder::DEFAULT_EC_PERCENT,
aztec_encoder::DEFAULT_AZTEC_LAYERS,
)
.expect("encode should succeed");
let expected_matrix = aztec.getMatrix();
@@ -599,15 +599,15 @@ fn testUserSpecifiedLayers2() {
fn doTestUserSpecifiedLayers(userSpecifiedLayers: i32) {
let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
let mut aztec = encoder::encode(alphabet, 25, -2).expect("should encode");
let mut aztec = aztec_encoder::encode(alphabet, 25, -2).expect("should encode");
assert_eq!(2, aztec.getLayers());
assert!(aztec.isCompact());
aztec = encoder::encode(alphabet, 25, 32).expect("should encode");
aztec = aztec_encoder::encode(alphabet, 25, 32).expect("should encode");
assert_eq!(32, aztec.getLayers());
assert!(!aztec.isCompact());
encoder::encode(alphabet, 25, userSpecifiedLayers).expect("encode");
aztec_encoder::encode(alphabet, 25, userSpecifiedLayers).expect("encode");
}
#[test]
@@ -618,7 +618,7 @@ fn testBorderCompact4CaseFailed() {
let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// encodes as 26 * 5 * 4 = 520 bits of data
let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
encoder::encode(&alphabet4, 0, -4).expect("encode");
aztec_encoder::encode(&alphabet4, 0, -4).expect("encode");
}
#[test]
@@ -630,14 +630,14 @@ fn testBorderCompact4Case() {
let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
// If we just try to encode it normally, it will go to a non-compact 4 layer
let mut aztecCode =
encoder::encode(&alphabet4, 0, encoder::DEFAULT_AZTEC_LAYERS).expect("Should encode");
let mut aztecCode = aztec_encoder::encode(&alphabet4, 0, aztec_encoder::DEFAULT_AZTEC_LAYERS)
.expect("Should encode");
assert!(!aztecCode.isCompact());
assert_eq!(4, aztecCode.getLayers());
// But shortening the string to 100 bytes (500 bits of data), compact works fine, even if we
// include more error checking.
aztecCode = encoder::encode(&alphabet4[..100], 10, encoder::DEFAULT_AZTEC_LAYERS)
aztecCode = aztec_encoder::encode(&alphabet4[..100], 10, aztec_encoder::DEFAULT_AZTEC_LAYERS)
.expect("should encode");
assert!(aztecCode.isCompact());
assert_eq!(4, aztecCode.getLayers());
@@ -646,7 +646,8 @@ fn testBorderCompact4Case() {
// Helper routines
fn testEncode(data: &str, compact: bool, layers: u32, expected: &str) {
let aztec = encoder::encode(data, 33, encoder::DEFAULT_AZTEC_LAYERS).expect("should encode");
let aztec = aztec_encoder::encode(data, 33, aztec_encoder::DEFAULT_AZTEC_LAYERS)
.expect("should encode");
assert_eq!(
compact,
aztec.isCompact(),
@@ -661,7 +662,8 @@ fn testEncode(data: &str, compact: bool, layers: u32, expected: &str) {
}
fn testEncodeDecode(data: &str, compact: bool, layers: u32) {
let aztec = encoder::encode(data, 25, encoder::DEFAULT_AZTEC_LAYERS).expect("should encode");
let aztec = aztec_encoder::encode(data, 25, aztec_encoder::DEFAULT_AZTEC_LAYERS)
.expect("should encode");
assert_eq!(
compact,
aztec.isCompact(),
@@ -737,9 +739,13 @@ fn testWriter(
Some(cs) => cs,
None => encoding::all::ISO_8859_1,
};
let aztec =
encoder::encode_with_charset(data, ecc_percent, encoder::DEFAULT_AZTEC_LAYERS, cset)
.expect("encode should encode");
let aztec = aztec_encoder::encode_with_charset(
data,
ecc_percent,
aztec_encoder::DEFAULT_AZTEC_LAYERS,
cset,
)
.expect("encode should encode");
assert_eq!(
compact,
aztec.isCompact(),
@@ -794,7 +800,7 @@ fn getPseudoRandom() -> rand::rngs::ThreadRng {
}
fn testModeMessageComplex(compact: bool, layers: u32, words: u32, expected: &str) {
let indata = encoder::generateModeMessage(compact, layers, words).expect("generate mode");
let indata = aztec_encoder::generateModeMessage(compact, layers, words).expect("generate mode");
assert_eq!(
stripSpace(expected),
stripSpace(&indata.to_string()),
@@ -804,7 +810,7 @@ fn testModeMessageComplex(compact: bool, layers: u32, words: u32, expected: &str
fn testStuffBits(wordSize: usize, bits: &str, expected: &str) {
let indata = toBitArray(bits);
let stuffed = encoder::stuffBits(&indata, wordSize);
let stuffed = aztec_encoder::stuffBits(&indata, wordSize);
assert_eq!(
stripSpace(expected),
stripSpace(&stuffed.to_string()),

10
src/aztec/aztec_writer.rs
View File

@@ -23,7 +23,7 @@ use crate::{
Writer,
};
use super::encoder::{encoder, AztecCode};
use super::encoder::{aztec_encoder, AztecCode};
/**
* Renders an Aztec code as a {@link BitMatrix}.
@@ -51,8 +51,8 @@ impl Writer for AztecWriter {
hints: &std::collections::HashMap<crate::EncodeHintType, crate::EncodeHintValue>,
) -> Result<crate::common::BitMatrix, crate::exceptions::Exceptions> {
let mut charset = None; // Do not add any ECI code by default
let mut ecc_percent = encoder::DEFAULT_EC_PERCENT;
let mut layers = encoder::DEFAULT_AZTEC_LAYERS;
let mut ecc_percent = aztec_encoder::DEFAULT_EC_PERCENT;
let mut layers = aztec_encoder::DEFAULT_AZTEC_LAYERS;
if hints.contains_key(&EncodeHintType::CHARACTER_SET) {
if let EncodeHintValue::CharacterSet(cset_name) = hints
.get(&EncodeHintType::CHARACTER_SET)
@@ -113,9 +113,9 @@ fn encode(
}
let aztec = if let Some(cset) = charset {
// dbg!(cset.name(), cset.whatwg_name());
encoder::encode_with_charset(contents, ecc_percent, layers, cset)?
aztec_encoder::encode_with_charset(contents, ecc_percent, layers, cset)?
} else {
encoder::encode(contents, ecc_percent, layers)?
aztec_encoder::encode(contents, ecc_percent, layers)?
};
renderRXingResult(&aztec, width, height)
}

0
src/aztec/encoder/encoder.rs → src/aztec/encoder/aztec_encoder.rs
View File

2
src/aztec/encoder/mod.rs
View File

@@ -5,7 +5,7 @@ mod simple_token;
mod state;
mod token;
pub mod encoder;
pub mod aztec_encoder;
pub use aztec_code::*;
pub use binary_shift_token::*;

1
src/client/result/AddressBookParsedResult.rs
View File

@@ -100,6 +100,7 @@ impl AddressBookParsedRXingResult {
)
}
#[allow(clippy::too_many_arguments)]
pub fn with_details(
names: Vec<String>,
nicknames: Vec<String>,

1
src/client/result/CalendarParsedResult.rs
View File

@@ -97,6 +97,7 @@ impl ParsedRXingResult for CalendarParsedRXingResult {
}
impl CalendarParsedRXingResult {
#[allow(clippy::too_many_arguments)]
pub fn new(
summary: String,
startString: String,

1
src/client/result/ExpandedProductParsedResult.rs
View File

@@ -73,6 +73,7 @@ impl ExpandedProductParsedRXingResult {
pub const KILOGRAM: &'static str = "KG";
pub const POUND: &'static str = "LB";
#[allow(clippy::too_many_arguments)]
pub fn new(
rawText: String,
productID: String,

1
src/client/result/VINParsedResult.rs
View File

@@ -62,6 +62,7 @@ impl ParsedRXingResult for VINParsedRXingResult {
}
}
impl VINParsedRXingResult {
#[allow(clippy::too_many_arguments)]
pub fn new(
vin: String,
world_manufacturer_id: String,

1
src/client/result/WifiParsedResult.rs
View File

@@ -74,6 +74,7 @@ impl WifiParsedRXingResult {
)
}
#[allow(clippy::too_many_arguments)]
pub fn with_details(
networkEncryption: String,
ssid: String,

1
src/common/bit_matrix.rs
View File

@@ -209,7 +209,6 @@ impl BitMatrix {
#[inline(always)]
fn get_offset(&self, y: u32, x: u32) -> usize {
y as usize * self.row_size + (x as usize / 32)
}

1
src/common/detector/monochrome_rectangle_detector.rs
View File

@@ -143,6 +143,7 @@ impl<'a> MonochromeRectangleDetector<'_> {
* @return a {@link RXingResultPoint} encapsulating the corner that was found
* @throws NotFoundException if such a point cannot be found
*/
#[allow(clippy::too_many_arguments)]
fn findCornerFromCenter(
&self,
centerX: i32,

1
src/common/grid_sampler.rs
View File

@@ -86,6 +86,7 @@ pub trait GridSampler {
* @throws NotFoundException if image can't be sampled, for example, if the transformation defined
* by the given points is invalid or results in sampling outside the image boundaries
*/
#[allow(clippy::too_many_arguments)]
fn sample_grid_detailed(
&self,
image: &BitMatrix,

4
src/common/perspective_transform.rs
View File

@@ -36,6 +36,7 @@ pub struct PerspectiveTransform {
}
impl PerspectiveTransform {
#[allow(clippy::too_many_arguments)]
fn new(
a11: f32,
a21: f32,
@@ -60,6 +61,7 @@ impl PerspectiveTransform {
}
}
#[allow(clippy::too_many_arguments)]
pub fn quadrilateralToQuadrilateral(
x0: f32,
y0: f32,
@@ -118,6 +120,7 @@ impl PerspectiveTransform {
}
}
#[allow(clippy::too_many_arguments)]
pub fn squareToQuadrilateral(
x0: f32,
y0: f32,
@@ -165,6 +168,7 @@ impl PerspectiveTransform {
}
}
#[allow(clippy::too_many_arguments)]
pub fn quadrilateralToSquare(
x0: f32,
y0: f32,

0
src/datamatrix/decoder/decoder.rs → src/datamatrix/decoder/datamatrix_decoder.rs
View File

4
src/datamatrix/decoder/mod.rs
View File

@@ -1,11 +1,11 @@
mod bit_matrix_parser;
mod data_block;
mod decoder;
mod datamatrix_decoder;
mod version;
pub use bit_matrix_parser::*;
pub use data_block::*;
pub use decoder::*;
pub use datamatrix_decoder::*;
pub use version::*;
pub mod decoded_bit_stream_parser;

0
src/datamatrix/detector/detector.rs → src/datamatrix/detector/datamatrix_detector.rs
View File

4
src/datamatrix/detector/mod.rs
View File

@@ -1,4 +1,4 @@
mod datamatrix_detector;
mod datamatrix_result;
mod detector;
pub use datamatrix_detector::*;
pub use datamatrix_result::*;
pub use detector::*;

0
src/datamatrix/encoder/encoder.rs → src/datamatrix/encoder/datamatrix_encoder.rs
View File

4
src/datamatrix/encoder/mod.rs
View File

@@ -1,5 +1,5 @@
mod datamatrix_encoder;
mod default_placement;
mod encoder;
mod encoder_context;
pub mod error_correction;
pub mod high_level_encoder;
@@ -7,8 +7,8 @@ pub mod minimal_encoder;
mod symbol_info;
mod symbol_shape_hint;
pub use datamatrix_encoder::*;
pub use default_placement::*;
pub use encoder::*;
pub use encoder_context::*;
pub use symbol_info::*;
pub use symbol_shape_hint::*;

1
src/datamatrix/encoder/symbol_info.rs
View File

@@ -93,6 +93,7 @@ impl SymbolInfo {
)
}
#[allow(clippy::too_many_arguments)]
pub fn with_details(
rectangular: bool,
dataCapacity: u32,

0
src/maxicode/decoder/decoder.rs → src/maxicode/decoder/maxicode_decoder.rs
View File

4
src/maxicode/decoder/mod.rs
View File

@@ -1,6 +1,6 @@
mod bit_matrix_parser;
pub mod decoded_bit_stream_parser;
pub mod decoder;
pub mod maxicode_decoder;
pub use bit_matrix_parser::*;
pub use decoder::*;
pub use maxicode_decoder::*;

4
src/maxicode/maxi_code_reader.rs
View File

@@ -20,7 +20,7 @@ use crate::{
common::BitMatrix, BarcodeFormat, Exceptions, RXingResult, RXingResultMetadataType, Reader,
};
use super::decoder::decoder;
use super::decoder::maxicode_decoder;
/**
* This implementation can detect and decode a MaxiCode in an image.
@@ -62,7 +62,7 @@ impl Reader for MaxiCodeReader {
// Note that MaxiCode reader effectively always assumes PURE_BARCODE mode
// and can't detect it in an image
let bits = Self::extractPureBits(image.getBlackMatrix())?;
let decoderRXingResult = decoder::decode_with_hints(bits, hints)?;
let decoderRXingResult = maxicode_decoder::decode_with_hints(bits, hints)?;
let mut result = RXingResult::new(
decoderRXingResult.getText(),
decoderRXingResult.getRawBytes().clone(),

2
src/multi/qrcode/qr_code_multi_reader.rs
View File

@@ -53,7 +53,7 @@ impl MultipleBarcodeReader for QRCodeMultiReader {
let detectorRXingResults = MultiDetector::new(image.getBlackMatrix()).detectMulti(hints)?;
for detectorRXingResult in detectorRXingResults {
let mut proc = || -> Result<(), Exceptions> {
let decoderRXingResult = decoder::decoder::decode_bitmatrix_with_hints(
let decoderRXingResult = decoder::qrcode_decoder::decode_bitmatrix_with_hints(
detectorRXingResult.getBits(),
hints,
)?;

14
src/pdf417/decoder/barcode_value.rs
View File

@@ -50,12 +50,14 @@ impl BarcodeValue {
let mut result = Vec::new();
for (key, value) in &self.0 {
// for (Entry<Integer,Integer> entry : values.entrySet()) {
if *value as i32 > maxConfidence {
maxConfidence = *value as i32;
result.clear();
result.push(*key);
} else if *value as i32 == maxConfidence {
result.push(*key);
match (*value as i32).cmp(&maxConfidence) {
std::cmp::Ordering::Greater => {
maxConfidence = *value as i32;
result.clear();
result.push(*key);
}
std::cmp::Ordering::Equal => result.push(*key),
std::cmp::Ordering::Less => {}
}
}

1
src/pdf417/decoder/pdf_417_scanning_decoder.rs
View File

@@ -648,6 +648,7 @@ fn getStartColumn(
}
}
#[allow(clippy::too_many_arguments)]
fn detectCodeword(
image: &BitMatrix,
minColumn: u32,

2
src/pdf417/detector/mod.rs
View File

@@ -1,4 +1,4 @@
mod pdf_417_detector_result;
pub use pdf_417_detector_result::*;
pub mod detector;
pub mod pdf_417_detector;

0
src/pdf417/detector/detector.rs → src/pdf417/detector/pdf_417_detector.rs
View File

4
src/pdf417/pdf_417_reader.rs
View File

@@ -23,7 +23,7 @@ use crate::{
};
use super::{
decoder::pdf_417_scanning_decoder, detector::detector, pdf_417_common,
decoder::pdf_417_scanning_decoder, detector::pdf_417_detector, pdf_417_common,
PDF417RXingResultMetadata,
};
@@ -95,7 +95,7 @@ impl PDF417Reader {
multiple: bool,
) -> Result<Vec<RXingResult>, Exceptions> {
let mut results = Vec::new(); //new ArrayList<>();
let detectorRXingResult = detector::detect_with_hints(image, hints, multiple)?;
let detectorRXingResult = pdf_417_detector::detect_with_hints(image, hints, multiple)?;
for points in detectorRXingResult.getPoints() {
let points_filtered = points.iter().filter_map(|e| *e).collect();
// for (RXingResultPoint[] points : detectorRXingResult.getPoints()) {

1
src/planar_yuv_luminance_source.rs
View File

@@ -153,6 +153,7 @@ pub struct PlanarYUVLuminanceSource {
}
impl PlanarYUVLuminanceSource {
#[allow(clippy::too_many_arguments)]
pub fn new_with_all(
yuv_data: Vec<u8>,
data_width: usize,

2
src/qrcode/decoder/mod.rs
View File

@@ -2,11 +2,11 @@ mod bit_matrix_parser;
mod data_block;
mod data_mask;
pub mod decoded_bit_stream_parser;
pub mod decoder;
mod error_correction_level;
mod format_information;
mod mode;
mod qr_code_decoder_meta_data;
pub mod qrcode_decoder;
mod version;
#[cfg(test)]

0
src/qrcode/decoder/decoder.rs → src/qrcode/decoder/qrcode_decoder.rs
View File

10
src/qrcode/detector/detector_test.rs
View File

@@ -3,7 +3,8 @@ use std::collections::HashMap;
use crate::{
common::{BitMatrix, DetectorRXingResult},
qrcode::{
decoder::decoder, decoder::ErrorCorrectionLevel, detector::Detector, encoder::encoder,
decoder::qrcode_decoder, decoder::ErrorCorrectionLevel, detector::Detector,
encoder::qrcode_encoder,
},
};
@@ -26,8 +27,8 @@ fn test_encode_decode(value: &str) {
for ec_level_v in 0..4 {
let ec_level: ErrorCorrectionLevel =
ErrorCorrectionLevel::forBits(ec_level_v).expect("must get level");
let qr_code =
encoder::encode_with_hints(value, ec_level, &HashMap::new()).expect("must encode");
let qr_code = qrcode_encoder::encode_with_hints(value, ec_level, &HashMap::new())
.expect("must encode");
// dbg!(&qr_code.to_string());
let byt_matrix = qr_code.getMatrix().as_ref().unwrap().clone();
// dbg!(BitMatrix::from(byt_matrix.clone()).to_string());
@@ -35,7 +36,8 @@ fn test_encode_decode(value: &str) {
let new_matrix: &BitMatrix = &byt_matrix.into();
let mut detector = Detector::new(new_matrix);
let detected_points = detector.detect().expect("must detect");
let decoded = decoder::decode_bitmatrix(detected_points.getBits()).expect("must decode");
let decoded =
qrcode_decoder::decode_bitmatrix(detected_points.getBits()).expect("must decode");
assert_eq!(decoded.getText(), value);
}
}

4
src/qrcode/detector/mod.rs
View File

@@ -1,17 +1,17 @@
mod alignment_pattern;
mod alignment_pattern_finder;
mod detector;
mod finder_pattern;
mod finder_pattern_finder;
mod finder_pattern_info;
mod qrcode_detector;
mod qrcode_detector_result;
pub use alignment_pattern::*;
pub use alignment_pattern_finder::*;
pub use detector::*;
pub use finder_pattern::*;
pub use finder_pattern_finder::*;
pub use finder_pattern_info::*;
pub use qrcode_detector::*;
pub use qrcode_detector_result::*;
#[cfg(test)]

0
src/qrcode/detector/detector.rs → src/qrcode/detector/qrcode_detector.rs
View File

203
src/qrcode/encoder/EncoderTestCase.rs
View File

@@ -20,7 +20,7 @@ use crate::{
common::BitArray,
qrcode::{
decoder::{ErrorCorrectionLevel, Mode, Version},
encoder::{encoder, MinimalEncoder},
encoder::{qrcode_encoder, MinimalEncoder},
},
EncodeHintType, EncodeHintValue,
};
@@ -42,7 +42,10 @@ fn testGetAlphanumericCode() {
// The first ten code points are numbers.
for i in 0..10u8 {
// for (int i = 0; i < 10; ++i) {
assert_eq!(i as i8, encoder::getAlphanumericCode((b'0' + i) as u32));
assert_eq!(
i as i8,
qrcode_encoder::getAlphanumericCode((b'0' + i) as u32)
);
}
// The next 26 code points are capital alphabet letters.
@@ -50,32 +53,32 @@ fn testGetAlphanumericCode() {
// for (int i = 10; i < 36; ++i) {
assert_eq!(
i as i8,
encoder::getAlphanumericCode((b'A' + i - 10) as u32)
qrcode_encoder::getAlphanumericCode((b'A' + i - 10) as u32)
);
}
// Others are symbol letters
assert_eq!(36, encoder::getAlphanumericCode(b' ' as u32));
assert_eq!(37, encoder::getAlphanumericCode(b'$' as u32));
assert_eq!(38, encoder::getAlphanumericCode(b'%' as u32));
assert_eq!(39, encoder::getAlphanumericCode(b'*' as u32));
assert_eq!(40, encoder::getAlphanumericCode(b'+' as u32));
assert_eq!(41, encoder::getAlphanumericCode(b'-' as u32));
assert_eq!(42, encoder::getAlphanumericCode(b'.' as u32));
assert_eq!(43, encoder::getAlphanumericCode(b'/' as u32));
assert_eq!(44, encoder::getAlphanumericCode(b':' as u32));
assert_eq!(36, qrcode_encoder::getAlphanumericCode(b' ' as u32));
assert_eq!(37, qrcode_encoder::getAlphanumericCode(b'$' as u32));
assert_eq!(38, qrcode_encoder::getAlphanumericCode(b'%' as u32));
assert_eq!(39, qrcode_encoder::getAlphanumericCode(b'*' as u32));
assert_eq!(40, qrcode_encoder::getAlphanumericCode(b'+' as u32));
assert_eq!(41, qrcode_encoder::getAlphanumericCode(b'-' as u32));
assert_eq!(42, qrcode_encoder::getAlphanumericCode(b'.' as u32));
assert_eq!(43, qrcode_encoder::getAlphanumericCode(b'/' as u32));
assert_eq!(44, qrcode_encoder::getAlphanumericCode(b':' as u32));
// Should return -1 for other letters;
assert_eq!(-1, encoder::getAlphanumericCode(b'a' as u32));
assert_eq!(-1, encoder::getAlphanumericCode(b'#' as u32));
assert_eq!(-1, encoder::getAlphanumericCode(b'\0' as u32));
assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'a' as u32));
assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'#' as u32));
assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'\0' as u32));
}
#[test]
fn test_digits_only() {
let test_data = "374833744734397449";
let data = encoder::encode(test_data, ErrorCorrectionLevel::H).expect("encode");
let decode = crate::qrcode::decoder::decoder::decode_bitmatrix(
let data = qrcode_encoder::encode(test_data, ErrorCorrectionLevel::H).expect("encode");
let decode = crate::qrcode::decoder::qrcode_decoder::decode_bitmatrix(
&data.getMatrix().as_ref().unwrap().clone().into(),
)
.expect("decode");
@@ -85,18 +88,18 @@ fn test_digits_only() {
#[test]
fn testChooseMode() {
// Numeric Mode::
assert_eq!(Mode::NUMERIC, encoder::chooseMode("0"));
assert_eq!(Mode::NUMERIC, encoder::chooseMode("0123456789"));
assert_eq!(Mode::NUMERIC, qrcode_encoder::chooseMode("0"));
assert_eq!(Mode::NUMERIC, qrcode_encoder::chooseMode("0123456789"));
// Alphanumeric Mode::
assert_eq!(Mode::ALPHANUMERIC, encoder::chooseMode("A"));
assert_eq!(Mode::ALPHANUMERIC, qrcode_encoder::chooseMode("A"));
assert_eq!(
Mode::ALPHANUMERIC,
encoder::chooseMode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
qrcode_encoder::chooseMode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
);
// 8-bit byte Mode::
assert_eq!(Mode::BYTE, encoder::chooseMode("a"));
assert_eq!(Mode::BYTE, encoder::chooseMode("#"));
assert_eq!(Mode::BYTE, encoder::chooseMode(""));
assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode("a"));
assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode("#"));
assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode(""));
// Kanji Mode:: We used to use MODE_KANJI for these, but we stopped
// doing that as we cannot distinguish Shift_JIS from other encodings
// from data bytes alone. See also comments in qrcode_encoder::h.
@@ -104,25 +107,25 @@ fn testChooseMode() {
// AIUE in Hiragana in Shift_JIS
assert_eq!(
Mode::BYTE,
encoder::chooseMode(&shiftJISString(&[0x8, 0xa, 0x8, 0xa, 0x8, 0xa, 0x8, 0xa6]))
qrcode_encoder::chooseMode(&shiftJISString(&[0x8, 0xa, 0x8, 0xa, 0x8, 0xa, 0x8, 0xa6]))
);
// Nihon in Kanji in Shift_JIS.
assert_eq!(
Mode::BYTE,
encoder::chooseMode(&shiftJISString(&[0x9, 0xf, 0x9, 0x7b]))
qrcode_encoder::chooseMode(&shiftJISString(&[0x9, 0xf, 0x9, 0x7b]))
);
// Sou-Utsu-Byou in Kanji in Shift_JIS.
assert_eq!(
Mode::BYTE,
encoder::chooseMode(&shiftJISString(&[0xe, 0x4, 0x9, 0x5, 0x9, 0x61]))
qrcode_encoder::chooseMode(&shiftJISString(&[0xe, 0x4, 0x9, 0x5, 0x9, 0x61]))
);
}
#[test]
fn testEncode() {
let qrCode = encoder::encode("ABCDEF", ErrorCorrectionLevel::H).expect("encode");
let qrCode = qrcode_encoder::encode("ABCDEF", ErrorCorrectionLevel::H).expect("encode");
let expected = r"<<
mode: ALPHANUMERIC
ecLevel: H
@@ -162,8 +165,8 @@ fn testEncodeWithVersion() {
EncodeHintType::QR_VERSION,
EncodeHintValue::QrVersion("7".to_owned()),
);
let qrCode =
encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
.expect("encode");
assert!(qrCode.to_string().contains(" version: 7\n"));
}
@@ -175,7 +178,7 @@ fn testEncodeWithVersionTooSmall() {
EncodeHintType::QR_VERSION,
EncodeHintValue::QrVersion("3".to_owned()),
);
encoder::encode_with_hints(
qrcode_encoder::encode_with_hints(
"THISMESSAGEISTOOLONGFORAQRCODEVERSION3",
ErrorCorrectionLevel::H,
&hints,
@@ -190,8 +193,8 @@ fn testSimpleutf8ECI() {
EncodeHintType::CHARACTER_SET,
EncodeHintValue::CharacterSet("utf8".to_owned()),
);
let qrCode =
encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints).expect("encode");
let qrCode = qrcode_encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints)
.expect("encode");
let expected = r"<<
mode: BYTE
ecLevel: H
@@ -233,8 +236,9 @@ fn testEncodeKanjiMode() {
EncodeHintValue::CharacterSet("Shift_JIS".to_owned()),
);
// Nihon in Kanji
let qrCode = encoder::encode_with_hints("\u{65e5}\u{672c}", ErrorCorrectionLevel::M, &hints)
.expect("encode");
let qrCode =
qrcode_encoder::encode_with_hints("\u{65e5}\u{672c}", ErrorCorrectionLevel::M, &hints)
.expect("encode");
let expected = r"<<
mode: KANJI
ecLevel: M
@@ -277,7 +281,7 @@ fn testEncodeShiftjisNumeric() {
);
let qrCode =
encoder::encode_with_hints("0123", ErrorCorrectionLevel::M, &hints).expect("encode");
qrcode_encoder::encode_with_hints("0123", ErrorCorrectionLevel::M, &hints).expect("encode");
let expected = r"<<
mode: NUMERIC
ecLevel: M
@@ -315,8 +319,9 @@ fn testEncodeGS1WithStringTypeHint() {
let mut hints = HashMap::new();
hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
let qrCode = encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
.expect("encode");
let qrCode =
qrcode_encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
.expect("encode");
verifyGS1EncodedData(&qrCode);
}
@@ -325,8 +330,9 @@ fn testEncodeGS1WithBooleanTypeHint() {
let mut hints = HashMap::new();
hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
let qrCode = encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
.expect("encode");
let qrCode =
qrcode_encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
.expect("encode");
verifyGS1EncodedData(&qrCode);
}
@@ -339,8 +345,8 @@ fn testDoesNotEncodeGS1WhenBooleanTypeHintExplicitlyFalse() {
EncodeHintValue::Gs1Format(false),
);
let qrCode =
encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
.expect("encode");
verifyNotGS1EncodedData(&qrCode);
}
@@ -352,8 +358,8 @@ fn testDoesNotEncodeGS1WhenStringTypeHintExplicitlyFalse() {
EncodeHintType::GS1_FORMAT,
EncodeHintValue::Gs1Format(false),
);
let qrCode =
encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
.expect("encode");
verifyNotGS1EncodedData(&qrCode);
}
@@ -366,8 +372,8 @@ fn testGS1ModeHeaderWithECI() {
EncodeHintValue::CharacterSet("utf8".to_owned()),
);
hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
let qrCode =
encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints).expect("encode");
let qrCode = qrcode_encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints)
.expect("encode");
let expected = r"<<
mode: BYTE
ecLevel: H
@@ -403,14 +409,14 @@ fn testGS1ModeHeaderWithECI() {
#[test]
fn testAppendModeInfo() {
let mut bits = BitArray::new();
assert!(encoder::appendModeInfo(Mode::NUMERIC, &mut bits).is_ok());
assert!(qrcode_encoder::appendModeInfo(Mode::NUMERIC, &mut bits).is_ok());
assert_eq!(" ...X", bits.to_string());
}
#[test]
fn testAppendLengthInfo() {
let mut bits = BitArray::new();
encoder::appendLengthInfo(
qrcode_encoder::appendLengthInfo(
1, // 1 letter (1/1).
Version::getVersionForNumber(1).unwrap(),
Mode::NUMERIC,
@@ -419,7 +425,7 @@ fn testAppendLengthInfo() {
.expect("ok");
assert_eq!(" ........ .X", bits.to_string()); // 10 bits.
let mut bits = BitArray::new();
encoder::appendLengthInfo(
qrcode_encoder::appendLengthInfo(
2, // 2 letters (2/1).
Version::getVersionForNumber(10).unwrap(),
Mode::ALPHANUMERIC,
@@ -428,7 +434,7 @@ fn testAppendLengthInfo() {
.expect("ok");
assert_eq!(" ........ .X.", bits.to_string()); // 11 bits.
let mut bits = BitArray::new();
encoder::appendLengthInfo(
qrcode_encoder::appendLengthInfo(
255, // 255 letter (255/1).
Version::getVersionForNumber(27).unwrap(),
Mode::BYTE,
@@ -437,7 +443,7 @@ fn testAppendLengthInfo() {
.expect("ok");
assert_eq!(" ........ XXXXXXXX", bits.to_string()); // 16 bits.
let mut bits = BitArray::new();
encoder::appendLengthInfo(
qrcode_encoder::appendLengthInfo(
512, // 512 letters (1024/2).
Version::getVersionForNumber(40).unwrap(),
Mode::KANJI,
@@ -452,32 +458,32 @@ fn testAppendBytes() {
// Should use appendNumericBytes.
// 1 = 01 = 0001 in 4 bits.
let mut bits = BitArray::new();
encoder::appendBytes(
qrcode_encoder::appendBytes(
"1",
Mode::NUMERIC,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.expect("ok");
assert_eq!(" ...X", bits.to_string());
// Should use appendAlphanumericBytes.
// A = 10 = 0xa = 001010 in 6 bits
let mut bits = BitArray::new();
encoder::appendBytes(
qrcode_encoder::appendBytes(
"A",
Mode::ALPHANUMERIC,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.expect("ok");
assert_eq!(" ..X.X.", bits.to_string());
// Lower letters such as 'a' cannot be encoded in MODE_ALPHANUMERIC.
//try {
if encoder::appendBytes(
if qrcode_encoder::appendBytes(
"a",
Mode::ALPHANUMERIC,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.is_ok()
{
@@ -489,30 +495,30 @@ fn testAppendBytes() {
// Should use append8BitBytes.
// 0x61, 0x62, 0x63
let mut bits = BitArray::new();
encoder::appendBytes(
qrcode_encoder::appendBytes(
"abc",
Mode::BYTE,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.expect("ok");
assert_eq!(" .XX....X .XX...X. .XX...XX", bits.to_string());
// Anything can be encoded in QRCode.MODE_8BIT_BYTE.
encoder::appendBytes(
qrcode_encoder::appendBytes(
"\0",
Mode::BYTE,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.expect("ok");
// Should use appendKanjiBytes.
// 0x93, 0x5f
let mut bits = BitArray::new();
encoder::appendBytes(
qrcode_encoder::appendBytes(
&shiftJISString(&[0x93, 0x5f]),
Mode::KANJI,
&mut bits,
encoder::DEFAULT_BYTE_MODE_ENCODING,
qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
)
.expect("ok");
assert_eq!(" .XX.XX.. XXXXX", bits.to_string());
@@ -521,29 +527,29 @@ fn testAppendBytes() {
#[test]
fn testTerminateBits() {
let mut v = BitArray::new();
encoder::terminateBits(0, &mut v).expect("terminate");
qrcode_encoder::terminateBits(0, &mut v).expect("terminate");
assert_eq!("", v.to_string());
let mut v = BitArray::new();
encoder::terminateBits(1, &mut v).expect("terminate");
qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
assert_eq!(" ........", v.to_string());
let mut v = BitArray::new();
v.appendBits(0, 3).expect("terminate"); // Append 000
encoder::terminateBits(1, &mut v).expect("terminate");
qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
assert_eq!(" ........", v.to_string());
let mut v = BitArray::new();
v.appendBits(0, 5).expect("terminate"); // Append 00000
encoder::terminateBits(1, &mut v).expect("terminate");
qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
assert_eq!(" ........", v.to_string());
let mut v = BitArray::new();
v.appendBits(0, 8).expect("terminate"); // Append 00000000
encoder::terminateBits(1, &mut v).expect("terminate");
qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
assert_eq!(" ........", v.to_string());
let mut v = BitArray::new();
encoder::terminateBits(2, &mut v).expect("terminate");
qrcode_encoder::terminateBits(2, &mut v).expect("terminate");
assert_eq!(" ........ XXX.XX..", v.to_string());
let mut v = BitArray::new();
v.appendBits(0, 1).expect("terminate"); // Append 0
encoder::terminateBits(3, &mut v).expect("terminate");
qrcode_encoder::terminateBits(3, &mut v).expect("terminate");
assert_eq!(" ........ XXX.XX.. ...X...X", v.to_string());
}
@@ -551,43 +557,43 @@ fn testTerminateBits() {
fn testGetNumDataBytesAndNumECBytesForBlockID() {
// Version 1-H.
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(26, 9, 1, 0).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(26, 9, 1, 0).expect("ok");
assert_eq!(9, numDataBytes);
assert_eq!(17, numEcBytes);
// Version 3-H. 2 blocks.
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 0).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 0).expect("ok");
assert_eq!(13, numDataBytes);
assert_eq!(22, numEcBytes);
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 1).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 1).expect("ok");
assert_eq!(13, numDataBytes);
assert_eq!(22, numEcBytes);
// Version 7-H. (4 + 1) blocks.
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 0).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 0).expect("ok");
assert_eq!(13, numDataBytes);
assert_eq!(26, numEcBytes);
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 4).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 4).expect("ok");
assert_eq!(14, numDataBytes);
assert_eq!(26, numEcBytes);
// Version 40-H. (20 + 61) blocks.
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 0).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 0).expect("ok");
assert_eq!(15, numDataBytes);
assert_eq!(30, numEcBytes);
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 20).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 20).expect("ok");
assert_eq!(16, numDataBytes);
assert_eq!(30, numEcBytes);
let (numDataBytes, numEcBytes) =
encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 80).expect("ok");
qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 80).expect("ok");
assert_eq!(16, numDataBytes);
assert_eq!(30, numEcBytes);
}
@@ -600,7 +606,7 @@ fn testInterleaveWithECBytes() {
// for (byte dataByte: dataBytes) {
in_.appendBits(*dataByte, 8).expect("ok");
}
let out = encoder::interleaveWithECBytes(&in_, 26, 9, 1).expect("encode");
let out = qrcode_encoder::interleaveWithECBytes(&in_, 26, 9, 1).expect("encode");
let expected = &[
// Data bytes.
32, 65, 205, 69, 41, 220, 46, 128, 236, // Error correction bytes.
@@ -627,7 +633,7 @@ fn testInterleaveWithECBytes() {
in_.appendBits(*dataByte, 8).expect("ok");
}
let out = encoder::interleaveWithECBytes(&in_, 134, 62, 4).expect("interleave ok");
let out = qrcode_encoder::interleaveWithECBytes(&in_, 134, 62, 4).expect("interleave ok");
let expected = &[
// Data bytes.
67, 230, 54, 55, 70, 247, 70, 71, 22, 7, 86, 87, 38, 23, 102, 103, 54, 39, 118, 119, 70, 55,
@@ -660,23 +666,23 @@ fn testInterleaveWithECBytes() {
fn testAppendNumericBytes() {
// 1 = 01 = 0001 in 4 bits.
let mut bits = BitArray::new();
encoder::appendNumericBytes("1", &mut bits).expect("append");
qrcode_encoder::appendNumericBytes("1", &mut bits).expect("append");
assert_eq!(" ...X", bits.to_string());
// 12 = 0xc = 0001100 in 7 bits.
let mut bits = BitArray::new();
encoder::appendNumericBytes("12", &mut bits).expect("append");
qrcode_encoder::appendNumericBytes("12", &mut bits).expect("append");
assert_eq!(" ...XX..", bits.to_string());
// 123 = 0x7b = 0001111011 in 10 bits.
let mut bits = BitArray::new();
encoder::appendNumericBytes("123", &mut bits).expect("append");
qrcode_encoder::appendNumericBytes("123", &mut bits).expect("append");
assert_eq!(" ...XXXX. XX", bits.to_string());
// 1234 = "123" + "4" = 0001111011 + 0100
let mut bits = BitArray::new();
encoder::appendNumericBytes("1234", &mut bits).expect("append");
qrcode_encoder::appendNumericBytes("1234", &mut bits).expect("append");
assert_eq!(" ...XXXX. XX.X..", bits.to_string());
// Empty.
let mut bits = BitArray::new();
encoder::appendNumericBytes("", &mut bits).expect("append");
qrcode_encoder::appendNumericBytes("", &mut bits).expect("append");
assert_eq!("", bits.to_string());
}
@@ -684,23 +690,23 @@ fn testAppendNumericBytes() {
fn testAppendAlphanumericBytes() {
// A = 10 = 0xa = 001010 in 6 bits
let mut bits = BitArray::new();
encoder::appendAlphanumericBytes("A", &mut bits).expect("append");
qrcode_encoder::appendAlphanumericBytes("A", &mut bits).expect("append");
assert_eq!(" ..X.X.", bits.to_string());
// AB = 10 * 45 + 11 = 461 = 0x1cd = 00111001101 in 11 bits
let mut bits = BitArray::new();
encoder::appendAlphanumericBytes("AB", &mut bits).expect("append");
qrcode_encoder::appendAlphanumericBytes("AB", &mut bits).expect("append");
assert_eq!(" ..XXX..X X.X", bits.to_string());
// ABC = "AB" + "C" = 00111001101 + 001100
let mut bits = BitArray::new();
encoder::appendAlphanumericBytes("ABC", &mut bits).expect("append");
qrcode_encoder::appendAlphanumericBytes("ABC", &mut bits).expect("append");
assert_eq!(" ..XXX..X X.X..XX. .", bits.to_string());
// Empty.
let mut bits = BitArray::new();
encoder::appendAlphanumericBytes("", &mut bits).expect("append");
qrcode_encoder::appendAlphanumericBytes("", &mut bits).expect("append");
assert_eq!("", bits.to_string());
// Invalid data.
// try {
if encoder::appendAlphanumericBytes("abc", &mut BitArray::new()).is_ok() {
if qrcode_encoder::appendAlphanumericBytes("abc", &mut BitArray::new()).is_ok() {
panic!("should not be ok");
}
// } catch (WriterException we) {
@@ -712,12 +718,13 @@ fn testAppendAlphanumericBytes() {
fn testAppend8BitBytes() {
// 0x61, 0x62, 0x63
let mut bits = BitArray::new();
encoder::append8BitBytes("abc", &mut bits, encoder::DEFAULT_BYTE_MODE_ENCODING)
qrcode_encoder::append8BitBytes("abc", &mut bits, qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING)
.expect("append");
assert_eq!(" .XX....X .XX...X. .XX...XX", bits.to_string());
// Empty.
let mut bits = BitArray::new();
encoder::append8BitBytes("", &mut bits, encoder::DEFAULT_BYTE_MODE_ENCODING).expect("append");
qrcode_encoder::append8BitBytes("", &mut bits, qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING)
.expect("append");
assert_eq!("", bits.to_string());
}
@@ -725,9 +732,9 @@ fn testAppend8BitBytes() {
#[test]
fn testAppendKanjiBytes() {
let mut bits = BitArray::new();
encoder::appendKanjiBytes(&shiftJISString(&[0x93, 0x5f]), &mut bits).expect("append");
qrcode_encoder::appendKanjiBytes(&shiftJISString(&[0x93, 0x5f]), &mut bits).expect("append");
assert_eq!(" .XX.XX.. XXXXX", bits.to_string());
encoder::appendKanjiBytes(&shiftJISString(&[0xe4, 0xaa]), &mut bits).expect("append");
qrcode_encoder::appendKanjiBytes(&shiftJISString(&[0xe4, 0xaa]), &mut bits).expect("append");
assert_eq!(" .XX.XX.. XXXXXXX. X.X.X.X. X.", bits.to_string());
}
@@ -736,7 +743,7 @@ fn testAppendKanjiBytes() {
#[test]
fn testGenerateECBytes() {
let dataBytes = &[32, 65, 205, 69, 41, 220, 46, 128, 236];
let ecBytes = encoder::generateECBytes(dataBytes, 17);
let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 17);
let expected = [
42, 159, 74, 221, 244, 169, 239, 150, 138, 70, 237, 85, 224, 96, 74, 219, 61,
];
@@ -748,7 +755,7 @@ fn testGenerateECBytes() {
let dataBytes = &[
67, 70, 22, 38, 54, 70, 86, 102, 118, 134, 150, 166, 182, 198, 214,
];
let ecBytes = encoder::generateECBytes(dataBytes, 18);
let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 18);
let expected = &[
175, 80, 155, 64, 178, 45, 214, 233, 65, 209, 12, 155, 117, 31, 140, 214, 27, 187,
];
@@ -759,7 +766,7 @@ fn testGenerateECBytes() {
}
// High-order zero coefficient case.
let dataBytes = &[32, 49, 205, 69, 42, 20, 0, 236, 17];
let ecBytes = encoder::generateECBytes(dataBytes, 17);
let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 17);
let expected = &[
0, 3, 130, 179, 194, 0, 55, 211, 110, 79, 98, 72, 170, 96, 211, 137, 213,
];
@@ -805,7 +812,7 @@ fn testBugInBitVectorNumBytes() {
// for (int x = 0; x < 3518; x++) {
builder.push('0');
}
assert!(encoder::encode(&builder, ErrorCorrectionLevel::L).is_ok());
assert!(qrcode_encoder::encode(&builder, ErrorCorrectionLevel::L).is_ok());
}
#[test]

18
src/qrcode/encoder/minimal_encoder.rs
View File

@@ -26,7 +26,7 @@ use crate::{
use unicode_segmentation::UnicodeSegmentation;
use super::encoder;
use super::qrcode_encoder;
pub enum VersionSize {
SMALL, //("version 1-9"),
@@ -155,7 +155,7 @@ impl MinimalEncoder {
if let Some(version) = version {
// compute minimal encoding for a given version
let result = self.encodeSpecificVersion(version)?;
if !encoder::willFit(
if !qrcode_encoder::willFit(
result.getSize(),
Self::getVersion(Self::getVersionSize(result.getVersion())),
&self.ecLevel,
@@ -183,7 +183,8 @@ impl MinimalEncoder {
for i in 0..3 {
// for (int i = 0; i < 3; i++) {
let size = results[i].getSize();
if encoder::willFit(size, versions[i], &self.ecLevel) && size < smallestSize {
if qrcode_encoder::willFit(size, versions[i], &self.ecLevel) && size < smallestSize
{
smallestSize = size;
smallestRXingResult = i as i32;
}
@@ -235,13 +236,13 @@ impl MinimalEncoder {
}
pub fn isDoubleByteKanji(c: &str) -> bool {
encoder::isOnlyDoubleByteKanji(c)
qrcode_encoder::isOnlyDoubleByteKanji(c)
}
pub fn isAlphanumeric(c: &str) -> bool {
if c.len() == 1 {
let ch = c.chars().next().unwrap();
encoder::getAlphanumericCode(ch as u32) != -1
qrcode_encoder::getAlphanumericCode(ch as u32) != -1
} else {
false
}
@@ -612,6 +613,7 @@ pub struct Edge {
_stringToEncode: Vec<String>,
}
impl Edge {
#[allow(clippy::too_many_arguments)]
pub fn new(
mode: Mode,
fromPosition: usize,
@@ -881,7 +883,7 @@ impl RXingResultList {
let size = Self::internal_static_get_size(version, &list);
// increase version if needed
while versionNumber < upperLimit
&& !encoder::willFit(
&& !qrcode_encoder::willFit(
size,
Version::getVersionForNumber(versionNumber).unwrap(),
ecLevel,
@@ -891,7 +893,7 @@ impl RXingResultList {
}
// shrink version if possible
while versionNumber > lowerLimit
&& encoder::willFit(
&& qrcode_encoder::willFit(
size,
Version::getVersionForNumber(versionNumber - 1).unwrap(),
ecLevel,
@@ -1084,7 +1086,7 @@ impl RXingResultNode {
bits.appendBits(self.encoders.getECIValue(self.charsetEncoderIndex), 8)?;
} else if self.characterLength > 0 {
// append data
encoder::appendBytes(
qrcode_encoder::appendBytes(
// &self.stringToEncode[self.fromPosition as usize
// ..(self.fromPosition + self.characterLength as usize)],
&(self

2
src/qrcode/encoder/mod.rs
View File

@@ -1,10 +1,10 @@
mod block_pair;
mod byte_matrix;
pub mod encoder;
pub mod mask_util;
pub mod matrix_util;
mod minimal_encoder;
mod qr_code;
pub mod qrcode_encoder;
pub use block_pair::*;
pub use byte_matrix::*;

0
src/qrcode/encoder/encoder.rs → src/qrcode/encoder/qrcode_encoder.rs
View File

6
src/qrcode/qr_code_reader.rs
View File

@@ -23,7 +23,7 @@ use crate::{
};
use super::{
decoder::{decoder, QRCodeDecoderMetaData},
decoder::{qrcode_decoder, QRCodeDecoderMetaData},
detector::Detector,
};
@@ -64,13 +64,13 @@ impl Reader for QRCodeReader {
let mut points: Vec<RXingResultPoint>;
if hints.contains_key(&DecodeHintType::PURE_BARCODE) {
let bits = Self::extractPureBits(image.getBlackMatrix())?;
decoderRXingResult = decoder::decode_bitmatrix_with_hints(&bits, hints)?;
decoderRXingResult = qrcode_decoder::decode_bitmatrix_with_hints(&bits, hints)?;
points = Vec::new();
} else {
let detectorRXingResult =
Detector::new(image.getBlackMatrix()).detect_with_hints(hints)?;
decoderRXingResult =
decoder::decode_bitmatrix_with_hints(detectorRXingResult.getBits(), hints)?;
qrcode_decoder::decode_bitmatrix_with_hints(detectorRXingResult.getBits(), hints)?;
points = detectorRXingResult.getPoints().clone();
}

4
src/qrcode/qr_code_writer.rs
View File

@@ -22,7 +22,7 @@ use crate::{
use super::{
decoder::ErrorCorrectionLevel,
encoder::{encoder, QRCode},
encoder::{qrcode_encoder, QRCode},
};
const QUIET_ZONE_SIZE: i32 = 4;
@@ -102,7 +102,7 @@ impl Writer for QRCodeWriter {
}
// }
let code = encoder::encode_with_hints(contents, errorCorrectionLevel, hints)?;
let code = qrcode_encoder::encode_with_hints(contents, errorCorrectionLevel, hints)?;
Self::renderRXingResult(&code, width, height, quietZone)
}