mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 12:22:34 +00:00
Cleanup of many components of the code.
Many unwraps, expects, and panics removed or handled. More rustification of the codebase. Squashed commit of the following: commit 80c6483cf8c819496a7b781f9e3a149d1f18d5fe Author: Henry <henry@azule.info> Date: Fri Feb 10 20:36:57 2023 -0600 add other parsed result option commit 412d92ae585e7bf194697f5282dbc045e448bace Author: Henry <henry@azule.info> Date: Fri Feb 10 19:06:34 2023 -0600 fix some panics commit 9108d3e931aadec00fc0bf346ebc52d24e5d8146 Author: Henry <henry@azule.info> Date: Fri Feb 10 18:56:30 2023 -0600 clippy --fix commit 8cd89d314323f54f342f15fc73297b62d418ac79 Author: Henry <henry@azule.info> Date: Fri Feb 10 18:55:45 2023 -0600 some more cleanup in aztec commit fb7f9242e273b85a4bb212f22a185a0dcbfafc36 Author: Henry <henry@azule.info> Date: Fri Feb 10 18:19:54 2023 -0600 cleanup root commit 4fb7c0639830869149332b29be789e891eade3e7 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 16:50:15 2023 -0600 format commit 3ac271af657b25fbe5ee39cbdf8859e5aa38ea41 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 16:43:14 2023 -0600 clippy --fix commit 0c5b4c1477159db93a9da9645039f51cd1a7c574 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 16:04:31 2023 -0600 qrcode cleanup complete commit 70c1d107cc672e45d46567c650c46fece7e7da9c Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 13:28:25 2023 -0600 clippy --fix commit e13263d0f1f2a13dbb59b6e60d8b871a32babc92 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 13:27:44 2023 -0600 qrcode detector cleanup commit f7f2855099e469fe1091868c6099196705d0ae83 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 11:48:13 2023 -0600 qrcode decoder commit bdbaaba597b3479639c2ed3726465a69e3004471 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 11:13:18 2023 -0600 clippy --fix commit fd6dbcaeb1f45dc91ae98f0e7c58aad48d67df78 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 11:12:28 2023 -0600 pdf417 cleanup complete commit 7bbd47604c2639a5eb61bdb5533e71be3bce95a1 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 10:39:28 2023 -0600 clippy --fix commit 8f4962b7bb5f133524fe4d3d4948e5672a88c545 Author: Henry Schimke <henry@azule.info> Date: Fri Feb 10 10:39:00 2023 -0600 cleanup on pdf417 hie commit 254c8243953776d3c8704dd81529aadd05d5a94e Author: Henry <henry@azule.info> Date: Fri Feb 10 02:51:21 2023 +0000 partway through pdf417 hle commit d4a5b00fde8c0282b0c6e4175a21c1e111b11533 Author: Henry <henry@azule.info> Date: Wed Feb 8 21:35:25 2023 +0000 clippy --fix commit 2bd4a8e218aa963a88997b50bc5a198f9a88205e Author: Henry <henry@azule.info> Date: Wed Feb 8 21:31:55 2023 +0000 pdf417 decode and detect cleanup commit 05130ac54a72c2303045d64507bf6185aa74e531 Author: Henry Schimke <henry@azule.info> Date: Tue Feb 7 08:06:25 2023 -0600 at decodeTextCompaction in decoded_bit_straem_parser commit 924c023a7d2339dfffa6ef0c4a805fb192576796 Author: Henry Schimke <henry@azule.info> Date: Mon Feb 6 18:22:02 2023 -0600 clippy --fix commit 5cfb81a885c22b4b5ec937a79be31d0815def211 Author: Henry Schimke <henry@azule.info> Date: Mon Feb 6 18:20:22 2023 -0600 oned cleanup commit 0649b64854baf56a8e3314728d4f6cf4063db8b2 Author: Henry Schimke <henry@azule.info> Date: Mon Feb 6 11:47:28 2023 -0600 rss cleanup commit 2d3127898fc11f7e65d590e983cda799b798b646 Author: Henry Schimke <henry@azule.info> Date: Mon Feb 6 10:19:56 2023 -0600 multi cleanup commit 7e8b43a159083a2096123e6204d4d1d359c59981 Author: Henry <henry@azule.info> Date: Sun Feb 5 21:41:59 2023 -0600 cargo fmt commit df8285e8da07b4bffd48ca6e596de3f010eb8d9e Author: Henry <henry@azule.info> Date: Sun Feb 5 21:41:29 2023 -0600 maxicode cleanup commit a51f923a14016eb416ca202b2194258808dde3e7 Author: Henry <henry@azule.info> Date: Sun Feb 5 21:27:57 2023 -0600 cargo fmt commit 332d7eef4a25318611025a3fcb0b70c604d917be Author: Henry <henry@azule.info> Date: Sun Feb 5 21:27:48 2023 -0600 cleanup datamatrix commit eb2311c476a9c9993f271ab6cf9fd359aedca26f Author: Henry <henry@azule.info> Date: Sun Feb 5 21:27:26 2023 -0600 cargo clippy --fix commit 2abaa4c51d287f619d4c7a438f85ba2a30f159cf Author: Henry <henry@azule.info> Date: Sun Feb 5 19:13:02 2023 -0600 finish cleanup in parsers commit 716aa2fbf728716cff36657a5fd80e7bca5276b7 Author: Henry Schimke <henry@azule.info> Date: Sun Feb 5 17:44:56 2023 -0600 cleanup continues commit 7d843788a49fa9cc82c4616d226c0f882e73612b Author: Henry Schimke <henry@azule.info> Date: Sun Feb 5 15:15:09 2023 -0600 common cleanup commit fd251866c68f22d450dd428c93d7a3620bf1be27 Author: Henry Schimke <henry@azule.info> Date: Sun Feb 5 10:24:54 2023 -0600 cleanup reedsolomon commit 132e27ed1468f5c1ce998516ff5a00687217c3e6 Author: Henry Schimke <henry@azule.info> Date: Sun Feb 5 09:52:04 2023 -0600 make MathUtils more generic commit d8352b7fff4cb4f9ecc8e8a969710d26ef410e8b Author: Henry Schimke <henry@azule.info> Date: Sun Feb 5 09:29:33 2023 -0600 cleanup some string handling in ResultParser There may still be some edge cases where multi-byte characters break the parser
This commit is contained in:
Henry
@@ -33,11 +33,10 @@ impl BarcodeMatrix {
|
||||
* @param width the width of the matrix (Cols)
|
||||
*/
|
||||
pub fn new(height: usize, width: usize) -> Self {
|
||||
let mut matrix = Vec::new(); //new BarcodeRow[height];
|
||||
//Initializes the array to the correct width
|
||||
//Initializes the array to the correct width
|
||||
let mut matrix = Vec::with_capacity(height);
|
||||
|
||||
for _i in 0..height {
|
||||
// for (int i = 0, matrixLength = matrix.length; i < matrixLength; i++) {
|
||||
//matrix[i] = new BarcodeRow((width + 4) * 17 + 1);
|
||||
matrix.push(BarcodeRow::new((width + 4) * 17 + 1));
|
||||
}
|
||||
Self {
|
||||
@@ -46,9 +45,6 @@ impl BarcodeMatrix {
|
||||
height,
|
||||
width: width * 17,
|
||||
}
|
||||
// this.width = width * 17;
|
||||
// this.height = height;
|
||||
// this.currentRow = -1;
|
||||
}
|
||||
|
||||
pub fn set(&mut self, x: usize, y: usize, value: u8) {
|
||||
@@ -73,10 +69,8 @@ impl BarcodeMatrix {
|
||||
|
||||
pub fn getScaledMatrix(&self, xScale: usize, yScale: usize) -> Vec<Vec<u8>> {
|
||||
let mut matrixOut = vec![vec![0; self.width * xScale]; self.height * yScale];
|
||||
// byte[][] matrixOut = new byte[height * yScale][width * xScale];
|
||||
let yMax = self.height * yScale;
|
||||
for i in 0..yMax {
|
||||
// for (int i = 0; i < yMax; i++) {
|
||||
matrixOut[yMax - i - 1] = self.matrix[i / yScale].getScaledRow(xScale);
|
||||
}
|
||||
|
||||
|
||||
@@ -40,18 +40,8 @@ impl BarcodeRow {
|
||||
* @param x The location in the bar
|
||||
* @param value Black if true, white if false;
|
||||
*/
|
||||
pub fn set(&mut self, x: usize, value: u8) {
|
||||
self.row[x] = value
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a specific location in the bar
|
||||
*
|
||||
* @param x The location in the bar
|
||||
* @param black Black if true, white if false;
|
||||
*/
|
||||
fn set_bool(&mut self, x: usize, black: bool) {
|
||||
self.row[x] = u8::from(black); //if black { 1 } else { 0 }
|
||||
pub fn set<T: Into<u8>>(&mut self, x: usize, value: T) {
|
||||
self.row[x] = value.into()
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -61,7 +51,7 @@ impl BarcodeRow {
|
||||
pub fn addBar(&mut self, black: bool, width: usize) {
|
||||
for _ii in 0..width {
|
||||
// for (int ii = 0; ii < width; ii++) {
|
||||
self.set_bool(self.currentLocation, black);
|
||||
self.set(self.currentLocation, black);
|
||||
self.currentLocation += 1;
|
||||
}
|
||||
}
|
||||
@@ -75,8 +65,6 @@ impl BarcodeRow {
|
||||
pub fn getScaledRow(&self, scale: usize) -> Vec<u8> {
|
||||
let mut output = vec![0; self.row.len() * scale];
|
||||
for (i, row) in output.iter_mut().enumerate() {
|
||||
// for i in 0..output.len() {
|
||||
// for (int i = 0; i < output.length; i++) {
|
||||
*row = self.row[i / scale];
|
||||
}
|
||||
|
||||
|
||||
@@ -112,7 +112,6 @@ impl PDF417 {
|
||||
let mut last = (pattern & map) != 0; //Initialize to inverse of first bit
|
||||
let mut width = 0;
|
||||
for _i in 0..len {
|
||||
// for (int i = 0; i < len; i++) {
|
||||
let black = (pattern & map) != 0;
|
||||
if last == black {
|
||||
width += 1;
|
||||
@@ -134,33 +133,36 @@ impl PDF417 {
|
||||
r: u32,
|
||||
errorCorrectionLevel: u32,
|
||||
logic: &mut BarcodeMatrix,
|
||||
) {
|
||||
) -> Result<(), Exceptions> {
|
||||
let mut idx = 0;
|
||||
for y in 0..r {
|
||||
// for (int y = 0; y < r; y++) {
|
||||
let cluster = y as usize % 3;
|
||||
logic.startRow();
|
||||
Self::encodeChar(START_PATTERN, 17, logic.getCurrentRowMut());
|
||||
|
||||
let left;
|
||||
let right;
|
||||
if cluster == 0 {
|
||||
left = (30 * (y / 3)) + ((r - 1) / 3);
|
||||
right = (30 * (y / 3)) + (c - 1);
|
||||
} else if cluster == 1 {
|
||||
left = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
|
||||
right = (30 * (y / 3)) + ((r - 1) / 3);
|
||||
} else {
|
||||
left = (30 * (y / 3)) + (c - 1);
|
||||
right = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
|
||||
}
|
||||
let (left, right) = match cluster {
|
||||
0 => ((30 * (y / 3)) + ((r - 1) / 3), (30 * (y / 3)) + (c - 1)),
|
||||
|
||||
1 => (
|
||||
(30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3),
|
||||
(30 * (y / 3)) + ((r - 1) / 3),
|
||||
),
|
||||
|
||||
_ => (
|
||||
(30 * (y / 3)) + (c - 1),
|
||||
(30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3),
|
||||
),
|
||||
};
|
||||
|
||||
let mut pattern = CODEWORD_TABLE[cluster][left as usize];
|
||||
Self::encodeChar(pattern, 17, logic.getCurrentRowMut());
|
||||
|
||||
for _x in 0..c {
|
||||
// for (int x = 0; x < c; x++) {
|
||||
pattern = CODEWORD_TABLE[cluster][fullCodewords.chars().nth(idx).unwrap() as usize];
|
||||
pattern = CODEWORD_TABLE[cluster][fullCodewords
|
||||
.chars()
|
||||
.nth(idx)
|
||||
.ok_or(Exceptions::IndexOutOfBoundsException(None))?
|
||||
as usize];
|
||||
Self::encodeChar(pattern, 17, logic.getCurrentRowMut());
|
||||
idx += 1;
|
||||
}
|
||||
@@ -174,6 +176,7 @@ impl PDF417 {
|
||||
Self::encodeChar(STOP_PATTERN, 18, logic.getCurrentRowMut());
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -230,11 +233,11 @@ impl PDF417 {
|
||||
}
|
||||
let n = sourceCodeWords + pad + 1;
|
||||
let mut sb = String::with_capacity(n as usize);
|
||||
sb.push(char::from_u32(n).unwrap());
|
||||
sb.push(char::from_u32(n).ok_or(Exceptions::ParseException(None))?);
|
||||
sb.push_str(&highLevel);
|
||||
for _i in 0..pad {
|
||||
// for (int i = 0; i < pad; i++) {
|
||||
sb.push(char::from_u32(900).unwrap()); //PAD characters
|
||||
sb.push(char::from_u32(900).ok_or(Exceptions::ParseException(None))?);
|
||||
//PAD characters
|
||||
}
|
||||
let dataCodewords = sb;
|
||||
|
||||
@@ -252,7 +255,7 @@ impl PDF417 {
|
||||
rows,
|
||||
errorCorrectionLevel,
|
||||
&mut barcode_matrix,
|
||||
);
|
||||
)?;
|
||||
self.barcodeMatrix = Some(barcode_matrix);
|
||||
Ok(())
|
||||
}
|
||||
@@ -286,8 +289,8 @@ impl PDF417 {
|
||||
continue;
|
||||
}
|
||||
|
||||
let newRatio: f32 =
|
||||
((17 * cols + 69) as f32 * DEFAULT_MODULE_WIDTH) / (rows as f32 * HEIGHT);
|
||||
let newRatio: f64 =
|
||||
((17 * cols + 69) as f64 * DEFAULT_MODULE_WIDTH) / (rows as f64 * HEIGHT);
|
||||
|
||||
// ignore if previous ratio is closer to preferred ratio
|
||||
if dimension.is_some()
|
||||
@@ -312,13 +315,9 @@ impl PDF417 {
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(dim) = dimension {
|
||||
Ok(dim)
|
||||
} else {
|
||||
Err(Exceptions::WriterException(Some(
|
||||
"Unable to fit message in columns".to_owned(),
|
||||
)))
|
||||
}
|
||||
dimension.ok_or(Exceptions::WriterException(Some(
|
||||
"Unable to fit message in columns".to_owned(),
|
||||
)))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -658,6 +657,6 @@ const CODEWORD_TABLE: [[u32; 929]; 3] = [
|
||||
],
|
||||
];
|
||||
|
||||
const PREFERRED_RATIO: f32 = 3.0;
|
||||
const DEFAULT_MODULE_WIDTH: f32 = 0.357; //1px in mm
|
||||
const HEIGHT: f32 = 2.0; //mm
|
||||
const PREFERRED_RATIO: f64 = 3.0;
|
||||
const DEFAULT_MODULE_WIDTH: f64 = 0.357; //1px in mm
|
||||
const HEIGHT: f64 = 2.0; //mm
|
||||
|
||||
@@ -122,7 +122,6 @@ pub fn getErrorCorrectionCodewordCount(errorCorrectionLevel: u32) -> Result<u32,
|
||||
return Err(Exceptions::IllegalArgumentException(Some(
|
||||
"Error correction level must be between 0 and 8!".to_owned(),
|
||||
)));
|
||||
// throw new IllegalArgumentException("Error correction level must be between 0 and 8!");
|
||||
}
|
||||
Ok(1 << (errorCorrectionLevel + 1))
|
||||
}
|
||||
@@ -169,28 +168,32 @@ pub fn generateErrorCorrection(
|
||||
let mut e = vec![0 as char; k as usize]; //new char[k];
|
||||
let sld = dataCodewords.chars().count();
|
||||
for i in 0..sld {
|
||||
// for (int i = 0; i < sld; i++) {
|
||||
let t1 = (dataCodewords.chars().nth(i).unwrap() as u32 + e[e.len() - 1] as u32) % 929;
|
||||
let t1 = (dataCodewords
|
||||
.chars()
|
||||
.nth(i)
|
||||
.ok_or(Exceptions::IndexOutOfBoundsException(None))? as u32
|
||||
+ e[e.len() - 1] as u32)
|
||||
% 929;
|
||||
let mut t2;
|
||||
let mut t3;
|
||||
let mut j = k as usize - 1;
|
||||
while j >= 1 {
|
||||
// for (int j = k - 1; j >= 1; j--) {
|
||||
t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel as usize][j]) % 929;
|
||||
t3 = 929 - t2;
|
||||
e[j] = char::from_u32((e[j - 1] as u32 + t3) % 929).unwrap();
|
||||
e[j] = char::from_u32((e[j - 1] as u32 + t3) % 929)
|
||||
.ok_or(Exceptions::ParseException(None))?;
|
||||
j -= 1;
|
||||
}
|
||||
t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel as usize][0]) % 929;
|
||||
t3 = 929 - t2;
|
||||
e[0] = char::from_u32(t3 % 929).unwrap();
|
||||
e[0] = char::from_u32(t3 % 929).ok_or(Exceptions::ParseException(None))?;
|
||||
}
|
||||
let mut sb = String::with_capacity(k as usize); // StringBuilder(k);
|
||||
let mut sb = String::with_capacity(k as usize);
|
||||
let mut j = k as isize - 1;
|
||||
while j >= 0 {
|
||||
// for (int j = k - 1; j >= 0; j--) {
|
||||
if e[j as usize] as u32 != 0 {
|
||||
e[j as usize] = char::from_u32(929 - e[j as usize] as u32).unwrap();
|
||||
e[j as usize] = char::from_u32(929 - e[j as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?;
|
||||
}
|
||||
sb.push(e[j as usize]);
|
||||
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
* This file has been modified from its original form in Barcode4J.
|
||||
*/
|
||||
|
||||
use std::{any::TypeId, fmt::Display};
|
||||
use std::{any::TypeId, fmt::Display, str::FromStr};
|
||||
|
||||
use encoding::EncodingRef;
|
||||
|
||||
@@ -125,10 +125,6 @@ const TEXT_PUNCTUATION_RAW: [u8; 30] = [
|
||||
40, 41, 63, 123, 125, 39, 0,
|
||||
];
|
||||
|
||||
// const MIXED : [u8;128]= [0;128];//new byte[128];
|
||||
|
||||
// const PUNCTUATION : [u8;128]= [0;128];//new byte[128];
|
||||
|
||||
const DEFAULT_ENCODING: EncodingRef = encoding::all::ISO_8859_1; //StandardCharsets.ISO_8859_1;
|
||||
|
||||
const MIXED: [i8; 128] = {
|
||||
@@ -158,23 +154,6 @@ const PUNCTUATION: [i8; 128] = {
|
||||
|
||||
punct
|
||||
};
|
||||
// static {
|
||||
// //Construct inverse lookups
|
||||
// Arrays.fill(MIXED, (byte) -1);
|
||||
// for (int i = 0; i < TEXT_MIXED_RAW.length; i++) {
|
||||
// byte b = TEXT_MIXED_RAW[i];
|
||||
// if (b > 0) {
|
||||
// MIXED[b] = (byte) i;
|
||||
// }
|
||||
// }
|
||||
// Arrays.fill(PUNCTUATION, (byte) -1);
|
||||
// for (int i = 0; i < TEXT_PUNCTUATION_RAW.length; i++) {
|
||||
// byte b = TEXT_PUNCTUATION_RAW[i];
|
||||
// if (b > 0) {
|
||||
// PUNCTUATION[b] = (byte) i;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
/**
|
||||
* Performs high-level encoding of a PDF417 message using the algorithm described in annex P
|
||||
@@ -206,15 +185,14 @@ pub fn encodeHighLevel(
|
||||
}
|
||||
|
||||
if encoding.is_none() && !autoECI {
|
||||
for i in 0..msg.chars().count() {
|
||||
// for (int i = 0; i < msg.length(); i++) {
|
||||
if msg.chars().nth(i).unwrap() as u32 > 255 {
|
||||
return Err(Exceptions::WriterException(Some(format!("Non-encodable character detected: {} (Unicode: {}). Consider specifying EncodeHintType.PDF417_AUTO_ECI and/or EncodeTypeHint.CHARACTER_SET.",msg.chars().nth(i).unwrap() as u32,msg.chars().nth(i).unwrap()))));
|
||||
for ch in msg.chars() {
|
||||
if ch as u32 > 255 {
|
||||
return Err(Exceptions::WriterException(Some(format!("Non-encodable character detected: {} (Unicode: {}). Consider specifying EncodeHintType.PDF417_AUTO_ECI and/or EncodeTypeHint.CHARACTER_SET.",ch as u32,ch))));
|
||||
}
|
||||
}
|
||||
}
|
||||
//the codewords 0..928 are encoded as Unicode characters
|
||||
let mut sb = String::with_capacity(msg.len()); //new StringBuilder(msg.length());
|
||||
let mut sb = String::with_capacity(msg.len());
|
||||
|
||||
let input: Box<dyn ECIInput>;
|
||||
if autoECI {
|
||||
@@ -223,9 +201,15 @@ pub fn encodeHighLevel(
|
||||
input = Box::new(NoECIInput::new(msg.to_owned()));
|
||||
if encoding.is_none() {
|
||||
encoding = Some(DEFAULT_ENCODING);
|
||||
} else if DEFAULT_ENCODING.name() != encoding.as_ref().unwrap().name() {
|
||||
if let Some(eci) = CharacterSetECI::getCharacterSetECI(encoding.unwrap()) {
|
||||
// if (eci != null) {
|
||||
} else if DEFAULT_ENCODING.name()
|
||||
!= encoding
|
||||
.as_ref()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?
|
||||
.name()
|
||||
{
|
||||
if let Some(eci) = CharacterSetECI::getCharacterSetECI(
|
||||
encoding.ok_or(Exceptions::IllegalStateException(None))?,
|
||||
) {
|
||||
encodingECI(CharacterSetECI::getValue(&eci) as i32, &mut sb)?;
|
||||
}
|
||||
}
|
||||
@@ -240,27 +224,26 @@ pub fn encodeHighLevel(
|
||||
Compaction::TEXT => {
|
||||
encodeText(&input, p, len as u32, &mut sb, textSubMode)?;
|
||||
}
|
||||
Compaction::BYTE if autoECI => {
|
||||
encodeMultiECIBinary(&input, 0, input.length() as u32, TEXT_COMPACTION, &mut sb)?
|
||||
}
|
||||
Compaction::BYTE => {
|
||||
if autoECI {
|
||||
encodeMultiECIBinary(&input, 0, input.length() as u32, TEXT_COMPACTION, &mut sb)?;
|
||||
} else {
|
||||
let msgBytes = encoding
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.encode(&input.to_string(), encoding::EncoderTrap::Strict)
|
||||
.unwrap_or_default(); //input.to_string().getBytes(encoding);
|
||||
encodeBinary(
|
||||
&msgBytes,
|
||||
p,
|
||||
msgBytes.len() as u32,
|
||||
BYTE_COMPACTION,
|
||||
&mut sb,
|
||||
);
|
||||
}
|
||||
let msgBytes = encoding
|
||||
.as_ref()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?
|
||||
.encode(&input.to_string(), encoding::EncoderTrap::Strict)
|
||||
.unwrap_or_default(); //input.to_string().getBytes(encoding);
|
||||
encodeBinary(
|
||||
&msgBytes,
|
||||
p,
|
||||
msgBytes.len() as u32,
|
||||
BYTE_COMPACTION,
|
||||
&mut sb,
|
||||
)?;
|
||||
}
|
||||
Compaction::NUMERIC => {
|
||||
sb.push(char::from_u32(LATCH_TO_NUMERIC).unwrap());
|
||||
encodeNumeric(&input, p, len as u32, &mut sb);
|
||||
sb.push(char::from_u32(LATCH_TO_NUMERIC).ok_or(Exceptions::ParseException(None))?);
|
||||
encodeNumeric(&input, p, len as u32, &mut sb)?;
|
||||
}
|
||||
_ => {
|
||||
let mut encodingMode = TEXT_COMPACTION; //Default mode, see 4.4.2.1
|
||||
@@ -272,18 +255,23 @@ pub fn encodeHighLevel(
|
||||
if p >= len as u32 {
|
||||
break;
|
||||
}
|
||||
let n = determineConsecutiveDigitCount(&input, p);
|
||||
let n = determineConsecutiveDigitCount(&input, p)?;
|
||||
if n >= 13 {
|
||||
sb.push(char::from_u32(LATCH_TO_NUMERIC).unwrap());
|
||||
sb.push(
|
||||
char::from_u32(LATCH_TO_NUMERIC).ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
encodingMode = NUMERIC_COMPACTION;
|
||||
textSubMode = SUBMODE_ALPHA; //Reset after latch
|
||||
encodeNumeric(&input, p, n, &mut sb);
|
||||
encodeNumeric(&input, p, n, &mut sb)?;
|
||||
p += n;
|
||||
} else {
|
||||
let t = determineConsecutiveTextCount(&input, p);
|
||||
let t = determineConsecutiveTextCount(&input, p)?;
|
||||
if t >= 5 || n == len as u32 {
|
||||
if encodingMode != TEXT_COMPACTION {
|
||||
sb.push(char::from_u32(LATCH_TO_TEXT).unwrap());
|
||||
sb.push(
|
||||
char::from_u32(LATCH_TO_TEXT)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
encodingMode = TEXT_COMPACTION;
|
||||
textSubMode = SUBMODE_ALPHA; //start with submode alpha after latch
|
||||
}
|
||||
@@ -307,32 +295,30 @@ pub fn encodeHighLevel(
|
||||
.collect::<String>();
|
||||
if let Ok(enc_str) = encoding
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?
|
||||
.encode(&str, encoding::EncoderTrap::Strict)
|
||||
{
|
||||
Some(enc_str)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}; //.getBytes(encoding))};
|
||||
// if let Some(byts) = bytes {
|
||||
let bytes_ok = bytes.is_some(); //if let Some(_) = bytes { true } else { false };
|
||||
if (bytes_ok && b == 1)
|
||||
/*((bytes_ok && b == 1)
|
||||
|| (!bytes_ok && bytes.as_ref().unwrap().len() == 1))*/
|
||||
&& (encodingMode == TEXT_COMPACTION)
|
||||
{
|
||||
};
|
||||
|
||||
let bytes_ok = bytes.is_some();
|
||||
if (bytes_ok && b == 1) && (encodingMode == TEXT_COMPACTION) {
|
||||
//Switch for one byte (instead of latch)
|
||||
if autoECI {
|
||||
encodeMultiECIBinary(&input, p, 1, TEXT_COMPACTION, &mut sb)?;
|
||||
} else {
|
||||
encodeBinary(
|
||||
bytes.as_ref().unwrap(),
|
||||
bytes
|
||||
.as_ref()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?,
|
||||
0,
|
||||
1,
|
||||
TEXT_COMPACTION,
|
||||
&mut sb,
|
||||
);
|
||||
)?;
|
||||
}
|
||||
} else {
|
||||
//Mode latch performed by encodeBinary()
|
||||
@@ -340,12 +326,17 @@ pub fn encodeHighLevel(
|
||||
encodeMultiECIBinary(&input, p, p + b, encodingMode, &mut sb)?;
|
||||
} else {
|
||||
encodeBinary(
|
||||
bytes.as_ref().unwrap(),
|
||||
bytes
|
||||
.as_ref()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?,
|
||||
0,
|
||||
bytes.as_ref().unwrap().len() as u32,
|
||||
bytes
|
||||
.as_ref()
|
||||
.ok_or(Exceptions::IllegalStateException(None))?
|
||||
.len() as u32,
|
||||
encodingMode,
|
||||
&mut sb,
|
||||
);
|
||||
)?;
|
||||
}
|
||||
encodingMode = BYTE_COMPACTION;
|
||||
textSubMode = SUBMODE_ALPHA; //Reset after latch
|
||||
@@ -393,7 +384,10 @@ fn encodeText<T: ECIInput + ?Sized>(
|
||||
if ch == ' ' {
|
||||
tmp.push(26 as char); //space
|
||||
} else {
|
||||
tmp.push(char::from_u32(ch as u32 - 65).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(ch as u32 - 65)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
}
|
||||
} else if isAlphaLower(ch) {
|
||||
submode = SUBMODE_LOWER;
|
||||
@@ -405,37 +399,49 @@ fn encodeText<T: ECIInput + ?Sized>(
|
||||
continue;
|
||||
} else {
|
||||
tmp.push(29 as char); //ps
|
||||
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
|
||||
//break;
|
||||
tmp.push(
|
||||
char::from_u32(PUNCTUATION[ch as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
}
|
||||
}
|
||||
// break;
|
||||
|
||||
SUBMODE_LOWER => {
|
||||
if isAlphaLower(ch) {
|
||||
if ch == ' ' {
|
||||
tmp.push(26 as char); //space
|
||||
} else {
|
||||
tmp.push(char::from_u32(ch as u32 - 97).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(ch as u32 - 97)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
}
|
||||
} else if isAlphaUpper(ch) {
|
||||
tmp.push(27 as char); //as
|
||||
tmp.push(char::from_u32(ch as u32 - 65).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(ch as u32 - 65)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
//space cannot happen here, it is also in "Lower"
|
||||
//break;
|
||||
} else if isMixed(ch) {
|
||||
submode = SUBMODE_MIXED;
|
||||
tmp.push(28 as char); //ml
|
||||
continue;
|
||||
} else {
|
||||
tmp.push(29 as char); //ps
|
||||
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
|
||||
//break;
|
||||
tmp.push(
|
||||
char::from_u32(PUNCTUATION[ch as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
}
|
||||
}
|
||||
// break;
|
||||
SUBMODE_MIXED => {
|
||||
if isMixed(ch) {
|
||||
tmp.push(char::from_u32(MIXED[ch as usize] as u32).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(MIXED[ch as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
} else if isAlphaUpper(ch) {
|
||||
submode = SUBMODE_ALPHA;
|
||||
tmp.push(28 as char); //al
|
||||
@@ -454,14 +460,20 @@ fn encodeText<T: ECIInput + ?Sized>(
|
||||
continue;
|
||||
}
|
||||
tmp.push(29 as char); //ps
|
||||
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(PUNCTUATION[ch as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
}
|
||||
}
|
||||
_ =>
|
||||
//SUBMODE_PUNCTUATION
|
||||
{
|
||||
if isPunctuation(ch) {
|
||||
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
|
||||
tmp.push(
|
||||
char::from_u32(PUNCTUATION[ch as usize] as u32)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
} else {
|
||||
submode = SUBMODE_ALPHA;
|
||||
tmp.push(29 as char); //al
|
||||
@@ -478,17 +490,28 @@ fn encodeText<T: ECIInput + ?Sized>(
|
||||
let mut h = 0 as char;
|
||||
let len = tmp.chars().count();
|
||||
for i in 0..len {
|
||||
// for (int i = 0; i < len; i++) {
|
||||
let odd = (i % 2) != 0;
|
||||
if odd {
|
||||
h = char::from_u32((h as u32 * 30) + tmp.chars().nth(i).unwrap() as u32).unwrap();
|
||||
h = char::from_u32(
|
||||
(h as u32 * 30)
|
||||
+ tmp
|
||||
.chars()
|
||||
.nth(i)
|
||||
.ok_or(Exceptions::IndexOutOfBoundsException(None))?
|
||||
as u32,
|
||||
)
|
||||
.ok_or(Exceptions::ParseException(None))?;
|
||||
sb.push(h);
|
||||
} else {
|
||||
h = tmp.chars().nth(i).unwrap();
|
||||
h = tmp
|
||||
.chars()
|
||||
.nth(i)
|
||||
.ok_or(Exceptions::IndexOutOfBoundsException(None))?;
|
||||
}
|
||||
}
|
||||
if (len % 2) != 0 {
|
||||
sb.push(char::from_u32((h as u32 * 30) + 29).unwrap()); //ps
|
||||
sb.push(char::from_u32((h as u32 * 30) + 29).ok_or(Exceptions::ParseException(None))?);
|
||||
//ps
|
||||
}
|
||||
Ok(submode)
|
||||
}
|
||||
@@ -530,7 +553,7 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
|
||||
} else {
|
||||
//encode the segment
|
||||
encodeBinary(
|
||||
&subBytes(input, localStart, localEnd),
|
||||
&subBytes(input, localStart, localEnd)?,
|
||||
0,
|
||||
localCount as u32,
|
||||
if localStart == startpos {
|
||||
@@ -539,7 +562,7 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
|
||||
BYTE_COMPACTION
|
||||
},
|
||||
sb,
|
||||
);
|
||||
)?;
|
||||
localStart = localEnd;
|
||||
}
|
||||
}
|
||||
@@ -547,14 +570,17 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn subBytes<T: ECIInput + ?Sized>(input: &Box<T>, start: u32, end: u32) -> Vec<u8> {
|
||||
pub fn subBytes<T: ECIInput + ?Sized>(
|
||||
input: &Box<T>,
|
||||
start: u32,
|
||||
end: u32,
|
||||
) -> Result<Vec<u8>, Exceptions> {
|
||||
let count = (end - start) as usize;
|
||||
let mut result = vec![0_u8; count];
|
||||
for i in start as usize..end as usize {
|
||||
// for (int i = start; i < end; i++) {
|
||||
result[i - start as usize] = input.charAt(i).unwrap() as u8;
|
||||
result[i - start as usize] = input.charAt(i)? as u8;
|
||||
}
|
||||
result
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -568,13 +594,19 @@ pub fn subBytes<T: ECIInput + ?Sized>(input: &Box<T>, start: u32, end: u32) -> V
|
||||
* @param startmode the mode from which this method starts
|
||||
* @param sb receives the encoded codewords
|
||||
*/
|
||||
fn encodeBinary(bytes: &[u8], startpos: u32, count: u32, startmode: u32, sb: &mut String) {
|
||||
fn encodeBinary(
|
||||
bytes: &[u8],
|
||||
startpos: u32,
|
||||
count: u32,
|
||||
startmode: u32,
|
||||
sb: &mut String,
|
||||
) -> Result<(), Exceptions> {
|
||||
if count == 1 && startmode == TEXT_COMPACTION {
|
||||
sb.push(char::from_u32(SHIFT_TO_BYTE).unwrap());
|
||||
sb.push(char::from_u32(SHIFT_TO_BYTE).ok_or(Exceptions::ParseException(None))?);
|
||||
} else if (count % 6) == 0 {
|
||||
sb.push(char::from_u32(LATCH_TO_BYTE).unwrap());
|
||||
sb.push(char::from_u32(LATCH_TO_BYTE).ok_or(Exceptions::ParseException(None))?);
|
||||
} else {
|
||||
sb.push(char::from_u32(LATCH_TO_BYTE_PADDED).unwrap());
|
||||
sb.push(char::from_u32(LATCH_TO_BYTE_PADDED).ok_or(Exceptions::ParseException(None))?);
|
||||
}
|
||||
|
||||
let mut idx = startpos;
|
||||
@@ -584,37 +616,39 @@ fn encodeBinary(bytes: &[u8], startpos: u32, count: u32, startmode: u32, sb: &mu
|
||||
while (startpos + count - idx) >= 6 {
|
||||
let mut t: i64 = 0;
|
||||
for i in 0..6 {
|
||||
// for (int i = 0; i < 6; i++) {
|
||||
t <<= 8;
|
||||
t += bytes[idx as usize + i as usize] as i64;
|
||||
}
|
||||
for ch in &mut chars {
|
||||
// for i in 0..5 {
|
||||
// for (int i = 0; i < 5; i++) {
|
||||
*ch = char::from_u32((t % 900) as u32).unwrap();
|
||||
*ch = char::from_u32((t % 900) as u32).ok_or(Exceptions::ParseException(None))?;
|
||||
t /= 900;
|
||||
}
|
||||
for ch in chars.into_iter().rev() {
|
||||
// for i in (0..chars.len()).rev() {
|
||||
// for (int i = chars.length - 1; i >= 0; i--) {
|
||||
sb.push(ch);
|
||||
}
|
||||
sb.push_str(&chars.into_iter().rev().collect::<String>());
|
||||
idx += 6;
|
||||
}
|
||||
}
|
||||
//Encode rest (remaining n<5 bytes if any)
|
||||
for i in idx..(startpos + count) {
|
||||
// for (int i = idx; i < startpos + count; i++) {
|
||||
let ch = bytes[i as usize];
|
||||
sb.push(ch as char);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn encodeNumeric<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32, count: u32, sb: &mut String) {
|
||||
fn encodeNumeric<T: ECIInput + ?Sized>(
|
||||
input: &Box<T>,
|
||||
startpos: u32,
|
||||
count: u32,
|
||||
sb: &mut String,
|
||||
) -> Result<(), Exceptions> {
|
||||
let mut idx = 0;
|
||||
let mut tmp = String::with_capacity(count as usize / 3 + 1);
|
||||
let num900: u128 = 900;
|
||||
let num0: u128 = 0;
|
||||
let NUM900: num::BigUint = num::BigUint::from(900_u16); //.ok_or(Exceptions::ParseException(None))?;
|
||||
let NUM0: num::BigUint = num::BigUint::from(0_u8); //.ok_or(Exceptions::ParseException(None))?;
|
||||
// let num900: u128 = 900;
|
||||
// const NUM0: u128 = 0;
|
||||
|
||||
while idx < count {
|
||||
tmp.clear();
|
||||
let len = 44.min(count as isize - idx as isize);
|
||||
@@ -624,31 +658,35 @@ fn encodeNumeric<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32, count: u32
|
||||
.subSequence(
|
||||
(startpos + idx) as usize,
|
||||
(startpos + idx + len as u32) as usize
|
||||
)
|
||||
.unwrap()
|
||||
)?
|
||||
.iter()
|
||||
.collect::<String>()
|
||||
);
|
||||
let mut bigint: u128 = part.parse().unwrap();
|
||||
// let mut bigint: u128 = part.parse().map_err(|_| Exceptions::ParseException(None))?;
|
||||
let mut bigint = num::BigUint::from_str(&part)
|
||||
.map_err(|e| Exceptions::ParseException(Some(format!("issue parsing {part}: {e}"))))?; // part.parse().map_err(|_| Exceptions::ParseException(None))?;
|
||||
loop {
|
||||
tmp.push(char::from_u32((bigint % num900) as u32).unwrap());
|
||||
bigint /= num900;
|
||||
tmp.push(
|
||||
char::from_u32((&bigint % &NUM900).try_into().map_err(|e| {
|
||||
Exceptions::ParseException(Some(format!(
|
||||
"erorr converting {bigint} to u32: {e}"
|
||||
)))
|
||||
})?)
|
||||
.ok_or(Exceptions::ParseException(None))?,
|
||||
);
|
||||
bigint /= &NUM900;
|
||||
|
||||
if bigint == num0 {
|
||||
if bigint == NUM0 {
|
||||
break;
|
||||
}
|
||||
} //while (!bigint.equals(num0));
|
||||
}
|
||||
|
||||
//Reverse temporary string
|
||||
let mut i = tmp.chars().count() as isize - 1;
|
||||
while i >= 0 {
|
||||
// for (int i = tmp.length() - 1; i >= 0; i--) {
|
||||
sb.push(tmp.chars().nth(i as usize).unwrap());
|
||||
|
||||
i -= 1;
|
||||
}
|
||||
sb.push_str(&tmp.chars().rev().collect::<String>());
|
||||
idx += len as u32;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn isDigit(ch: char) -> bool {
|
||||
@@ -682,19 +720,21 @@ fn isText(ch: char) -> bool {
|
||||
* @param startpos the start position within the input
|
||||
* @return the requested character count
|
||||
*/
|
||||
fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32) -> u32 {
|
||||
fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(
|
||||
input: &Box<T>,
|
||||
startpos: u32,
|
||||
) -> Result<u32, Exceptions> {
|
||||
let mut count = 0;
|
||||
let len = input.length();
|
||||
let mut idx = startpos as usize;
|
||||
if idx < len {
|
||||
while idx < len && !input.isECI(idx as u32).unwrap() && isDigit(input.charAt(idx).unwrap())
|
||||
{
|
||||
while idx < len && !input.isECI(idx as u32)? && isDigit(input.charAt(idx)?) {
|
||||
count += 1;
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
|
||||
count
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -704,21 +744,24 @@ fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos
|
||||
* @param startpos the start position within the input
|
||||
* @return the requested character count
|
||||
*/
|
||||
fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32) -> u32 {
|
||||
fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(
|
||||
input: &Box<T>,
|
||||
startpos: u32,
|
||||
) -> Result<u32, Exceptions> {
|
||||
let len = input.length();
|
||||
let mut idx = startpos as usize;
|
||||
while idx < len {
|
||||
let mut numericCount = 0;
|
||||
while numericCount < 13
|
||||
&& idx < len
|
||||
&& !input.isECI(idx as u32).unwrap()
|
||||
&& isDigit(input.charAt(idx).unwrap())
|
||||
&& !input.isECI(idx as u32)?
|
||||
&& isDigit(input.charAt(idx)?)
|
||||
{
|
||||
numericCount += 1;
|
||||
idx += 1;
|
||||
}
|
||||
if numericCount >= 13 {
|
||||
return (idx - startpos as usize - numericCount) as u32;
|
||||
return Ok((idx - startpos as usize - numericCount) as u32);
|
||||
}
|
||||
if numericCount > 0 {
|
||||
//Heuristic: All text-encodable chars or digits are binary encodable
|
||||
@@ -726,12 +769,12 @@ fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos:
|
||||
}
|
||||
|
||||
//Check if character is encodable
|
||||
if input.isECI(idx as u32).unwrap() || !isText(input.charAt(idx).unwrap()) {
|
||||
if input.isECI(idx as u32)? || !isText(input.charAt(idx)?) {
|
||||
break;
|
||||
}
|
||||
idx += 1;
|
||||
}
|
||||
(idx - startpos as usize) as u32
|
||||
Ok((idx - startpos as usize) as u32)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -747,17 +790,13 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
|
||||
startpos: u32,
|
||||
encoding: Option<EncodingRef>,
|
||||
) -> Result<u32, Exceptions> {
|
||||
// CharsetEncoder encoder = encoding == null ? null : encoding.newEncoder();
|
||||
let len = input.length();
|
||||
let mut idx = startpos as usize;
|
||||
while idx < len {
|
||||
let mut numericCount = 0;
|
||||
|
||||
let mut i = idx;
|
||||
while numericCount < 13
|
||||
&& !input.isECI(i as u32).unwrap()
|
||||
&& isDigit(input.charAt(i).unwrap())
|
||||
{
|
||||
while numericCount < 13 && !input.isECI(i as u32)? && isDigit(input.charAt(i)?) {
|
||||
numericCount += 1;
|
||||
//textCount++;
|
||||
i = idx + numericCount;
|
||||
@@ -777,11 +816,13 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
|
||||
)
|
||||
.is_ok();
|
||||
|
||||
// if encoder != null && !encoder.canEncode(input.charAt(idx)) {
|
||||
if !can_encode {
|
||||
assert!(TypeId::of::<T>() == TypeId::of::<NoECIInput>());
|
||||
// assert!(input instanceof NoECIInput);
|
||||
let ch = input.charAt(idx).unwrap();
|
||||
if TypeId::of::<T>() != TypeId::of::<NoECIInput>() {
|
||||
return Err(Exceptions::IllegalStateException(Some(
|
||||
"expected NoECIInput type".to_owned(),
|
||||
)));
|
||||
}
|
||||
let ch = input.charAt(idx)?;
|
||||
return Err(Exceptions::WriterException(Some(format!(
|
||||
"Non-encodable character detected: {} (Unicode: {})",
|
||||
ch, ch as u32
|
||||
@@ -795,15 +836,15 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
|
||||
|
||||
fn encodingECI(eci: i32, sb: &mut String) -> Result<(), Exceptions> {
|
||||
if (0..900).contains(&eci) {
|
||||
sb.push(char::from_u32(ECI_CHARSET).unwrap());
|
||||
sb.push(char::from_u32(eci as u32).unwrap());
|
||||
sb.push(char::from_u32(ECI_CHARSET).ok_or(Exceptions::ParseException(None))?);
|
||||
sb.push(char::from_u32(eci as u32).ok_or(Exceptions::ParseException(None))?);
|
||||
} else if eci < 810900 {
|
||||
sb.push(char::from_u32(ECI_GENERAL_PURPOSE).unwrap());
|
||||
sb.push(char::from_u32((eci / 900 - 1) as u32).unwrap());
|
||||
sb.push(char::from_u32((eci % 900) as u32).unwrap());
|
||||
sb.push(char::from_u32(ECI_GENERAL_PURPOSE).ok_or(Exceptions::ParseException(None))?);
|
||||
sb.push(char::from_u32((eci / 900 - 1) as u32).ok_or(Exceptions::ParseException(None))?);
|
||||
sb.push(char::from_u32((eci % 900) as u32).ok_or(Exceptions::ParseException(None))?);
|
||||
} else if eci < 811800 {
|
||||
sb.push(char::from_u32(ECI_USER_DEFINED).unwrap());
|
||||
sb.push(char::from_u32((810900 - eci) as u32).unwrap());
|
||||
sb.push(char::from_u32(ECI_USER_DEFINED).ok_or(Exceptions::ParseException(None))?);
|
||||
sb.push(char::from_u32((810900 - eci) as u32).ok_or(Exceptions::ParseException(None))?);
|
||||
} else {
|
||||
return Err(Exceptions::WriterException(Some(format!(
|
||||
"ECI number not in valid range from 0..811799, but was {eci}"
|
||||
@@ -819,11 +860,10 @@ impl ECIInput for NoECIInput {
|
||||
}
|
||||
|
||||
fn charAt(&self, index: usize) -> Result<char, Exceptions> {
|
||||
if let Some(ch) = self.0.chars().nth(index) {
|
||||
Ok(ch)
|
||||
} else {
|
||||
Err(Exceptions::IndexOutOfBoundsException(None))
|
||||
}
|
||||
self.0
|
||||
.chars()
|
||||
.nth(index)
|
||||
.ok_or(Exceptions::IndexOutOfBoundsException(None))
|
||||
}
|
||||
|
||||
fn subSequence(&self, start: usize, end: usize) -> Result<Vec<char>, Exceptions> {
|
||||
@@ -839,8 +879,8 @@ impl ECIInput for NoECIInput {
|
||||
Ok(-1)
|
||||
}
|
||||
|
||||
fn haveNCharacters(&self, index: usize, n: usize) -> bool {
|
||||
index + n <= self.0.len()
|
||||
fn haveNCharacters(&self, index: usize, n: usize) -> Result<bool, Exceptions> {
|
||||
Ok(index + n <= self.0.len())
|
||||
}
|
||||
}
|
||||
impl NoECIInput {
|
||||
|
||||
Reference in New Issue
Block a user