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

Use thiserror for error handling with less boilerplate

Browse Source
This commit is contained in:
Steve Cook
2023-02-20 09:41:28 -05:00
parent 01e4f4a126
commit f8b29f37db
135 changed files with 868 additions and 905 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/oned/coda_bar_reader.rs
View File

@@ -65,13 +65,13 @@ impl OneDReader for CodaBarReader {
loop {
let charOffset = self.toNarrowWidePattern(nextStart);
if charOffset == -1 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// Hack: We store the position in the alphabet table into a
// StringBuilder, so that we can access the decoded patterns in
// validatePattern. We'll translate to the actual characters later.
self.decodeRowRXingResult
.push(char::from_u32(charOffset as u32).ok_or(Exceptions::parse)?);
.push(char::from_u32(charOffset as u32).ok_or(Exceptions::PARSE)?);
nextStart += 8;
// Stop as soon as we see the end character.
if self.decodeRowRXingResult.chars().count() > 1
@@ -99,7 +99,7 @@ impl OneDReader for CodaBarReader {
// otherwise this is probably a false positive. The exception is if we are
// at the end of the row. (I.e. the barcode barely fits.)
if nextStart < self.counterLength && trailingWhitespace < lastPatternSize / 2 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
self.validatePattern(startOffset)?;
@@ -113,7 +113,7 @@ impl OneDReader for CodaBarReader {
.decodeRowRXingResult
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)? as usize]
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as usize]
.to_string(),
);
}
@@ -122,23 +122,23 @@ impl OneDReader for CodaBarReader {
.decodeRowRXingResult
.chars()
.next()
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
if !Self::arrayContains(&Self::STARTEND_ENCODING, startchar) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let endchar = self
.decodeRowRXingResult
.chars()
.nth(self.decodeRowRXingResult.chars().count() - 1)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
if !Self::arrayContains(&Self::STARTEND_ENCODING, endchar) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// remove stop/start characters character and check if a long enough string is contained
if (self.decodeRowRXingResult.chars().count()) <= Self::MIN_CHARACTER_LENGTH as usize {
// Almost surely a false positive ( start + stop + at least 1 character)
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
if !matches!(
@@ -242,7 +242,7 @@ impl CodaBarReader {
.decodeRowRXingResult
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
as usize];
for j in (0_usize..=6).rev() {
// Even j = bars, while odd j = spaces. Categories 2 and 3 are for
@@ -281,7 +281,7 @@ impl CodaBarReader {
.decodeRowRXingResult
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
as usize];
for j in (0usize..=6).rev() {
// Even j = bars, while odd j = spaces. Categories 2 and 3 are for
@@ -289,7 +289,7 @@ impl CodaBarReader {
let category = (j & 1) + ((pattern as usize) & 1) * 2;
let size = self.counters[(pos + j)];
if (size as f32) < mins[category] || (size as f32) > maxes[category] {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
pattern >>= 1;
}
@@ -310,7 +310,7 @@ impl CodaBarReader {
let mut i = row.getNextUnset(0);
let end = row.getSize();
if i >= end {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let mut isWhite = true;
let mut count = 0;
@@ -362,7 +362,7 @@ impl CodaBarReader {
i += 2;
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
pub fn arrayContains(array: &[char], key: char) -> bool {

14
src/oned/coda_bar_writer.rs
View File

@@ -44,12 +44,12 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
let firstChar = contents
.chars()
.next()
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_ascii_uppercase();
let lastChar = contents
.chars()
.nth(contents.chars().count() - 1)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_ascii_uppercase();
let startsNormal = CodaBarReader::arrayContains(&START_END_CHARS, firstChar);
let endsNormal = CodaBarReader::arrayContains(&START_END_CHARS, lastChar);
@@ -57,7 +57,7 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
let endsAlt = CodaBarReader::arrayContains(&ALT_START_END_CHARS, lastChar);
if startsNormal {
if !endsNormal {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Invalid start/end guards: {contents}"
)));
}
@@ -65,7 +65,7 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
contents.to_owned()
} else if startsAlt {
if !endsAlt {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Invalid start/end guards: {contents}"
)));
}
@@ -74,7 +74,7 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
} else {
// Doesn't start with a guard
if endsNormal || endsAlt {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Invalid start/end guards: {contents}"
)));
}
@@ -94,7 +94,7 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
) {
resultLength += 10;
} else {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Cannot encode : '{ch}'"
)));
}
@@ -109,7 +109,7 @@ impl OneDimensionalCodeWriter for CodaBarWriter {
let mut c = contents
.chars()
.nth(index)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_ascii_uppercase();
if index == 0 || index == contents.chars().count() - 1 {
// The start/end chars are not in the CodaBarReader.ALPHABET.

16
src/oned/code_128_reader.rs
View File

@@ -53,7 +53,7 @@ impl OneDReader for Code128Reader {
CODE_START_A => CODE_CODE_A,
CODE_START_B => CODE_CODE_B,
CODE_START_C => CODE_CODE_C,
_ => return Err(Exceptions::format),
_ => return Err(Exceptions::FORMAT),
};
let mut done = false;
@@ -103,7 +103,7 @@ impl OneDReader for Code128Reader {
// Take care of illegal start codes
match code {
CODE_START_A | CODE_START_B | CODE_START_C => return Err(Exceptions::format),
CODE_START_A | CODE_START_B | CODE_START_C => return Err(Exceptions::FORMAT),
_ => {}
}
@@ -297,21 +297,21 @@ impl OneDReader for Code128Reader {
row.getSize().min(nextStart + (nextStart - lastStart) / 2),
false,
)? {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// Pull out from sum the value of the penultimate check code
checksumTotal -= multiplier as usize * lastCode as usize;
// lastCode is the checksum then:
if (checksumTotal % 103) as u8 != lastCode {
return Err(Exceptions::checksum);
return Err(Exceptions::CHECKSUM);
}
// Need to pull out the check digits from string
let resultLength = result.chars().count();
if resultLength == 0 {
// false positive
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// Only bother if the result had at least one character, and if the checksum digit happened to
@@ -332,7 +332,7 @@ impl OneDReader for Code128Reader {
let rawCodesSize = rawCodes.len();
let mut rawBytes = vec![0u8; rawCodesSize];
for (i, rawByte) in rawBytes.iter_mut().enumerate().take(rawCodesSize) {
*rawByte = *rawCodes.get(i).ok_or(Exceptions::indexOutOfBounds)?;
*rawByte = *rawCodes.get(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
}
let mut resultObject = RXingResult::new(
&result,
@@ -406,7 +406,7 @@ impl Code128Reader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn decodeCode(&self, row: &BitArray, counters: &mut [u32; 6], rowOffset: usize) -> Result<u8> {
@@ -426,7 +426,7 @@ impl Code128Reader {
if bestMatch >= 0 {
Ok(bestMatch as u8)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
}

38
src/oned/code_128_writer.rs
View File

@@ -100,7 +100,7 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
let length = contents.chars().count();
// Check length
if !(1..=80).contains(&length) {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Contents length should be between 1 and 80 characters, but got {length}"
)));
}
@@ -108,13 +108,13 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
// Check for forced code set hint.
let mut forcedCodeSet = -1_i32;
if hints.contains_key(&EncodeHintType::FORCE_CODE_SET) {
let Some(EncodeHintValue::ForceCodeSet(codeSetHint)) = hints.get(&EncodeHintType::FORCE_CODE_SET) else { return Err(Exceptions::illegalState) };
let Some(EncodeHintValue::ForceCodeSet(codeSetHint)) = hints.get(&EncodeHintType::FORCE_CODE_SET) else { return Err(Exceptions::ILLEGAL_STATE) };
match codeSetHint.as_str() {
"A" => forcedCodeSet = CODE_CODE_A as i32,
"B" => forcedCodeSet = CODE_CODE_B as i32,
"C" => forcedCodeSet = CODE_CODE_C as i32,
_ => {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Unsupported code set hint: {codeSetHint}"
)))
}
@@ -135,7 +135,7 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
if c > 127 {
// no full Latin-1 character set available at the moment
// shift and manual code change are not supported
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Bad character in input: ASCII value={c}"
)));
}
@@ -150,7 +150,7 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
// allows no ascii above 95 (no lower caps, no special symbols)
{
if c > 95 && c <= 127 {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Bad character in input for forced code set A: ASCII value={c}"
)));
}
@@ -159,7 +159,7 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
// allows no ascii below 32 (terminal symbols)
{
if c <= 32 {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Bad character in input for forced code set B: ASCII value={c}"
)));
}
@@ -173,7 +173,7 @@ fn check(contents: &str, hints: &crate::EncodingHintDictionary) -> Result<i32> {
|| ch == ESCAPE_FNC_3
|| ch == ESCAPE_FNC_4
{
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Bad character in input for forced code set C: ASCII value={c}"
)));
}
@@ -196,7 +196,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
while position < length {
//Select code to use
let newCodeSet = if forcedCodeSet == -1 {
chooseCode(contents, position, codeSet).ok_or(Exceptions::illegalState)?
chooseCode(contents, position, codeSet).ok_or(Exceptions::ILLEGAL_STATE)?
} else {
forcedCodeSet as usize // THIS IS RISKY
};
@@ -209,7 +209,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
match contents
.chars()
.nth(position)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
{
ESCAPE_FNC_1 => patternIndex = CODE_FNC_1 as isize,
ESCAPE_FNC_2 => patternIndex = CODE_FNC_2 as isize,
@@ -229,7 +229,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
patternIndex = contents
.chars()
.nth(position)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
as isize
- ' ' as isize;
if patternIndex < 0 {
@@ -241,7 +241,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
patternIndex = contents
.chars()
.nth(position)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
as isize
- ' ' as isize
}
@@ -249,7 +249,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
// CODE_CODE_C
if position + 1 == length {
// this is the last character, but the encoding is C, which always encodes two characers
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"Bad number of characters for digit only encoding.",
));
}
@@ -260,7 +260,7 @@ fn encodeFast(contents: &str, forcedCodeSet: i32) -> Result<Vec<bool>> {
.map(|(_u, c)| c)
.collect();
patternIndex = s.parse::<isize>().map_err(|e| {
Exceptions::parseWith(format!("issue parsing {s}: {e}"))
Exceptions::parse_with(format!("issue parsing {s}: {e}"))
})?;
position += 1;
} // Also incremented below
@@ -536,7 +536,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
if contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
== ESCAPE_FNC_1
{
addPattern(
@@ -556,7 +556,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
addPattern(
&mut patterns,
s.parse::<usize>().map_err(|e| {
Exceptions::parseWith(format!("unable to parse {s} {e}"))
Exceptions::parse_with(format!("unable to parse {s} {e}"))
})?,
&mut checkSum,
&mut checkWeight,
@@ -572,7 +572,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
let mut patternIndex = match contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
{
ESCAPE_FNC_1 => CODE_FNC_1 as isize,
ESCAPE_FNC_2 => CODE_FNC_2 as isize,
@@ -590,7 +590,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)? as isize
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as isize
- ' ' as isize
}
};
@@ -681,7 +681,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
minPath: &mut Vec<Vec<Latch>>,
) -> Result<u32> {
if position >= contents.chars().count() {
return Err(Exceptions::illegalState);
return Err(Exceptions::ILLEGAL_STATE);
}
let mCost = memoizedCost[charset.ordinal()][position];
if mCost > 0 {
@@ -762,7 +762,7 @@ stuvwxyz{|}~\u{007F}\u{00FF}";
}
}
if minCost == u32::MAX {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Bad character in input: ASCII value={}",
contents.chars().nth(position).unwrap_or('x')
)));

