react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/oned/ODITFReader.cpp

@@ -0,0 +1,97 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODITFReader.h"
+
+#include "ReaderOptions.h"
+#include "GTIN.h"
+#include "Barcode.h"
+#include "BarcodeData.h"
+#include "SymbologyIdentifier.h"
+#include "ZXAlgorithms.h"
+
+namespace ZXing::OneD {
+
+BarcodeData ITFReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+{
+	const int minCharCount = _opts.formats().size() == 1 ? 4 : 6; // if we are only looking for ITF, we accept shorter symbols
+	const int minQuietZone = 6; // spec requires 10
+
+	next = FindLeftGuard(next, 4 + 10 + 3, FixedPattern<4, 4>{1, 1, 1, 1}, minQuietZone);
+	if (!next.isValid())
+		return {};
+
+	// get threshold of first character pair
+	auto threshold = NarrowWideThreshold(next.subView(4, 10));
+	if (!threshold.isValid())
+		return {};
+	// check that each bar/space in the start pattern is < threshold
+	for (int i = 0; i < 4; ++i)
+		if (next[i] > threshold[i])
+			return {};
+
+	constexpr int weights[] = {1, 2, 4, 7, 0};
+	int xStart = next.pixelsInFront();
+	bool startsAtFirstBar = next.isAtFirstBar();
+
+	next = next.subView(4, 10);
+
+	std::string txt;
+	txt.reserve(20);
+
+	while (next.isValid()) {
+		// look for end-of-symbol
+		if (next[3] > threshold.space * 3)
+			break;
+
+		BarAndSpace<int> digits, numWide;
+		bool bad = false;
+		for (int i = 0; i < 10; ++i) {
+			bad |= next[i] > threshold[i] * 3 || next[i] < threshold[i] / 3;
+			numWide[i] += next[i] > threshold[i];
+			digits[i] += weights[i/2] * (next[i] > threshold[i]);
+		}
+
+		if (bad || numWide.bar != 2 || numWide.space != 2)
+			break;
+
+		for (int i = 0; i < 2; ++i)
+			txt.push_back(ToDigit(digits[i] == 11 ? 0 : digits[i]));
+
+		// update threshold to support scanning slanted symbols (scanned non-perpendicular)
+		threshold = NarrowWideThreshold(next);
+
+		next.skipSymbol();
+	}
+
+	next = next.subView(0, 3);
+
+	// Check stop pattern
+	if (!next.isValid() || !threshold.isValid()
+		|| next[0] < threshold[0] || next[1] > threshold[1] || next[2] > threshold[2])
+		return {};
+
+	// Check quiet zone size (full quiet zone on both ends or cropped on both ends)
+	if (!(std::min((int)next[3], xStart) > minQuietZone * (threshold.bar + threshold.space) / 3
+		  || (next.isAtLastBar() && startsAtFirstBar && std::max(xStart, (int)next[3]) < 2 * std::min(xStart, (int)next[3]) + 2)))
+		return {};
+
+	// Check min length depending on whether the code covers the complete image or not
+	if (Size(txt) < (startsAtFirstBar && next.isAtLastBar() ? (minCharCount / 2) : minCharCount))
+		return {};
+
+	Error error = _opts.validateOptionalChecksum() && !GTIN::IsCheckDigitValid(txt) ? ChecksumError() : Error();
+
+	// Symbology identifier ISO/IEC 16390:2007 Annex C Table C.1
+	// See also GS1 General Specifications 5.1.2 Figure 5.1.2-2
+	SymbologyIdentifier symbologyIdentifier = {'I', GTIN::IsCheckDigitValid(txt) ? '1' : '0'};
+	
+	int xStop = next.pixelsTillEnd();
+
+	return LinearBarcode(BarcodeFormat::ITF, txt, rowNumber, xStart, xStop, symbologyIdentifier, error);
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODITFReader.h

@@ -0,0 +1,33 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+* <p>Implements decoding of the ITF format, or Interleaved Two of Five.</p>
+*
+* <p>This Reader will scan ITF barcodes of certain lengths only.
+* At the moment it reads length >= 6. Not all lengths are scanned, especially shorter ones, to avoid false positives.
+* This in turn is due to a lack of required checksum function.</p>
+*
+* <p>According to the specification, the modifier (3rd char) of the symbologyIdentifier is '1' iff the symbol has a valid checksum</p>
+*
+* <p><a href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia.org/wiki/Interleaved_2_of_5</a>
+* is a great reference for Interleaved 2 of 5 information.</p>
+*/
+class ITFReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODITFWriter.cpp

@@ -0,0 +1,78 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODITFWriter.h"
+
+#include "ODWriterHelper.h"
+#include "Utf.h"
+
+#include <array>
+#include <stdexcept>
+#include <vector>
+
+namespace ZXing::OneD {
+
+static const std::array<int, 4> START_PATTERN = { 1, 1, 1, 1 };
+static const std::array<int, 3> END_PATTERN = { 3, 1, 1 };
+
+static const int W = 3; // Pixel width of a wide line
+static const int N = 1; // Pixed width of a narrow line
+
+/**
+* Patterns of Wide / Narrow lines to indicate each digit
+*/
+static const std::array<std::array<int, 5>, 10> PATTERNS = {
+	N, N, W, W, N, // 0
+	W, N, N, N, W, // 1
+	N, W, N, N, W, // 2
+	W, W, N, N, N, // 3
+	N, N, W, N, W, // 4
+	W, N, W, N, N, // 5
+	N, W, W, N, N, // 6
+	N, N, N, W, W, // 7
+	W, N, N, W, N, // 8
+	N, W, N, W, N,  // 9
+};
+
+BitMatrix
+ITFWriter::encode(const std::wstring& contents, int width, int height) const
+{
+	size_t length = contents.length();
+	if (length == 0) {
+		throw std::invalid_argument("Found empty contents");
+	}
+	if (length % 2 != 0) {
+		throw std::invalid_argument("The length of the input should be even");
+	}
+	if (length > 80) {
+		throw std::invalid_argument("Requested contents should be less than 80 digits long");
+	}
+
+	std::vector<bool> result(9 + 9 * length, false);
+	int pos = WriterHelper::AppendPattern(result, 0, START_PATTERN, true);
+	for (size_t i = 0; i < length; i += 2) {
+		int one = contents[i] - '0';
+		int two = contents[i + 1] - '0';
+		if (one < 0 || one > 9 || two < 0 || two > 9) {
+			throw std::invalid_argument("Contents should contain only digits: 0-9");
+		}
+		std::array<int, 10> encoding = {};
+		for (int j = 0; j < 5; j++) {
+			encoding[2 * j] = PATTERNS[one][j];
+			encoding[2 * j + 1] = PATTERNS[two][j];
+		}
+		pos += WriterHelper::AppendPattern(result, pos, encoding, true);
+	}
+	WriterHelper::AppendPattern(result, pos, END_PATTERN, true);
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 10);
+}
+
+BitMatrix ITFWriter::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODITFWriter.h

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace OneD {
+
+/**
+* This object renders a ITF code as a {@link BitMatrix}.
+*
+* @author erik.barbara@gmail.com (Erik Barbara)
+*/
+class ITFWriter
+{
+public:
+	ITFWriter& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; return *this; }
+	BitMatrix encode(const std::wstring& contents, int width, int height) const;
+	BitMatrix encode(const std::string& contents, int width, int height) const;
+
+private:
+	int _sidesMargin = -1;
+};
+
+} // OneD
+} // ZXing

