1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/*
* Copyright 2011 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::collections::HashMap;
use crate::{
common::{BitMatrix, Result},
BarcodeFormat, EncodeHintType, EncodeHintValue, Exceptions, Writer,
};
use once_cell::sync::Lazy;
use regex::Regex;
pub static NUMERIC: Lazy<Regex> = Lazy::new(|| Regex::new("[0-9]+").unwrap());
/**
* <p>Encapsulates functionality and implementation that is common to one-dimensional barcodes.</p>
*
* @author dsbnatut@gmail.com (Kazuki Nishiura)
*/
pub trait OneDimensionalCodeWriter: Writer {
// private static final Pattern NUMERIC = Pattern.compile("[0-9]+");
/**
* Encode the contents to boolean array expression of one-dimensional barcode.
* Start code and end code should be included in result, and side margins should not be included.
*
* @param contents barcode contents to encode
* @return a {@code boolean[]} of horizontal pixels (false = white, true = black)
*/
fn encode_oned(&self, contents: &str) -> Result<Vec<bool>>;
/**
* Can be overwritten if the encode requires to read the hints map. Otherwise it defaults to {@code encode}.
* @param contents barcode contents to encode
* @param hints encoding hints
* @return a {@code boolean[]} of horizontal pixels (false = white, true = black)
*/
fn encode_oned_with_hints(
&self,
contents: &str,
_hints: &crate::EncodingHintDictionary,
) -> Result<Vec<bool>> {
self.encode_oned(contents)
}
fn getSupportedWriteFormats(&self) -> Option<Vec<BarcodeFormat>> {
None
}
/**
* @return a byte array of horizontal pixels (0 = white, 1 = black)
*/
fn renderRXingResult(
code: &[bool],
width: i32,
height: i32,
sidesMargin: u32,
) -> Result<BitMatrix> {
let inputWidth = code.len();
// Add quiet zone on both sides.
let fullWidth = inputWidth + sidesMargin as usize;
let outputWidth = width.max(fullWidth as i32);
let outputHeight = 1.max(height);
let multiple = outputWidth as usize / fullWidth;
let leftPadding = (outputWidth as isize - (inputWidth as isize * multiple as isize)) / 2;
let mut output = BitMatrix::new(outputWidth as u32, outputHeight as u32)?;
let mut inputX = 0;
let mut outputX = leftPadding;
while inputX < inputWidth {
if code[inputX] {
output.setRegion(outputX as u32, 0, multiple as u32, outputHeight as u32)?;
}
inputX += 1;
outputX += multiple as isize;
}
Ok(output)
}
/**
* @param contents string to check for numeric characters
* @throws IllegalArgumentException if input contains characters other than digits 0-9.
*/
fn checkNumeric(contents: &str) -> Result<()> {
if !NUMERIC.is_match(contents) {
Err(Exceptions::illegal_argument_with(
"Input should only contain digits 0-9",
))
} else {
Ok(())
}
}
/**
* @param target encode black/white pattern into this array
* @param pos position to start encoding at in {@code target}
* @param pattern lengths of black/white runs to encode
* @param startColor starting color - false for white, true for black
* @return the number of elements added to target.
*/
fn appendPattern<T: TryInto<usize> + Copy>(
target: &mut [bool],
pos: usize,
pattern: &[T],
startColor: bool,
) -> u32 {
let mut color = startColor;
let mut numAdded = 0;
let mut pos = pos;
for len in pattern {
for _j in 0..TryInto::<usize>::try_into(*len).unwrap_or_default() {
target[pos] = color;
pos += 1;
}
numAdded += TryInto::<usize>::try_into(*len).unwrap_or_default();
color = !color; // flip color after each segment
}
numAdded as u32
}
fn getDefaultMargin(&self) -> u32 {
// CodaBar spec requires a side margin to be more than ten times wider than narrow space.
// This seems like a decent idea for a default for all formats.
10
}
}
struct L;
impl Writer for L {
fn encode(
&self,
contents: &str,
format: &crate::BarcodeFormat,
width: i32,
height: i32,
) -> Result<crate::common::BitMatrix> {
self.encode_with_hints(contents, format, width, height, &HashMap::new())
}
fn encode_with_hints(
&self,
contents: &str,
format: &crate::BarcodeFormat,
width: i32,
height: i32,
hints: &crate::EncodingHintDictionary,
) -> Result<crate::common::BitMatrix> {
if contents.is_empty() {
return Err(Exceptions::illegal_argument_with("Found empty contents"));
}
if width < 0 || height < 0 {
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::illegal_argument_with(format!(
"Can only encode {supportedFormats:?}, but got {format:?}"
)));
}
}
let mut sidesMargin = self.getDefaultMargin();
if let Some(EncodeHintValue::Margin(margin)) = hints.get(&EncodeHintType::MARGIN) {
sidesMargin = margin.parse::<u32>().map_err(|e| {
Exceptions::illegal_argument_with(format!("couldnt parse {margin}: {e}"))
})?;
}
let code = self.encode_oned_with_hints(contents, hints)?;
Self::renderRXingResult(&code, width, height, sidesMargin)
}
}
impl OneDimensionalCodeWriter for L {
fn encode_oned(&self, _contents: &str) -> Result<Vec<bool>> {
unimplemented!()
}
}