46
src/oned/code_39_reader.rs
View File

@@ -60,7 +60,7 @@ impl OneDReader for Code39Reader {
one_d_reader::recordPattern(row, nextStart, &mut counters)?;
let pattern = Self::toNarrowWidePattern(&counters);
if pattern < 0 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decodedChar = Self::patternToChar(pattern as u32)?;
self.decodeRowRXingResult.push(decodedChar);
@@ -85,7 +85,7 @@ impl OneDReader for Code39Reader {
// If 50% of last pattern size, following last pattern, is not whitespace, fail
// (but if it's whitespace to the very end of the image, that's OK)
if nextStart != end && (whiteSpaceAfterEnd * 2) < lastPatternSize as usize {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
if self.usingCheckDigit {
@@ -96,7 +96,7 @@ impl OneDReader for Code39Reader {
self.decodeRowRXingResult
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?,
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?,
) {
total += pos;
}
@@ -105,20 +105,20 @@ impl OneDReader for Code39Reader {
.decodeRowRXingResult
.chars()
.nth(max)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
!= Self::ALPHABET_STRING
.chars()
.nth(total % 43)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
{
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
self.decodeRowRXingResult.truncate(max);
}
if self.decodeRowRXingResult.chars().count() == 0 {
// false positive
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let resultString = if self.extendedMode {
@@ -246,7 +246,7 @@ impl Code39Reader {
isWhite = !isWhite;
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
// For efficiency, returns -1 on failure. Not throwing here saved as many as 700 exceptions
@@ -306,13 +306,13 @@ impl Code39Reader {
return Self::ALPHABET_STRING
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds);
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS);
}
}
if pattern == Self::ASTERISK_ENCODING {
return Ok('*');
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn decodeExtended(encoded: &str) -> Result<String> {
@@ -322,46 +322,46 @@ impl Code39Reader {
while i < length {
// for i in 0..length {
// for (int i = 0; i < length; i++) {
let c = encoded.chars().nth(i).ok_or(Exceptions::indexOutOfBounds)?;
let c = encoded.chars().nth(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
if c == '+' || c == '$' || c == '%' || c == '/' {
let next = encoded
.chars()
.nth(i + 1)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
let mut decodedChar = '\0';
match c {
'+' => {
// +A to +Z map to a to z
if ('A'..='Z').contains(&next) {
decodedChar = char::from_u32(next as u32 + 32)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
'$' => {
// $A to $Z map to control codes SH to SB
if ('A'..='Z').contains(&next) {
decodedChar = char::from_u32(next as u32 - 64)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
'%' => {
// %A to %E map to control codes ESC to US
if ('A'..='E').contains(&next) {
decodedChar = char::from_u32(next as u32 - 38)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else if ('F'..='J').contains(&next) {
decodedChar = char::from_u32(next as u32 - 11)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else if ('K'..='O').contains(&next) {
decodedChar = char::from_u32(next as u32 + 16)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else if ('P'..='T').contains(&next) {
decodedChar = char::from_u32(next as u32 + 43)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else if next == 'U' {
decodedChar = 0 as char;
} else if next == 'V' {
@@ -371,18 +371,18 @@ impl Code39Reader {
} else if next == 'X' || next == 'Y' || next == 'Z' {
decodedChar = 127 as char;
} else {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
'/' => {
// /A to /O map to ! to , and /Z maps to :
if ('A'..='O').contains(&next) {
decodedChar = char::from_u32(next as u32 - 32)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
} else if next == 'Z' {
decodedChar = ':';
} else {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
_ => {}

28
src/oned/code_39_writer.rs
View File

@@ -34,7 +34,7 @@ impl OneDimensionalCodeWriter for Code39Writer {
let mut contents = contents.to_owned();
let mut length = contents.chars().count();
if length > 80 {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested contents should be less than 80 digits long, but got {length}"
)));
}
@@ -48,14 +48,14 @@ impl OneDimensionalCodeWriter for Code39Writer {
contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?,
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?,
)
.is_none()
{
contents = Self::tryToConvertToExtendedMode(&contents)?;
length = contents.chars().count();
if length > 80 {
return Err(Exceptions::illegalArgumentWith(format!("Requested contents should be less than 80 digits long, but got {length} (extended full ASCII mode)")));
return Err(Exceptions::illegal_argument_with(format!("Requested contents should be less than 80 digits long, but got {length} (extended full ASCII mode)")));
}
break;
}
@@ -71,7 +71,7 @@ impl OneDimensionalCodeWriter for Code39Writer {
pos += Self::appendPattern(&mut result, pos as usize, &narrowWhite, false);
//append next character to byte matrix
for i in 0..length {
let Some(indexInString) = Code39Reader::ALPHABET_STRING.find(contents.chars().nth(i).ok_or(Exceptions::indexOutOfBounds)?) else {
let Some(indexInString) = Code39Reader::ALPHABET_STRING.find(contents.chars().nth(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?) else {
continue;
};
Self::toIntArray(
@@ -118,56 +118,56 @@ impl Code39Writer {
extendedContent.push('$');
extendedContent.push(
char::from_u32('A' as u32 + (character as u32 - 1))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character < ' ' {
extendedContent.push('%');
extendedContent.push(
char::from_u32('A' as u32 + (character as u32 - 27))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= ',' || character == '/' || character == ':' {
extendedContent.push('/');
extendedContent.push(
char::from_u32('A' as u32 + (character as u32 - 33))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= '9' {
extendedContent.push(
char::from_u32('0' as u32 + (character as u32 - 48))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= '?' {
extendedContent.push('%');
extendedContent.push(
char::from_u32('F' as u32 + (character as u32 - 59))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= 'Z' {
extendedContent.push(
char::from_u32('A' as u32 + (character as u32 - 65))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= '_' {
extendedContent.push('%');
extendedContent.push(
char::from_u32('K' as u32 + (character as u32 - 91))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= 'z' {
extendedContent.push('+');
extendedContent.push(
char::from_u32('A' as u32 + (character as u32 - 97))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character as u32 <= 127 {
extendedContent.push('%');
extendedContent.push(
char::from_u32('P' as u32 + (character as u32 - 123))
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested content contains a non-encodable character: '{character}'"
)));
}

44
src/oned/code_93_reader.rs
View File

@@ -66,7 +66,7 @@ impl OneDReader for Code93Reader {
one_d_reader::recordPattern(row, nextStart, &mut theCounters)?;
let pattern = Self::toPattern(&theCounters);
if pattern < 0 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decodedChar = Self::patternToChar(pattern as u32)?;
self.decodeRowRXingResult.push(decodedChar);
@@ -95,12 +95,12 @@ impl OneDReader for Code93Reader {
// Should be at least one more black module
if nextStart == end || !row.get(nextStart) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
if self.decodeRowRXingResult.chars().count() < 2 {
// false positive -- need at least 2 checksum digits
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Self::checkChecksums(&self.decodeRowRXingResult)?;
@@ -194,7 +194,7 @@ impl Code93Reader {
isWhite = !isWhite;
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn toPattern(counters: &[u32; 6]) -> i32 {
@@ -224,7 +224,7 @@ impl Code93Reader {
return Ok(Self::ALPHABET[i]);
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn decodeExtended(encoded: &str) -> Result<String> {
@@ -234,52 +234,52 @@ impl Code93Reader {
while i < length {
// for i in 0..length {
// for (int i = 0; i < length; i++) {
let c = encoded.chars().nth(i).ok_or(Exceptions::indexOutOfBounds)?;
let c = encoded.chars().nth(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
if ('a'..='d').contains(&c) {
if i >= length - 1 {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
let next = encoded
.chars()
.nth(i + 1)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
let mut decodedChar = '\0';
match c {
'd' => {
// +A to +Z map to a to z
if ('A'..='Z').contains(&next) {
decodedChar =
char::from_u32(next as u32 + 32).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 + 32).ok_or(Exceptions::PARSE)?;
} else {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
}
'a' => {
// $A to $Z map to control codes SH to SB
if ('A'..='Z').contains(&next) {
decodedChar =
char::from_u32(next as u32 - 64).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 - 64).ok_or(Exceptions::PARSE)?;
} else {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
}
'b' => {
if ('A'..='E').contains(&next) {
// %A to %E map to control codes ESC to USep
decodedChar =
char::from_u32(next as u32 - 38).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 - 38).ok_or(Exceptions::PARSE)?;
} else if ('F'..='J').contains(&next) {
// %F to %J map to ; < = > ?
decodedChar =
char::from_u32(next as u32 - 11).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 - 11).ok_or(Exceptions::PARSE)?;
} else if ('K'..='O').contains(&next) {
// %K to %O map to [ \ ] ^ _
decodedChar =
char::from_u32(next as u32 + 16).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 + 16).ok_or(Exceptions::PARSE)?;
} else if ('P'..='T').contains(&next) {
// %P to %T map to { | } ~ DEL
decodedChar =
char::from_u32(next as u32 + 43).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 + 43).ok_or(Exceptions::PARSE)?;
} else if next == 'U' {
// %U map to NUL
decodedChar = '\0';
@@ -293,18 +293,18 @@ impl Code93Reader {
// %X to %Z all map to DEL (127)
decodedChar = 127 as char;
} else {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
}
'c' => {
// /A to /O map to ! to , and /Z maps to :
if ('A'..='O').contains(&next) {
decodedChar =
char::from_u32(next as u32 - 32).ok_or(Exceptions::parse)?;
char::from_u32(next as u32 - 32).ok_or(Exceptions::PARSE)?;
} else if next == 'Z' {
decodedChar = ':';
} else {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
}
_ => {}
@@ -334,7 +334,7 @@ impl Code93Reader {
for i in (0..checkPosition).rev() {
total += weight
* Self::ALPHABET_STRING
.find(result.chars().nth(i).ok_or(Exceptions::indexOutOfBounds)?)
.find(result.chars().nth(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?)
.map_or_else(|| -1_i32, |v| v as i32);
weight += 1;
if weight > weightMax as i32 {
@@ -344,10 +344,10 @@ impl Code93Reader {
if result
.chars()
.nth(checkPosition)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
!= Self::ALPHABET[(total as usize) % 47]
{
Err(Exceptions::checksum)
Err(Exceptions::CHECKSUM)
} else {
Ok(())
}

22
src/oned/code_93_writer.rs
View File

@@ -36,7 +36,7 @@ impl OneDimensionalCodeWriter for Code93Writer {
let mut contents = Self::convertToExtended(contents)?;
let length = contents.chars().count();
if length > 80 {
return Err(Exceptions::illegalArgumentWith(format!("Requested contents should be less than 80 digits long after converting to extended encoding, but got {length}" )));
return Err(Exceptions::illegal_argument_with(format!("Requested contents should be less than 80 digits long after converting to extended encoding, but got {length}" )));
}
//length of code + 2 start/stop characters + 2 checksums, each of 9 bits, plus a termination bar
@@ -49,7 +49,7 @@ impl OneDimensionalCodeWriter for Code93Writer {
for i in 0..length {
// for (int i = 0; i < length; i++) {
let Some(indexInString) = Code93Reader::ALPHABET_STRING.find(contents.chars().nth(i).ok_or(Exceptions::indexOutOfBounds)?) else {panic!("alphabet")};
let Some(indexInString) = Code93Reader::ALPHABET_STRING.find(contents.chars().nth(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?) else {panic!("alphabet")};
pos += Self::appendPattern(
&mut result,
pos,
@@ -66,7 +66,7 @@ impl OneDimensionalCodeWriter for Code93Writer {
Code93Reader::ALPHABET_STRING
.chars()
.nth(check1)
.ok_or(Exceptions::indexOutOfBounds)?,
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?,
);
let check2 = Self::computeChecksumIndex(&contents, 15);
@@ -157,13 +157,13 @@ impl Code93Writer {
// SOH - SUB: ($)A - ($)Z
extendedContent.push('a');
extendedContent.push(
char::from_u32('A' as u32 + character as u32 - 1).ok_or(Exceptions::parse)?,
char::from_u32('A' as u32 + character as u32 - 1).ok_or(Exceptions::PARSE)?,
);
} else if character as u32 <= 31 {
// ESC - US: (%)A - (%)E
extendedContent.push('b');
extendedContent.push(
char::from_u32('A' as u32 + character as u32 - 27).ok_or(Exceptions::parse)?,
char::from_u32('A' as u32 + character as u32 - 27).ok_or(Exceptions::PARSE)?,
);
} else if character == ' ' || character == '$' || character == '%' || character == '+' {
// space $ % +
@@ -173,7 +173,7 @@ impl Code93Writer {
extendedContent.push('c');
extendedContent.push(
char::from_u32('A' as u32 + character as u32 - '!' as u32)
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character <= '9' {
extendedContent.push(character);
@@ -185,7 +185,7 @@ impl Code93Writer {
extendedContent.push('b');
extendedContent.push(
char::from_u32('F' as u32 + character as u32 - ';' as u32)
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character == '@' {
// @: (%)V
@@ -198,7 +198,7 @@ impl Code93Writer {
extendedContent.push('b');
extendedContent.push(
char::from_u32('K' as u32 + character as u32 - '[' as u32)
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character == '`' {
// `: (%)W
@@ -208,17 +208,17 @@ impl Code93Writer {
extendedContent.push('d');
extendedContent.push(
char::from_u32('A' as u32 + character as u32 - 'a' as u32)
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else if character as u32 <= 127 {
// { - DEL: (%)P - (%)T
extendedContent.push('b');
extendedContent.push(
char::from_u32('P' as u32 + character as u32 - '{' as u32)
.ok_or(Exceptions::parse)?,
.ok_or(Exceptions::PARSE)?,
);
} else {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested content contains a non-encodable character: '{character}'"
)));
}

8
src/oned/ean_13_reader.rs
View File

@@ -66,7 +66,7 @@ impl UPCEANReader for EAN13Reader {
&upc_ean_reader::L_AND_G_PATTERNS,
)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
@@ -89,7 +89,7 @@ impl UPCEANReader for EAN13Reader {
let bestMatch =
self.decodeDigit(row, &mut counters, rowOffset, &upc_ean_reader::L_PATTERNS)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
@@ -148,11 +148,11 @@ impl EAN13Reader {
if lgPatternFound == Self::FIRST_DIGIT_ENCODINGS[d] {
resultString.insert(
0,
char::from_u32('0' as u32 + d as u32).ok_or(Exceptions::parse)?,
char::from_u32('0' as u32 + d as u32).ok_or(Exceptions::PARSE)?,
);
return Ok(());
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}

16
src/oned/ean_13_writer.rs
View File

@@ -46,13 +46,13 @@ impl OneDimensionalCodeWriter for EAN13Writer {
}
13 => {
if !reader.checkStandardUPCEANChecksum(&contents)? {
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"Contents do not pass checksum",
));
}
}
_ => {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested contents should be 12 or 13 digits long, but got {length}"
)))
}
@@ -63,9 +63,9 @@ impl OneDimensionalCodeWriter for EAN13Writer {
let firstDigit = contents
.chars()
.next()
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize;
.ok_or(Exceptions::PARSE)? as usize;
let parities = EAN13Reader::FIRST_DIGIT_ENCODINGS[firstDigit];
let mut result = [false; CODE_WIDTH];
let mut pos = 0;
@@ -80,9 +80,9 @@ impl OneDimensionalCodeWriter for EAN13Writer {
let mut digit = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize;
.ok_or(Exceptions::PARSE)? as usize;
if (parities >> (6 - i) & 1) == 1 {
digit += 10;
}
@@ -101,9 +101,9 @@ impl OneDimensionalCodeWriter for EAN13Writer {
let digit = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize;
.ok_or(Exceptions::PARSE)? as usize;
pos += EAN13Writer::appendPattern(
&mut result,

4
src/oned/ean_8_reader.rs
View File

@@ -54,7 +54,7 @@ impl UPCEANReader for EAN8Reader {
let bestMatch =
self.decodeDigit(row, &mut counters, rowOffset, &upc_ean_reader::L_PATTERNS)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
@@ -70,7 +70,7 @@ impl UPCEANReader for EAN8Reader {
let bestMatch =
self.decodeDigit(row, &mut counters, rowOffset, &upc_ean_reader::L_PATTERNS)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
x += 1;

12
src/oned/ean_8_writer.rs
View File

@@ -56,13 +56,13 @@ impl OneDimensionalCodeWriter for EAN8Writer {
}
8 => {
if !EAN8Reader.checkStandardUPCEANChecksum(&contents)? {
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"Contents do not pass checksum",
));
}
}
_ => {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested contents should be 7 or 8 digits long, but got {length}"
)))
}
@@ -81,9 +81,9 @@ impl OneDimensionalCodeWriter for EAN8Writer {
let digit = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::indexOutOfBounds)? as usize;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as usize;
pos += Self::appendPattern(&mut result, pos, &upc_ean_reader::L_PATTERNS[digit], false)
as usize;
}
@@ -96,9 +96,9 @@ impl OneDimensionalCodeWriter for EAN8Writer {
let digit = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::indexOutOfBounds)? as usize;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as usize;
pos += Self::appendPattern(&mut result, pos, &upc_ean_reader::L_PATTERNS[digit], true)
as usize;
}

14
src/oned/itf_reader.rs
View File

@@ -143,7 +143,7 @@ impl OneDReader for ITFReader {
lengthOK = true;
}
if !lengthOK {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
let mut resultObject = RXingResult::new(
@@ -198,9 +198,9 @@ impl ITFReader {
}
let mut bestMatch = self.decodeDigit(&counterBlack)?;
resultString.push(char::from_u32('0' as u32 + bestMatch).ok_or(Exceptions::parse)?);
resultString.push(char::from_u32('0' as u32 + bestMatch).ok_or(Exceptions::PARSE)?);
bestMatch = self.decodeDigit(&counterWhite)?;
resultString.push(char::from_u32('0' as u32 + bestMatch).ok_or(Exceptions::parse)?);
resultString.push(char::from_u32('0' as u32 + bestMatch).ok_or(Exceptions::PARSE)?);
payloadStart += counterDigitPair.iter().sum::<u32>() as usize;
}
@@ -261,7 +261,7 @@ impl ITFReader {
if quietCount != 0 {
// Unable to find the necessary number of quiet zone pixels.
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
} else {
Ok(())
}
@@ -278,7 +278,7 @@ impl ITFReader {
let width = row.getSize();
let endStart = row.getNextSet(0);
if endStart == width {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Ok(endStart)
@@ -373,7 +373,7 @@ impl ITFReader {
isWhite = !isWhite;
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/**
@@ -402,7 +402,7 @@ impl ITFReader {
if bestMatch >= 0 {
Ok(bestMatch as u32 % 10)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
}

12
src/oned/itf_writer.rs
View File

@@ -33,12 +33,12 @@ impl OneDimensionalCodeWriter for ITFWriter {
fn encode_oned(&self, contents: &str) -> Result<Vec<bool>> {
let length = contents.chars().count();
if length % 2 != 0 {
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"The length of the input should be even",
));
}
if length > 80 {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested contents should be less than 80 digits long, but got {length}"
)));
}
@@ -52,15 +52,15 @@ impl OneDimensionalCodeWriter for ITFWriter {
let one = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize;
.ok_or(Exceptions::PARSE)? as usize;
let two = contents
.chars()
.nth(i + 1)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize;
.ok_or(Exceptions::PARSE)? as usize;
let mut encoding = [0; 10];
for j in 0..5 {
encoding[2 * j] = PATTERNS[one][j];

4
src/oned/multi_format_one_d_reader.rs
View File

@@ -47,7 +47,7 @@ impl OneDReader for MultiFormatOneDReader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
impl MultiFormatOneDReader {
@@ -166,7 +166,7 @@ impl Reader for MultiFormatOneDReader {
Ok(result)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}

4
src/oned/multi_format_upc_ean_reader.rs
View File

@@ -135,7 +135,7 @@ impl OneDReader for MultiFormatUPCEANReader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
@@ -198,7 +198,7 @@ impl Reader for MultiFormatUPCEANReader {
Ok(result)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}

10
src/oned/one_d_code_writer.rs
View File

@@ -101,7 +101,7 @@ pub trait OneDimensionalCodeWriter: Writer {
*/
fn checkNumeric(contents: &str) -> Result<()> {
if !NUMERIC.is_match(contents) {
Err(Exceptions::illegalArgumentWith(
Err(Exceptions::illegal_argument_with(
"Input should only contain digits 0-9",
))
} else {
@@ -164,17 +164,17 @@ impl Writer for L {
hints: &crate::EncodingHintDictionary,
) -> Result<crate::common::BitMatrix> {
if contents.is_empty() {
return Err(Exceptions::illegalArgumentWith("Found empty contents"));
return Err(Exceptions::illegal_argument_with("Found empty contents"));
}
if width < 0 || height < 0 {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Negative size is not allowed. Input: {width}x{height}"
)));
}
if let Some(supportedFormats) = self.getSupportedWriteFormats() {
if !supportedFormats.contains(format) {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Can only encode {supportedFormats:?}, but got {format:?}"
)));
}
@@ -183,7 +183,7 @@ impl Writer for L {
let mut sidesMargin = self.getDefaultMargin();
if let Some(EncodeHintValue::Margin(margin)) = hints.get(&EncodeHintType::MARGIN) {
sidesMargin = margin.parse::<u32>().map_err(|e| {
Exceptions::illegalArgumentWith(format!("couldnt parse {margin}: {e}"))
Exceptions::illegal_argument_with(format!("couldnt parse {margin}: {e}"))
})?;
}

8
src/oned/one_d_reader.rs
View File

@@ -125,7 +125,7 @@ pub trait OneDReader: Reader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/**
@@ -212,7 +212,7 @@ pub fn recordPattern(row: &BitArray, start: usize, counters: &mut [u32]) -> Resu
let end = row.getSize();
if start >= end {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let mut isWhite = !row.get(start);
@@ -235,7 +235,7 @@ pub fn recordPattern(row: &BitArray, start: usize, counters: &mut [u32]) -> Resu
// If we read fully the last section of pixels and filled up our counters -- or filled
// the last counter but ran off the side of the image, OK. Otherwise, a problem.
if !(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end)) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Ok(())
}
@@ -253,7 +253,7 @@ pub fn recordPatternInReverse(row: &BitArray, start: usize, counters: &mut [u32]
}
}
if numTransitionsLeft >= 0 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
recordPattern(row, start + 1, counters)?;

2
src/oned/rss/abstract_rss_reader.rs
View File

@@ -39,7 +39,7 @@ pub trait AbstractRSSReaderTrait: OneDReader {
return Ok(value as u32);
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/**

8
src/oned/rss/expanded/binary_util.rs
View File

@@ -53,13 +53,13 @@ pub fn buildBitArrayFromString(data: &str) -> Result<BitArray> {
// for (int i = 0; i < dotsAndXs.length(); ++i) {
if i % 9 == 0 {
// spaces
if dotsAndXs.chars().nth(i).ok_or(Exceptions::parse)? != ' ' {
return Err(Exceptions::illegalStateWith("space expected"));
if dotsAndXs.chars().nth(i).ok_or(Exceptions::PARSE)? != ' ' {
return Err(Exceptions::illegal_state_with("space expected"));
}
continue;
}
let currentChar = dotsAndXs.chars().nth(i).ok_or(Exceptions::parse)?;
let currentChar = dotsAndXs.chars().nth(i).ok_or(Exceptions::PARSE)?;
if currentChar == 'X' || currentChar == 'x' {
binary.set(counter);
}
@@ -81,7 +81,7 @@ pub fn buildBitArrayFromStringWithoutSpaces(data: &str) -> Result<BitArray> {
sb.push(' ');
let mut i = 0;
while i < 8 && current < dotsAndXs_length {
sb.push(dotsAndXs.chars().nth(current).ok_or(Exceptions::parse)?);
sb.push(dotsAndXs.chars().nth(current).ok_or(Exceptions::PARSE)?);
current += 1;
i += 1;

2
src/oned/rss/expanded/decoders/abstract_expanded_decoder.rs
View File

@@ -152,7 +152,7 @@ pub fn createDecoder<'a>(
_ => {}
}
Err(Exceptions::illegalStateWith(format!(
Err(Exceptions::illegal_state_with(format!(
"unknown decoder: {information}"
)))
}

2
src/oned/rss/expanded/decoders/ai_01392x_decoder.rs
View File

@@ -39,7 +39,7 @@ impl AI01decoder for AI01392xDecoder<'_> {}
impl AbstractExpandedDecoder for AI01392xDecoder<'_> {
fn parseInformation(&mut self) -> Result<String> {
if self.information.getSize() < Self::HEADER_SIZE + Self::GTIN_SIZE as usize {
return Err(crate::Exceptions::notFound);
return Err(crate::Exceptions::NOT_FOUND);
}
let mut buf = String::new();

2
src/oned/rss/expanded/decoders/ai_01393x_decoder.rs
View File

@@ -39,7 +39,7 @@ impl AI01decoder for AI01393xDecoder<'_> {}
impl AbstractExpandedDecoder for AI01393xDecoder<'_> {
fn parseInformation(&mut self) -> Result<String> {
if self.information.getSize() < Self::HEADER_SIZE + Self::GTIN_SIZE as usize {
return Err(crate::Exceptions::notFound);
return Err(crate::Exceptions::NOT_FOUND);
}
let mut buf = String::new();

2
src/oned/rss/expanded/decoders/ai_013x0x1x_decoder.rs
View File

@@ -57,7 +57,7 @@ impl AbstractExpandedDecoder for AI013x0x1xDecoder<'_> {
if self.information.getSize()
!= Self::HEADER_SIZE + Self::GTIN_SIZE as usize + Self::WEIGHT_SIZE + Self::DATE_SIZE
{
return Err(crate::Exceptions::notFound);
return Err(crate::Exceptions::NOT_FOUND);
}
let mut buf = String::new();

2
src/oned/rss/expanded/decoders/ai_013x0x_decoder.rs
View File

@@ -53,7 +53,7 @@ impl AbstractExpandedDecoder for AI013x0xDecoder<'_> {
if self.information.getSize()
!= Self::HEADER_SIZE + Self::GTIN_SIZE as usize + Self::WEIGHT_SIZE
{
return Err(crate::Exceptions::notFound);
return Err(crate::Exceptions::NOT_FOUND);
}
let mut buf = String::new();

2
src/oned/rss/expanded/decoders/decoded_numeric.rs
View File

@@ -52,7 +52,7 @@ impl DecodedNumeric {
if
/*firstDigit < 0 ||*/
firstDigit > 10 || /*secondDigit < 0 ||*/ secondDigit > 10 {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
Ok(Self {

12
src/oned/rss/expanded/decoders/field_parser.rs
View File

@@ -146,7 +146,7 @@ pub fn parseFieldsInGeneralPurpose(rawInformation: &str) -> Result<String> {
// Processing 2-digit AIs
if rawInformation.chars().count() < 2 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let lookup: String = rawInformation.chars().take(2).collect();
@@ -159,7 +159,7 @@ pub fn parseFieldsInGeneralPurpose(rawInformation: &str) -> Result<String> {
}
if rawInformation.chars().count() < 3 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let firstThreeDigits: String = rawInformation.chars().take(3).collect();
@@ -172,7 +172,7 @@ pub fn parseFieldsInGeneralPurpose(rawInformation: &str) -> Result<String> {
}
if rawInformation.chars().count() < 4 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let threeDigitPlusDigitDataLength = THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH.get(&firstThreeDigits);
@@ -192,18 +192,18 @@ pub fn parseFieldsInGeneralPurpose(rawInformation: &str) -> Result<String> {
return processFixedAI(4, ffdl.length, rawInformation);
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn processFixedAI(aiSize: usize, fieldSize: usize, rawInformation: &str) -> Result<String> {
if rawInformation.chars().count() < aiSize {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let ai: String = rawInformation.chars().take(aiSize).collect();
if rawInformation.chars().count() < aiSize + fieldSize {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let field: String = rawInformation

16
src/oned/rss/expanded/decoders/general_app_id_decoder.rs
View File

@@ -198,7 +198,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
if let Some(r) = result.getDecodedInformation() {
Ok(r.clone())
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
@@ -344,7 +344,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
if (5..15).contains(&fiveBitValue) {
return Ok(DecodedChar::new(
pos + 5,
char::from_u32('0' as u32 + fiveBitValue - 5).ok_or(Exceptions::parse)?,
char::from_u32('0' as u32 + fiveBitValue - 5).ok_or(Exceptions::PARSE)?,
));
}
@@ -353,14 +353,14 @@ impl<'a> GeneralAppIdDecoder<'_> {
if (64..90).contains(&sevenBitValue) {
return Ok(DecodedChar::new(
pos + 7,
char::from_u32(sevenBitValue + 1).ok_or(Exceptions::parse)?,
char::from_u32(sevenBitValue + 1).ok_or(Exceptions::PARSE)?,
));
}
if (90..116).contains(&sevenBitValue) {
return Ok(DecodedChar::new(
pos + 7,
char::from_u32(sevenBitValue + 7).ok_or(Exceptions::parse)?,
char::from_u32(sevenBitValue + 7).ok_or(Exceptions::PARSE)?,
));
}
@@ -387,7 +387,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
250 => '?',
251 => '_',
252 => ' ',
_ => return Err(Exceptions::format),
_ => return Err(Exceptions::FORMAT),
};
Ok(DecodedChar::new(pos + 8, c))
@@ -422,7 +422,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
if (5..15).contains(&fiveBitValue) {
return Ok(DecodedChar::new(
pos + 5,
char::from_u32('0' as u32 + fiveBitValue - 5).ok_or(Exceptions::parse)?,
char::from_u32('0' as u32 + fiveBitValue - 5).ok_or(Exceptions::PARSE)?,
));
}
@@ -431,7 +431,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
if (32..58).contains(&sixBitValue) {
return Ok(DecodedChar::new(
pos + 6,
char::from_u32(sixBitValue + 33).ok_or(Exceptions::parse)?,
char::from_u32(sixBitValue + 33).ok_or(Exceptions::PARSE)?,
));
}
@@ -442,7 +442,7 @@ impl<'a> GeneralAppIdDecoder<'_> {
61 => '.',
62 => '/',
_ => {
return Err(Exceptions::illegalStateWith(format!(
return Err(Exceptions::illegal_state_with(format!(
"Decoding invalid alphanumeric value: {sixBitValue}"
)))
}

60
src/oned/rss/expanded/rss_expanded_reader.rs
View File

@@ -224,7 +224,7 @@ impl Reader for RSSExpandedReader {
Ok(result)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
}
@@ -294,7 +294,7 @@ impl RSSExpandedReader {
if let Ok(to_add) = to_add_res {
self.pairs.push(to_add);
} else if self.pairs.is_empty() {
return Err(to_add_res.err().unwrap_or(Exceptions::illegalState));
return Err(to_add_res.err().unwrap_or(Exceptions::ILLEGAL_STATE));
} else {
// exit this loop when retrieveNextPair() fails and throws
done = true;
@@ -326,7 +326,7 @@ impl RSSExpandedReader {
// }
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn checkRows(&mut self, reverse: bool) -> Option<Vec<ExpandedPair>> {
@@ -370,7 +370,7 @@ impl RSSExpandedReader {
) -> Result<Vec<ExpandedPair>> {
for i in currentRow..self.rows.len() {
// for (int i = currentRow; i < rows.size(); i++) {
let row = self.rows.get(i).ok_or(Exceptions::indexOutOfBounds)?;
let row = self.rows.get(i).ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
self.pairs.clear();
for collectedRow in &collectedRows.clone() {
// for (ExpandedRow collectedRow : collectedRows) {
@@ -398,7 +398,7 @@ impl RSSExpandedReader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/// Whether the pairs form a valid find pattern sequence,
@@ -529,24 +529,24 @@ impl RSSExpandedReader {
// Not private for unit testing
pub(crate) fn constructRXingResult(pairs: &[ExpandedPair]) -> Result<RXingResult> {
let binary = bit_array_builder::buildBitArray(&pairs.to_vec())
.ok_or(Exceptions::IllegalStateException(None))?;
.ok_or(Exceptions::ILLEGAL_STATE)?;
let mut decoder = abstract_expanded_decoder::createDecoder(&binary)?;
let resultingString = decoder.parseInformation()?;
let firstPoints = pairs
.get(0)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.getFinderPattern()
.as_ref()
.ok_or(Exceptions::illegalState)?
.ok_or(Exceptions::ILLEGAL_STATE)?
.getPoints();
let lastPoints = pairs
.last()
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.getFinderPattern()
.as_ref()
.ok_or(Exceptions::illegalState)?
.ok_or(Exceptions::ILLEGAL_STATE)?
.getPoints();
let mut result = RXingResult::new(
@@ -645,7 +645,7 @@ impl RSSExpandedReader {
let leftChar = self.decodeDataCharacter(
row,
pattern.as_ref().ok_or(Exceptions::notFound)?,
pattern.as_ref().ok_or(Exceptions::NOT_FOUND)?,
isOddPattern,
true,
)?;
@@ -653,16 +653,16 @@ impl RSSExpandedReader {
if !previousPairs.is_empty()
&& previousPairs
.last()
.ok_or(Exceptions::notFound)?
.ok_or(Exceptions::NOT_FOUND)?
.mustBeLast()
{
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let rightChar = self
.decodeDataCharacter(
row,
pattern.as_ref().ok_or(Exceptions::notFound)?,
pattern.as_ref().ok_or(Exceptions::NOT_FOUND)?,
isOddPattern,
false,
)
@@ -692,11 +692,11 @@ impl RSSExpandedReader {
} else if previousPairs.is_empty() {
rowOffset = 0;
} else {
let lastPair = previousPairs.last().ok_or(Exceptions::indexOutOfBounds)?;
let lastPair = previousPairs.last().ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
rowOffset = lastPair
.getFinderPattern()
.as_ref()
.ok_or(Exceptions::illegalState)?
.ok_or(Exceptions::ILLEGAL_STATE)?
.getStartEnd()[1] as i32;
}
let mut searchingEvenPair = previousPairs.len() % 2 != 0;
@@ -748,7 +748,7 @@ impl RSSExpandedReader {
isWhite = !isWhite;
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn reverseCounters(counters: &mut [u32]) {
@@ -845,7 +845,7 @@ impl RSSExpandedReader {
let expectedElementWidth: f32 =
(pattern.getStartEnd()[1] - pattern.getStartEnd()[0]) as f32 / 15.0;
if (elementWidth - expectedElementWidth).abs() / expectedElementWidth > 0.3 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
for (i, counter) in counters.iter().enumerate() {
@@ -854,12 +854,12 @@ impl RSSExpandedReader {
let mut count = (value + 0.5) as i32; // Round
if count < 1 {
if value < 0.3 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
count = 1;
} else if count > 8 {
if value > 8.7 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
count = 8;
}
@@ -899,7 +899,7 @@ impl RSSExpandedReader {
let checksumPortion = oddChecksumPortion + evenChecksumPortion;
if (oddSum & 0x01) != 0 || !(4..=13).contains(&oddSum) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let group = ((13 - oddSum) / 2) as usize;
@@ -947,12 +947,12 @@ impl RSSExpandedReader {
1 => {
if oddParityBad {
if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decrementOdd = true;
} else {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decrementEven = true;
}
@@ -960,12 +960,12 @@ impl RSSExpandedReader {
-1 => {
if oddParityBad {
if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
incrementOdd = true;
} else {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
incrementEven = true;
}
@@ -973,7 +973,7 @@ impl RSSExpandedReader {
0 => {
if oddParityBad {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// Both bad
if oddSum < evenSum {
@@ -984,16 +984,16 @@ impl RSSExpandedReader {
incrementEven = true;
}
} else if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
_ => return Err(Exceptions::notFound),
_ => return Err(Exceptions::NOT_FOUND),
}
if incrementOdd {
if decrementOdd {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Self::increment(&mut self.oddCounts, &self.oddRoundingErrors);
}
@@ -1002,7 +1002,7 @@ impl RSSExpandedReader {
}
if incrementEven {
if decrementEven {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Self::increment(&mut self.evenCounts, &self.oddRoundingErrors);
}

30
src/oned/rss/rss_14_reader.rs
View File

@@ -64,12 +64,12 @@ impl OneDReader for RSS14Reader {
if right.getCount() > 1 && self.checkChecksum(left, right) {
return self
.constructRXingResult(left, right)
.ok_or(Exceptions::illegalState);
.ok_or(Exceptions::ILLEGAL_STATE);
}
}
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
impl Reader for RSS14Reader {
@@ -123,7 +123,7 @@ impl Reader for RSS14Reader {
Ok(result)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
}
@@ -340,7 +340,7 @@ impl RSS14Reader {
if outsideChar {
if (oddSum & 0x01) != 0 || !(4..=12).contains(&oddSum) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let group = ((12 - oddSum) / 2) as usize;
let oddWidest = Self::OUTSIDE_ODD_WIDEST[group];
@@ -355,7 +355,7 @@ impl RSS14Reader {
))
} else {
if (evenSum & 0x01) != 0 || !(4..=10).contains(&evenSum) {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let group = ((10 - evenSum) / 2) as usize;
let oddWidest = Self::INSIDE_ODD_WIDEST[group];
@@ -414,7 +414,7 @@ impl RSS14Reader {
isWhite = !isWhite;
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
fn parseFoundFinderPattern(
@@ -511,12 +511,12 @@ impl RSS14Reader {
1 => {
if oddParityBad {
if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decrementOdd = true;
} else {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
decrementEven = true;
}
@@ -524,12 +524,12 @@ impl RSS14Reader {
-1 => {
if oddParityBad {
if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
incrementOdd = true;
} else {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
incrementEven = true;
}
@@ -537,7 +537,7 @@ impl RSS14Reader {
0 => {
if oddParityBad {
if !evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
// Both bad
if oddSum < evenSum {
@@ -548,15 +548,15 @@ impl RSS14Reader {
incrementEven = true;
}
} else if evenParityBad {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
_ => return Err(Exceptions::notFound),
_ => return Err(Exceptions::NOT_FOUND),
}
if incrementOdd {
if decrementOdd {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Self::increment(&mut self.oddCounts, &self.oddRoundingErrors);
}
@@ -565,7 +565,7 @@ impl RSS14Reader {
}
if incrementEven {
if decrementEven {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Self::increment(&mut self.evenCounts, &self.evenRoundingErrors);
}

2
src/oned/upc_a_reader.rs
View File

@@ -101,7 +101,7 @@ impl UPCAReader {
Ok(upcaRXingResult)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}
}

2
src/oned/upc_a_writer.rs
View File

@@ -48,7 +48,7 @@ impl Writer for UPCAWriter {
hints: &crate::EncodingHintDictionary,
) -> Result<crate::common::BitMatrix> {
if format != &BarcodeFormat::UPC_A {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Can only encode UPC-A, but got {format:?}"
)));
}

10
src/oned/upc_e_reader.rs
View File

@@ -50,7 +50,7 @@ impl UPCEANReader for UPCEReader {
while x < 6 && rowOffset < end {
let bestMatch = self.decodeDigit(row, &mut counters, rowOffset, &L_AND_G_PATTERNS)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
if bestMatch >= 10 {
@@ -67,7 +67,7 @@ impl UPCEANReader for UPCEReader {
fn checkChecksum(&self, s: &str) -> Result<bool> {
self.checkStandardUPCEANChecksum(
&convertUPCEtoUPCA(s).ok_or(Exceptions::IllegalArgumentException(None))?,
&convertUPCEtoUPCA(s).ok_or(Exceptions::ILLEGAL_ARGUMENT)?,
)
}
@@ -126,15 +126,15 @@ impl UPCEReader {
if lgPatternFound == Self::NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d] {
resultString.insert(
0,
char::from_u32('0' as u32 + numSys as u32).ok_or(Exceptions::parse)?,
char::from_u32('0' as u32 + numSys as u32).ok_or(Exceptions::PARSE)?,
);
resultString
.push(char::from_u32('0' as u32 + d as u32).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + d as u32).ok_or(Exceptions::PARSE)?);
return Ok(());
}
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}

22
src/oned/upc_e_writer.rs
View File

@@ -47,22 +47,22 @@ impl OneDimensionalCodeWriter for UPCEWriter {
// No check digit present, calculate it and add it
let check = reader.getStandardUPCEANChecksum(
&upc_e_reader::convertUPCEtoUPCA(&contents)
.ok_or(Exceptions::illegalArgument)?,
.ok_or(Exceptions::ILLEGAL_ARGUMENT)?,
)?;
contents.push_str(&check.to_string());
}
8 => {
if !reader.checkStandardUPCEANChecksum(
&upc_e_reader::convertUPCEtoUPCA(&contents)
.ok_or(Exceptions::illegalArgument)?,
.ok_or(Exceptions::ILLEGAL_ARGUMENT)?,
)? {
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"Contents do not pass checksum",
));
}
}
_ => {
return Err(Exceptions::illegalArgumentWith(format!(
return Err(Exceptions::illegal_argument_with(format!(
"Requested contents should be 7 or 8 digits long, but got {length}"
)))
}
@@ -73,11 +73,11 @@ impl OneDimensionalCodeWriter for UPCEWriter {
let firstDigit = contents
.chars()
.next()
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize; //Character.digit(contents.charAt(0), 10);
.ok_or(Exceptions::PARSE)? as usize; //Character.digit(contents.charAt(0), 10);
if firstDigit != 0 && firstDigit != 1 {
return Err(Exceptions::illegalArgumentWith(
return Err(Exceptions::illegal_argument_with(
"Number system must be 0 or 1",
));
}
@@ -85,9 +85,9 @@ impl OneDimensionalCodeWriter for UPCEWriter {
let checkDigit = contents
.chars()
.nth(7)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize; //Character.digit(contents.charAt(7), 10);
.ok_or(Exceptions::PARSE)? as usize; //Character.digit(contents.charAt(7), 10);
let parities = UPCEReader::NUMSYS_AND_CHECK_DIGIT_PATTERNS[firstDigit][checkDigit];
let mut result = [false; CODE_WIDTH];
@@ -99,9 +99,9 @@ impl OneDimensionalCodeWriter for UPCEWriter {
let mut digit = contents
.chars()
.nth(i)
.ok_or(Exceptions::indexOutOfBounds)?
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?
.to_digit(10)
.ok_or(Exceptions::parse)? as usize; //Character.digit(contents.charAt(i), 10);
.ok_or(Exceptions::PARSE)? as usize; //Character.digit(contents.charAt(i), 10);
if (parities >> (6 - i) & 1) == 1 {
digit += 10;
}

8
src/oned/upc_ean_extension_2_support.rs
View File

@@ -88,7 +88,7 @@ impl UPCEANExtension2Support {
&upc_ean_reader::L_AND_G_PATTERNS,
)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
@@ -104,16 +104,16 @@ impl UPCEANExtension2Support {
}
if resultString.chars().count() != 2 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
if resultString
.parse::<u32>()
.map_err(|e| Exceptions::parseWith(format!("could not parse {resultString}: {e}")))?
.map_err(|e| Exceptions::parse_with(format!("could not parse {resultString}: {e}")))?
% 4
!= checkParity
{
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Ok(rowOffset as u32)

10
src/oned/upc_ean_extension_5_support.rs
View File

@@ -87,7 +87,7 @@ impl UPCEANExtension5Support {
&upc_ean_reader::L_AND_G_PATTERNS,
)?;
resultString
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::parse)?);
.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).ok_or(Exceptions::PARSE)?);
rowOffset += counters.iter().sum::<u32>() as usize;
@@ -104,14 +104,14 @@ impl UPCEANExtension5Support {
}
if resultString.chars().count() != 5 {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let checkDigit = Self::determineCheckDigit(lgPatternFound)?;
if Self::extensionChecksum(resultString).ok_or(Exceptions::illegalArgument)?
if Self::extensionChecksum(resultString).ok_or(Exceptions::ILLEGAL_ARGUMENT)?
!= checkDigit as u32
{
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
Ok(rowOffset as u32)
@@ -146,7 +146,7 @@ impl UPCEANExtension5Support {
return Ok(d);
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/**

24
src/oned/upc_ean_reader.rs
View File

@@ -183,18 +183,18 @@ pub trait UPCEANReader: OneDReader {
let end = endRange[1];
let quietEnd = end + (end - endRange[0]);
if quietEnd >= row.getSize() || !row.isRange(end, quietEnd, false)? {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
let resultString = result;
// UPC/EAN should never be less than 8 chars anyway
if resultString.chars().count() < 8 {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
if !self.checkChecksum(&resultString)? {
return Err(Exceptions::checksum);
return Err(Exceptions::CHECKSUM);
}
let left = (startGuardRange[1] + startGuardRange[0]) as f32 / 2.0;
@@ -241,7 +241,7 @@ pub trait UPCEANReader: OneDReader {
}
}
if !valid {
return Err(Exceptions::notFound);
return Err(Exceptions::NOT_FOUND);
}
}
@@ -292,7 +292,7 @@ pub trait UPCEANReader: OneDReader {
let char_in_question = s
.chars()
.nth(length - 1)
.ok_or(Exceptions::indexOutOfBounds)?;
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)?;
let check = char_in_question.is_ascii_digit();
let check_against = &s[..length - 1]; //s.subSequence(0, length - 1);
@@ -300,7 +300,7 @@ pub trait UPCEANReader: OneDReader {
Ok(calculated_checksum
== if check {
char_in_question.to_digit(10).ok_or(Exceptions::parse)?
char_in_question.to_digit(10).ok_or(Exceptions::PARSE)?
} else {
u32::MAX
})
@@ -315,10 +315,10 @@ pub trait UPCEANReader: OneDReader {
let digit = (s
.chars()
.nth(i as usize)
.ok_or(Exceptions::indexOutOfBounds)? as i32)
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as i32)
- ('0' as i32);
if !(0..=9).contains(&digit) {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
sum += digit;
@@ -331,10 +331,10 @@ pub trait UPCEANReader: OneDReader {
let digit = (s
.chars()
.nth(i as usize)
.ok_or(Exceptions::indexOutOfBounds)? as i32)
.ok_or(Exceptions::INDEX_OUT_OF_BOUNDS)? as i32)
- ('0' as i32);
if !(0..=9).contains(&digit) {
return Err(Exceptions::format);
return Err(Exceptions::FORMAT);
}
sum += digit;
@@ -421,7 +421,7 @@ pub trait UPCEANReader: OneDReader {
}
}
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
/**
@@ -458,7 +458,7 @@ pub trait UPCEANReader: OneDReader {
if bestMatch >= 0 {
Ok(bestMatch as usize)
} else {
Err(Exceptions::notFound)
Err(Exceptions::NOT_FOUND)
}
}