package/cpp/zxing-core/core/src/oned/ODMultiUPCEANReader.cpp

@@ -0,0 +1,323 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODMultiUPCEANReader.h"
+
+#include "BarcodeFormat.h"
+#include "BitArray.h"
+#include "ReaderOptions.h"
+#include "GTIN.h"
+#include "ODUPCEANCommon.h"
+#include "Barcode.h"
+#include "JSON.h"
+#include "SymbologyIdentifier.h"
+
+#include <cmath>
+
+namespace ZXing::OneD {
+
+constexpr int CHAR_LEN = 4;
+
+constexpr auto END_PATTERN           = FixedPattern<3, 3>{1, 1, 1};
+constexpr auto MID_PATTERN           = FixedPattern<5, 5>{1, 1, 1, 1, 1};
+constexpr auto UPCE_END_PATTERN      = FixedPattern<6, 6>{1, 1, 1, 1, 1, 1};
+constexpr auto EXT_START_PATTERN     = FixedPattern<3, 4>{1, 1, 2};
+constexpr auto EXT_SEPARATOR_PATTERN = FixedPattern<2, 2>{1, 1};
+
+static const int FIRST_DIGIT_ENCODINGS[] = {0x00, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A};
+
+// The GS1 specification has the following to say about quiet zones
+// Type: EAN-13 | EAN-8 | UPC-A | UPC-E | EAN Add-on | UPC Add-on
+// QZ L:   11   |   7   |   9   |   9   |     7-12   |     9-12
+// QZ R:    7   |   7   |   9   |   7   |        5   |        5
+
+constexpr float QUIET_ZONE_LEFT = 6;
+constexpr float QUIET_ZONE_RIGHT_EAN = 3; // used to be 6, see #526 and #558
+constexpr float QUIET_ZONE_RIGHT_UPC = 6;
+constexpr float QUIET_ZONE_ADDON = 3;
+
+// There is a single sample (ean13-1/12.png) that fails to decode with these (new) settings because
+// it has a right-side quiet zone of only about 4.5 modules, which is clearly out of spec.
+
+static bool DecodeDigit(const PatternView& view, std::string& txt, int* lgPattern = nullptr)
+{
+#if 1
+	// These two values are critical for determining how permissive the decoding will be.
+	// We've arrived at these values through a lot of trial and error. Setting them any higher
+	// lets false positives creep in quickly.
+	static constexpr float MAX_AVG_VARIANCE = 0.48f;
+	static constexpr float MAX_INDIVIDUAL_VARIANCE = 0.7f;
+
+	int bestMatch =
+		lgPattern ? RowReader::DecodeDigit(view, UPCEANCommon::L_AND_G_PATTERNS, MAX_AVG_VARIANCE, MAX_INDIVIDUAL_VARIANCE, false)
+				  : RowReader::DecodeDigit(view, UPCEANCommon::L_PATTERNS, MAX_AVG_VARIANCE, MAX_INDIVIDUAL_VARIANCE, false);
+	if (bestMatch == -1)
+		return false;
+
+	txt += ToDigit(bestMatch % 10);
+	if (lgPattern)
+		AppendBit(*lgPattern, bestMatch >= 10);
+
+	return true;
+#else
+	constexpr int CHAR_SUM = 7;
+	auto pattern = RowReader::OneToFourBitPattern<CHAR_LEN, CHAR_SUM>(view);
+
+	// remove first and last bit
+	pattern = (~pattern >> 1) & 0b11111;
+
+	// clang-format off
+/* pattern now contains the central 5 bits of the L/G/R code
+ * L/G-codes always start with 1 and end with 0, R-codes are simply
+ * inverted L-codes.
+
+		L-Code  G-Code  R-Code
+	___________________________________
+	0 	00110 	10011 	11001
+	1 	01100 	11001 	10011
+	2 	01001 	01101 	10110
+	3 	11110 	10000 	00001
+	4 	10001 	01110 	01110
+	5 	11000 	11100 	00111
+	6 	10111 	00010 	01000
+	7 	11101 	01000 	00010
+	8 	11011 	00100 	00100
+	9 	00101 	01011 	11010
+*/
+	constexpr char I = 0xf0; // invalid pattern
+
+	const char digit[] = {I,    I,    0x16, I,    0x18, 0x09, 0x00, I,
+                          0x17, 0x02, I,    0x19, 0x01, 0x12, 0x14, I,
+                          0x13, 0x04, I,    0x10, I,    I,    I,    0x06,
+                          0x05, 0x11, I,    0x08, 0x15, 0x07, 0x03, I};
+	// clang-format on
+
+	char d = digit[pattern];
+	txt += ToDigit(d & 0xf);
+	if (lgPattern)
+		AppendBit(*lgPattern, (d >> 4) & 1);
+
+	return d != I;
+#endif
+}
+
+static bool DecodeDigits(int digitCount, PatternView& next, std::string& txt, int* lgPattern = nullptr)
+{
+	for (int j = 0; j < digitCount; ++j, next.skipSymbol())
+		if (!DecodeDigit(next, txt, lgPattern))
+			return false;
+	return true;
+}
+
+struct PartialResult
+{
+	std::string txt;
+	PatternView end;
+	BarcodeFormat format = BarcodeFormat::None;
+
+	PartialResult() { txt.reserve(14); }
+	bool isValid() const { return format != BarcodeFormat::None; }
+};
+
+bool _ret_false_debug_helper()
+{
+	return false;
+}
+#define CHECK(A) if(!(A)) return _ret_false_debug_helper();
+
+static bool EAN13(PartialResult& res, PatternView begin)
+{
+	auto mid = begin.subView(27, MID_PATTERN.size());
+	auto end = begin.subView(56, END_PATTERN.size());
+
+	CHECK(IsRightGuard(end, END_PATTERN, QUIET_ZONE_RIGHT_EAN) && IsPattern(mid, MID_PATTERN));
+
+	auto next = begin.subView(END_PATTERN.size(), CHAR_LEN);
+	res.txt = " "; // make space for lgPattern character
+	int lgPattern = 0;
+
+	CHECK(DecodeDigits(6, next, res.txt, &lgPattern));
+
+	next = next.subView(MID_PATTERN.size(), CHAR_LEN);
+
+	CHECK(DecodeDigits(6, next, res.txt));
+
+	int i = IndexOf(FIRST_DIGIT_ENCODINGS, lgPattern);
+	CHECK(i != -1);
+	res.txt[0] = ToDigit(i);
+
+	res.end = end;
+	res.format = BarcodeFormat::EAN13;
+	return true;
+}
+
+static bool PlausibleDigitModuleSize(PatternView begin, int start, int i, float moduleSizeRef)
+{
+	float moduleSizeData = begin.subView(start + i * 4, 4).sum() / 7.f;
+	return std::abs(moduleSizeData / moduleSizeRef - 1) < 0.2f;
+}
+
+static bool EAN8(PartialResult& res, PatternView begin)
+{
+	auto mid = begin.subView(19, MID_PATTERN.size());
+	auto end = begin.subView(40, END_PATTERN.size());
+
+	CHECK(IsRightGuard(end, END_PATTERN, QUIET_ZONE_RIGHT_EAN) && IsPattern(mid, MID_PATTERN));
+
+	// additional plausibility check for the module size: it has to be about the same for both
+	// the guard patterns and the payload/data part.
+	float moduleSizeGuard = (begin.sum() + mid.sum() + end.sum()) / 11.f;
+	for (auto start : {3, 24})
+		for (int i = 0; i < 4; ++i)
+			CHECK(PlausibleDigitModuleSize(begin, start, i, moduleSizeGuard));
+
+	auto next = begin.subView(END_PATTERN.size(), CHAR_LEN);
+	res.txt.clear();
+
+	CHECK(DecodeDigits(4, next, res.txt));
+
+	next = next.subView(MID_PATTERN.size(), CHAR_LEN);
+
+	CHECK(DecodeDigits(4, next, res.txt));
+
+	res.end = end;
+	res.format = BarcodeFormat::EAN8;
+	return true;
+}
+
+static bool UPCE(PartialResult& res, PatternView begin)
+{
+	auto end = begin.subView(27, UPCE_END_PATTERN.size());
+
+	CHECK(IsRightGuard(end, UPCE_END_PATTERN, QUIET_ZONE_RIGHT_UPC));
+
+	// additional plausibility check for the module size: it has to be about the same for both
+	// the guard patterns and the payload/data part. This speeds up the falsepositives use case
+	// about 2x and brings the misread count down to 0
+	float moduleSizeGuard = (begin.sum() + end.sum()) / 9.f;
+	for (int i = 0; i < 6; ++i)
+		CHECK(PlausibleDigitModuleSize(begin, 3, i, moduleSizeGuard));
+
+	auto next = begin.subView(END_PATTERN.size(), CHAR_LEN);
+	int lgPattern = 0;
+	res.txt = " "; // make space for lgPattern character
+
+	CHECK(DecodeDigits(6, next, res.txt, &lgPattern));
+
+	int i = IndexOf(UPCEANCommon::NUMSYS_AND_CHECK_DIGIT_PATTERNS, lgPattern);
+	CHECK(i != -1);
+
+	res.txt[0] = ToDigit(i / 10);
+	res.txt += ToDigit(i % 10);
+
+	res.end = end;
+	res.format = BarcodeFormat::UPCE;
+	return true;
+}
+
+static int Ean5Checksum(const std::string& s)
+{
+	int sum = 0, N = Size(s);
+	for (int i = N - 2; i >= 0; i -= 2)
+		sum += s[i] - '0';
+	sum *= 3;
+	for (int i = N - 1; i >= 0; i -= 2)
+		sum += s[i] - '0';
+	sum *= 3;
+	return sum % 10;
+}
+
+static bool AddOn(PartialResult& res, PatternView begin, int digitCount)
+{
+	auto ext = begin.subView(0, 3 + digitCount * 4 + (digitCount - 1) * 2);
+	CHECK(ext.isValid());
+	auto moduleSize = IsPattern(ext, EXT_START_PATTERN);
+	CHECK(moduleSize);
+
+	CHECK(ext.isAtLastBar() || *ext.end() > QUIET_ZONE_ADDON * moduleSize - 1);
+
+	res.end = ext;
+	ext = ext.subView(EXT_START_PATTERN.size(), CHAR_LEN);
+	int lgPattern = 0;
+	res.txt.clear();
+
+	for (int i = 0; i < digitCount; ++i) {
+		CHECK(DecodeDigit(ext, res.txt, &lgPattern));
+		ext.skipSymbol();
+		if (i < digitCount - 1) {
+			CHECK(IsPattern(ext, EXT_SEPARATOR_PATTERN, 0, 0, moduleSize));
+			ext.skipPair();
+		}
+	}
+
+	if (digitCount == 2) {
+		CHECK(std::stoi(res.txt) % 4 == lgPattern);
+	} else {
+		constexpr int CHECK_DIGIT_ENCODINGS[] = {0x18, 0x14, 0x12, 0x11, 0x0C, 0x06, 0x03, 0x0A, 0x09, 0x05};
+		CHECK(Ean5Checksum(res.txt) == IndexOf(CHECK_DIGIT_ENCODINGS, lgPattern));
+	}
+	res.format = BarcodeFormat::EANUPC; // make sure res.format is valid, see below
+	return true;
+}
+
+BarcodeData MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+{
+	const int minSize = 3 + 6*4 + 6; // UPC-E
+
+	next = FindLeftGuard(next, minSize, END_PATTERN, QUIET_ZONE_LEFT);
+	if (!next.isValid())
+		return {};
+
+	PartialResult res;
+	auto begin = next;
+
+	if (!((((readEAN13 || readUPCA) && EAN13(res, begin)) || (readEAN8 && EAN8(res, begin)) || (readUPCE && UPCE(res, begin)))))
+		return {};
+
+	// ISO/IEC 15420:2009 (& GS1 General Specifications 5.1.3) states that the content for "]E0" should be 13 digits,
+	// i.e. converted to EAN-13 if UPC-A/E
+	std::string upceTxt;
+	if (res.format == BarcodeFormat::UPCE) {
+		upceTxt = res.txt;
+		res.txt = "0" + UPCEANCommon::ConvertUPCEtoUPCA(res.txt);
+	}
+
+	Error error = !GTIN::IsCheckDigitValid(res.txt) ? ChecksumError() : Error();
+
+	// if we explicitly excluded EAN13, don't return an EAN13 symbol
+	if (res.format == BarcodeFormat::EAN13 && !readEAN13) {
+		if (res.txt.front() == '0')
+			res.format = BarcodeFormat::UPCA;
+		else
+			return {};
+	}
+
+	// Symbology identifier modifiers ISO/IEC 15420:2009 Annex B Table B.1
+	SymbologyIdentifier symbologyIdentifier = {'E', res.format == BarcodeFormat::EAN8 ? '4' : '0'};
+
+	next = res.end;
+
+	auto ext = res.end;
+	PartialResult addOnRes;
+	if (_opts.eanAddOnSymbol() != EanAddOnSymbol::Ignore && ext.skipSymbol()
+		&& ext.skipSingle(static_cast<int>(begin.sum() * 3.5)) && (AddOn(addOnRes, ext, 5) || AddOn(addOnRes, ext, 2))) {
+		res.txt += addOnRes.txt;
+		next = addOnRes.end;
+		// ISO/IEC 15420:2009 states that the content for "]E3" should be 15 or 18 digits, i.e. converted to EAN-13
+		// and extended with no separator, and that the content for "]E4" should be 8 digits, i.e. no add-on
+		// @gitlost and @axxel decided to extend the spec here to simply add an EAN-8 + add-on option
+		symbologyIdentifier.modifier = '3'; // Combined packet, EAN-13, UPC-A, UPC-E, with add-on
+	}
+
+	if (_opts.eanAddOnSymbol() == EanAddOnSymbol::Require && !addOnRes.isValid())
+		return {};
+
+	return LinearBarcode(res.format, res.txt, rowNumber, begin.pixelsInFront(), next.pixelsTillEnd(), symbologyIdentifier, error,
+						 JsonProp(BarcodeExtra::UPCE, upceTxt) + JsonProp(BarcodeExtra::EanAddOn, addOnRes.txt));
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODMultiUPCEANReader.h

@@ -0,0 +1,32 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+* @brief A reader that can read all available UPC/EAN formats.
+*/
+class MultiUPCEANReader : public RowReader
+{
+	bool readEAN8, readEAN13, readUPCA, readUPCE;
+public:
+	explicit MultiUPCEANReader(const ReaderOptions& opts)
+		: RowReader(opts),
+		  readEAN8(opts.hasFormat(BarcodeFormat::EAN8)),
+		  readEAN13(opts.hasFormat(BarcodeFormat::EAN13)),
+		  readUPCA(opts.hasFormat(BarcodeFormat::UPCA)),
+		  readUPCE(opts.hasFormat(BarcodeFormat::UPCE))
+	{}
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD
+