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

package/cpp/zxing-core/core/src/BarcodeFormat.cpp

@@ -0,0 +1,286 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BarcodeFormat.h"
+
+#include "Version.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+
+namespace ZXing {
+
+// =================================== BarcodeFormat =================================
+
+static_assert(ZX_BCF_ID('\0', '\0') == 0, "BarcodeFormat encoding error");
+
+BarcodeFormat Symbology(BarcodeFormat format)
+{
+	return BarcodeFormat(ZX_BCF_ID(SymbologyKey(format), ' ' * (VariantKey(format) != 0)));
+}
+
+std::string_view Name(BarcodeFormat format)
+{
+	switch (format) {
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) \
+	case BarcodeFormat(ZX_BCF_ID(SYM, VAR)): return HRI;
+		ZX_BCF_LIST(X)
+#undef X
+	default: return "Unknown";
+	};
+}
+
+BarcodeFormat BarcodeFormatFromString(std::string_view str)
+{
+	if (str.size() < 3)
+		throw std::invalid_argument(StrCat("This is not a valid barcode format: '", str, "'"));
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) \
+	if ((str[0] == ']' && str[1] == SYM && str[2] == VAR) || IsEqualIgnoreCase(str, #NAME) || IsEqualIgnoreCaseAnd(str, HRI, " -_/")) \
+		return BarcodeFormat(ZX_BCF_ID(SYM, VAR));
+	ZX_BCF_LIST(X)
+#undef X
+	throw std::invalid_argument(StrCat("This is not a valid barcode format: '", str, "'"));
+}
+
+std::string ToString(BarcodeFormat format)
+{
+	return std::string(Name(format));
+}
+
+bool operator<=(BarcodeFormat e, BarcodeFormat s)
+{
+	return e == s || s == BarcodeFormat::All
+		   || (SymbologyKey(s) == '*' ? SymbologyKey(e) != '*' && (e & s)
+									  : SymbologyKey(s) == SymbologyKey(e) && VariantKey(s) == ' ');
+}
+
+bool operator&(BarcodeFormat a, BarcodeFormat b)
+{
+	if (SymbologyKey(a) == '*' && SymbologyKey(b) == '*') {
+		switch (VariantKey(a)) {
+		case 'l': return ZXING_ENABLE_1D && !Contains("smp", VariantKey(b));
+		case 's': return ZXING_ENABLE_PDF417 && !Contains("lmp", VariantKey(b));
+		case 'p': return !Contains("lms", VariantKey(b)); // TODO: postal codes
+		case 'm':
+			return (ZXING_ENABLE_MAXICODE || ZXING_ENABLE_QRCODE || ZXING_ENABLE_DATAMATRIX || ZXING_ENABLE_AZTEC)
+				   && !Contains("lsp", VariantKey(b));
+		default: return true;
+		}
+	}
+
+	if (SymbologyKey(a) == '*')
+		std::swap(a, b);
+
+	if (SymbologyKey(b) == '*') {
+		char vkb = VariantKey(b);
+		if (vkb == '*')
+			return true;
+
+		switch (a) {
+#ifdef ZXING_USE_ZINT
+#define USING_ZINT 1
+#else
+#define USING_ZINT 0
+#endif
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) \
+	case BarcodeFormat(ZX_BCF_ID(SYM, VAR)): \
+		return ENABLED \
+			   && ((vkb == 'w' && USING_ZINT) ? ZINT : (FLAGS[0] == vkb || FLAGS[1] == vkb || FLAGS[2] == vkb || FLAGS[3] == vkb || FLAGS[4] == vkb));
+			ZX_BCF_LIST(X)
+#undef X
+		};
+	}
+
+	if (a == b || Symbology(a) == b || a == Symbology(b))
+		return true;
+
+	return false;
+}
+
+// ==================================== BarcodeFormats =================================
+
+inline bool operator<(BarcodeFormat a, BarcodeFormat b)
+{
+	return SymbologyKey(a) < SymbologyKey(b) || (SymbologyKey(a) == SymbologyKey(b) && VariantKey(a) < VariantKey(b));
+}
+
+void BarcodeFormats::normalize()
+{
+	std::erase_if(formats_, [](BarcodeFormat t) { return t == BarcodeFormat::None; });
+	std::sort(formats_.begin(), formats_.end());
+	formats_.erase(std::unique(formats_.begin(), formats_.end()), formats_.end());
+}
+
+BarcodeFormats::BarcodeFormats(std::string_view str)
+{
+	while (str.size() >= 3 && str[0] == ']') {
+		formats_.push_back(BarcodeFormat(ZX_BCF_ID(str[1], str[2])));
+		str.remove_prefix(3);
+	}
+
+	ForEachToken(TrimWS(str, " []"), ",|", [this](std::string_view token) {
+		if (!token.empty())
+			formats_.push_back(BarcodeFormatFromString(token));
+	});
+
+	normalize();
+}
+
+BarcodeFormats BarcodeFormats::list(const BarcodeFormats& filter)
+{
+	std::vector<BarcodeFormat> res;
+	res.reserve(100);
+	if (filter.empty()) {
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) \
+		if (ENABLED) \
+			res.push_back(BarcodeFormat(ZX_BCF_ID(SYM, VAR)));
+		ZX_BCF_LIST(X)
+#undef X
+		return res;
+	}
+	for (auto f : filter) {
+		// printf("Filter for: %s\n", IdStr(f).c_str());
+#define X(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) \
+	if (ENABLED && SYM != '*' \
+		&& (SymbologyKey(f) == '*' ? BarcodeFormat(ZX_BCF_ID(SYM, VAR)) & f \
+								   : SYM == SymbologyKey(f) && (VariantKey(f) == ' ' || VariantKey(f) == VAR))) \
+		res.push_back(BarcodeFormat(ZX_BCF_ID(SYM, VAR))); //, printf("adding: %c %c\n", SYM, VAR);
+		ZX_BCF_LIST(X)
+#undef X
+		// printf("N: %d\n", (int)res.size());
+	}
+	return res;
+}
+
+// BarcodeFormats&& BarcodeFormats::operator|(BarcodeFormat bt) &&
+// {
+// 	types_.push_back(bt);
+// 	normalize();
+// 	return std::move(*this);
+// }
+
+// BarcodeFormats&& BarcodeFormats::operator|(const BarcodeFormats& other) &&
+// {
+// 	types_.insert(std::end(types_), other.begin(), other.end());
+// 	normalize();
+// 	return std::move(*this);
+// }
+
+BarcodeFormats BarcodeFormats::operator&(const BarcodeFormats& other)
+{
+	std::vector<BarcodeFormat> res;
+	for (auto l : formats_)
+		for (auto r : other.formats_)
+			if (l <= r)
+				res.push_back(l);
+			else if (r <= l)
+				res.push_back(r);
+	return res;
+}
+
+BarcodeFormats BarcodeFormatsFromString(std::string_view str)
+{
+	return BarcodeFormats(str);
+}
+
+std::string ToString(const BarcodeFormats& formats)
+{
+	if (formats.empty())
+		return {};
+	std::string res;
+	for (auto f : formats)
+		res += std::string(Name(f)) + ", ";
+	return res.substr(0, res.size() - 2);
+}
+
+} // namespace ZXing
+
+#if 0
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BarcodeFormat.h"
+
+#include "ZXAlgorithms.h"
+
+#include <iterator>
+#include <stdexcept>
+
+namespace ZXing {
+
+struct BarcodeFormatName
+{
+	BarcodeFormat format;
+	std::string_view name;
+};
+
+static const BarcodeFormatName NAMES[] = {
+	{BarcodeFormat::None, "None"},
+	{BarcodeFormat::Aztec, "Aztec"},
+	{BarcodeFormat::Codabar, "Codabar"},
+	{BarcodeFormat::Code39, "Code39"},
+	{BarcodeFormat::Code93, "Code93"},
+	{BarcodeFormat::Code128, "Code128"},
+	{BarcodeFormat::DataBar, "DataBar"},
+	{BarcodeFormat::DataBarExpanded, "DataBarExpanded"},
+	{BarcodeFormat::DataBarLimited, "DataBarLimited"},
+	{BarcodeFormat::DataMatrix, "DataMatrix"},
+	{BarcodeFormat::DXFilmEdge, "DXFilmEdge"},
+	{BarcodeFormat::EAN8, "EAN-8"},
+	{BarcodeFormat::EAN13, "EAN-13"},
+	{BarcodeFormat::ITF, "ITF"},
+	{BarcodeFormat::MaxiCode, "MaxiCode"},
+	{BarcodeFormat::MicroPDF417, "MicroPDF417"},
+	{BarcodeFormat::MicroQRCode, "MicroQRCode"},
+	{BarcodeFormat::PDF417, "PDF417"},
+	{BarcodeFormat::QRCode, "QRCode"},
+	{BarcodeFormat::RMQRCode, "rMQRCode"},
+	{BarcodeFormat::UPCA, "UPC-A"},
+	{BarcodeFormat::UPCE, "UPC-E"},
+	{BarcodeFormat::LinearCodes, "Linear-Codes"},
+	{BarcodeFormat::MatrixCodes, "Matrix-Codes"},
+};
+
+std::string ToString(BarcodeFormat format)
+{
+	auto i = FindIf(NAMES, [format](auto& v) { return v.format == format; });
+	return i == std::end(NAMES) ? std::string() : std::string(i->name);
+}
+
+std::string ToString(BarcodeFormats formats)
+{
+	if (formats.empty())
+		return ToString(BarcodeFormat::None);
+	std::string res;
+	for (auto f : formats)
+		res += ToString(f) + "|";
+	return res.substr(0, res.size() - 1);
+}
+
+BarcodeFormat BarcodeFormatFromString(std::string_view str)
+{
+	auto i = FindIf(NAMES, [str](auto& v) { return IsEqualIgnoreCaseAnd(v.name, str, "_-"); });
+	return i == std::end(NAMES) ? BarcodeFormat::None : i->format;
+}
+
+BarcodeFormats BarcodeFormatsFromString(std::string_view str)
+{
+	BarcodeFormats res;
+	ForEachToken(TrimWS(str, " []"), " ,|", [&res](std::string_view token) {
+		if (!token.empty()) {
+			auto bc = BarcodeFormatFromString(token);
+			if (bc == BarcodeFormat::None)
+				throw std::invalid_argument("This is not a valid barcode format: '" + std::string(token) + "'");
+			res |= bc;
+		}
+	});
+	return res;
+}
+
+} // ZXing
+#endif // 0

package/cpp/zxing-core/core/src/BarcodeFormat.h

@@ -0,0 +1,272 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Version.h"
+
+#include <stdint.h>
+
+// FLAGS[0]: l == linear, m == matrix
+// FLAGS[1]: r == readable
+// FLAGS[2]: w == writable (MultiformatWriter))
+// FLAGS[3]: G == GS1
+// FLAGS[4]: R == Retail, I == Industrial, O == Other
+
+// clang-format off
+//    NAME,             SYM, VAR,  FLAGS, ZINT, ENABLED,                 HRI
+#define ZX_BCF_LIST(X) \
+	X(None,              0 ,  0,  "     ",   0, 1,                       "None") \
+	X(All,              '*', '*', "     ",   0, 1,                       "All") \
+	X(AllReadable,      '*', 'r', "     ",   0, 1,                       "All Readable") \
+	X(AllCreatable,     '*', 'w', "     ",   0, 1,                       "All Creatable") \
+	X(AllLinear,        '*', 'l', "     ",   0, 1,                       "All Linear") \
+	X(AllMatrix,        '*', 'm', "     ",   0, 1,                       "All Matrix") \
+	X(AllGS1,           '*', 'G', "     ",   0, 1,                       "All GS1") \
+	X(AllRetail,        '*', 'R', "     ",   0, 1,                       "All Retail") \
+	X(AllIndustrial,    '*', 'I', "     ",   0, 1,                       "All Industrial") \
+	X(Codabar,          'F', ' ', "lrw  ",  18, ZXING_ENABLE_1D,         "Codabar") \
+	X(Code39,           'A', ' ', "lrw I",   8, ZXING_ENABLE_1D,         "Code 39") \
+	X(Code39Std,        'A', 's', "lrw I",   8, ZXING_ENABLE_1D,         "Code 39 Standard") \
+	X(Code39Ext,        'A', 'e', "lr  I",   9, ZXING_ENABLE_1D,         "Code 39 Extended") \
+	X(Code32,           'A', '2', "lr  I", 129, ZXING_ENABLE_1D,         "Code 32") \
+	X(PZN,              'A', 'p', "lr  I",  52, ZXING_ENABLE_1D,         "Pharmazentralnummer") \
+	X(Code93,           'G', ' ', "lrw I",  25, ZXING_ENABLE_1D,         "Code 93") \
+	X(Code128,          'C', ' ', "lrwGI",  20, ZXING_ENABLE_1D,         "Code 128") \
+	X(ITF,              'I', ' ', "lrw I",   3, ZXING_ENABLE_1D,         "ITF") \
+	X(ITF14,            'I', '4', "lr  I",  89, ZXING_ENABLE_1D,         "ITF-14") \
+	X(DataBar,          'e', ' ', "lr GR",  29, ZXING_ENABLE_1D,         "DataBar") \
+	X(DataBarOmni,      'e', 'o', "lr GR",  29, ZXING_ENABLE_1D,         "DataBar Omni") \
+	X(DataBarStk,       'e', 's', "lr GR",  79, ZXING_ENABLE_1D,         "DataBar Stacked") \
+	X(DataBarStkOmni,   'e', 'O', "lr GR",  80, ZXING_ENABLE_1D,         "DataBar Stacked Omni") \
+	X(DataBarLtd,       'e', 'l', "lr GR",  30, ZXING_ENABLE_1D,         "DataBar Limited") \
+	X(DataBarExp,       'e', 'e', "lr GR",  31, ZXING_ENABLE_1D,         "DataBar Expanded") \
+	X(DataBarExpStk,    'e', 'E', "lr GR",  81, ZXING_ENABLE_1D,         "DataBar Expanded Stacked") \
+	X(EANUPC,           'E', ' ', "lr  R",  15, ZXING_ENABLE_1D,         "EAN/UPC") \
+	X(EAN13,            'E', '1', "lrw R",  15, ZXING_ENABLE_1D,         "EAN-13") \
+	X(EAN8,             'E', '8', "lrw R",  10, ZXING_ENABLE_1D,         "EAN-8") \
+	X(EAN5,             'E', '5', "l   R",  12, ZXING_ENABLE_1D,         "EAN-5") \
+	X(EAN2,             'E', '2', "l   R",  11, ZXING_ENABLE_1D,         "EAN-2") \
+	X(ISBN,             'E', 'i', "lr  R",  69, ZXING_ENABLE_1D,         "ISBN") \
+	X(UPCA,             'E', 'a', "lrw R",  34, ZXING_ENABLE_1D,         "UPC-A") \
+	X(UPCE,             'E', 'e', "lrw R",  37, ZXING_ENABLE_1D,         "UPC-E") \
+	X(Telepen,          'B', ' ', "lr  I",  32, ZXING_ENABLE_1D,         "Telepen") \
+	X(TelepenAlpha,     'B', '0', "lr  I",  32, ZXING_ENABLE_1D,         "Telepen Alpha") \
+	X(TelepenNumeric,   'B', '1', "lr  I",  87, ZXING_ENABLE_1D,         "Telepen Numeric") \
+	X(OtherBarcode,     'X', ' ', " r   ",   0, ZXING_ENABLE_1D,         "Other barcode") /* see ISO/IEC 15424:2025 */ \
+	X(DXFilmEdge,       'X', 'x', "lr   ", 147, ZXING_ENABLE_1D,         "DX Film Edge") \
+	X(PDF417,           'L', ' ', "mrw  ",  55, ZXING_ENABLE_PDF417,     "PDF417") \
+	X(CompactPDF417,    'L', 'c', "mr   ",  56, ZXING_ENABLE_PDF417,     "Compact PDF417") \
+	X(MicroPDF417,      'L', 'm', "mr   ",  84, ZXING_ENABLE_PDF417,     "MicroPDF417") \
+	X(Aztec,            'z', ' ', "mrwG ",  92, ZXING_ENABLE_AZTEC,      "Aztec") \
+	X(AztecCode,        'z', 'c', "mrwG ",  92, ZXING_ENABLE_AZTEC,      "Aztec Code") \
+	X(AztecRune,        'z', 'r', "mr   ", 128, ZXING_ENABLE_AZTEC,      "Aztec Rune") \
+	X(QRCode,           'Q', ' ', "mrwG ",  58, ZXING_ENABLE_QRCODE,     "QR Code") \
+	X(QRCodeModel1,     'Q', '1', "mr   ",   0, ZXING_ENABLE_QRCODE,     "QR Code Model 1") \
+	X(QRCodeModel2,     'Q', '2', "mrw  ",  58, ZXING_ENABLE_QRCODE,     "QR Code Model 2") \
+	X(MicroQRCode,      'Q', 'm', "mr   ",  97, ZXING_ENABLE_QRCODE,     "Micro QR Code") \
+	X(RMQRCode,         'Q', 'r', "mr G ", 145, ZXING_ENABLE_QRCODE,     "rMQR Code") \
+	X(DataMatrix,       'd', ' ', "mrwG ",  71, ZXING_ENABLE_DATAMATRIX, "Data Matrix") \
+	X(MaxiCode,         'U', ' ', "mr   ",  57, ZXING_ENABLE_MAXICODE,   "MaxiCode") \
+	/* Add new formats here */
+// clang-format on
+
+#define ZX_BCF_ID(SYM, VAR) (((uint8_t)(SYM) << 0) | ((uint8_t)(VAR) << 8))
+
+#ifdef __cplusplus
+
+#include <array>
+#include <algorithm>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace ZXing {
+
+/**
+ * @brief Enumerates barcode formats known to this package.
+ *
+ * Some formats represent a symbology (e.g. EANUPC) with multiple variants (EAN13, EAN8, etc.), while others represent a specific
+ * symbology variant (e.g. MicroQRCode). Both can be used with ReaderOptions::formats() to select which formats to read/scan for, but
+ * only specific variants are returned by the library when reading barcodes.
+ *
+ * If the format name starts with "All", it is a pseudo-format representing a set of formats (e.g. AllLinear, AllGS1, etc.). These can
+ * be used for filtering and selection purposes, but are not returned by the library when reading barcodes and can not be used when
+ * creating barcodes.
+ */
+enum class BarcodeFormat : unsigned int
+{
+#define ZX_(NAME, SYM, VAR, FLAGS, ZINT, ENABLED, HRI) NAME = ZX_BCF_ID(SYM, VAR),
+	ZX_BCF_LIST(ZX_)
+#undef ZX_
+	/// @cond DEPRECATED
+	DataBarExpanded [[deprecated("Use DataBarExp instead")]] = DataBarExp,
+	DataBarLimited [[deprecated("Use DataBarLtd instead")]] = DataBarLtd,
+	LinearCodes [[deprecated("Use AllLinear instead")]] = AllLinear,
+	MatrixCodes [[deprecated("Use AllMatrix instead")]] = AllMatrix,
+	Any [[deprecated("Use All instead")]] = All,
+	/// @endcond
+};
+
+/// @cond INTERNAL
+inline char SymbologyKey(const BarcodeFormat& format)
+{
+	return uint32_t(format) & 0xFF;
+}
+
+inline char VariantKey(const BarcodeFormat& format)
+{
+	return (uint32_t(format) >> 8) & 0xFF;
+}
+
+inline std::string IdStr(const BarcodeFormat& format)
+{
+	return {']', SymbologyKey(format), VariantKey(format)};
+}
+/// @endcond
+
+/// Returns the symbology (base type) of the given barcode format (e.g. EAN/UPC for EAN13, EAN8, UPCA, etc.).
+BarcodeFormat Symbology(BarcodeFormat format);
+
+/// Returns the human-readable name of the given barcode format.
+std::string_view Name(BarcodeFormat format);
+
+/// Test if left hand side (e == element) is 'inside' right hand side (s == set) (e.g. MicroQRCode <= QRCode).
+bool operator<=(BarcodeFormat e, BarcodeFormat s);
+
+/// Test if the two BarcodeFormats have a non-empty intersection (e.g. AllMatrix & QRCode).
+bool operator&(BarcodeFormat a, BarcodeFormat b);
+
+template <std::size_t N>
+using BarcodeFormatArray = std::array<BarcodeFormat, N>;
+
+constexpr BarcodeFormatArray<2> operator|(BarcodeFormat a, BarcodeFormat b)
+{
+	return {a, b};
+}
+
+template <std::size_t N>
+constexpr BarcodeFormatArray<N + 1> operator|(BarcodeFormatArray<N> bts, BarcodeFormat bt)
+{
+	BarcodeFormatArray<N + 1> ret{};
+	for (std::size_t i = 0; i < N; ++i)
+		ret[i] = bts[i];
+	ret[N] = bt;
+	return ret;
+}
+
+template <std::size_t N>
+constexpr bool operator&(BarcodeFormat lhs, const BarcodeFormatArray<N>& rhs)
+{
+	return std::any_of(rhs.begin(), rhs.end(), [lhs](BarcodeFormat bt) { return lhs & bt; });
+}
+
+/// @brief Parse a string into a BarcodeFormat. '-', '_', '/' and ' ' are optional.
+/// @throws std::invalid_parameter if the string can not be fully parsed.
+BarcodeFormat BarcodeFormatFromString(std::string_view str);
+
+std::string ToString(BarcodeFormat format);
+
+/**
+ * @brief A small container representing a collection of BarcodeFormat values.
+ *
+ * BarcodeFormats encapsulates an ordered collection of BarcodeFormat values and
+ * provides convenient construction, iteration, and set-like operations.
+ *
+ * General behavior and invariants:
+ * - The internal representation is kept in a canonical form (sorted, no duplicates)
+ *   using normalize().
+ * - The API exposes read-only access and iteration.
+ */
+class BarcodeFormats
+{
+	std::vector<BarcodeFormat> formats_;
+
+	void normalize();
+
+public:
+	BarcodeFormats() = default;
+	BarcodeFormats(BarcodeFormat f) : formats_{f} {}
+
+	/// @brief Constructs a collection from a compile-time array of BarcodeFormat values.
+	/// ```c++
+	/// BarcodeFormats formats = BarcodeFormat::QRCode | BarcodeFormat::EAN13;
+	/// ```
+	template <std::size_t N>
+	BarcodeFormats(BarcodeFormatArray<N> formats) : formats_{formats.begin(), formats.end()}
+	{
+		normalize();
+	}
+
+	BarcodeFormats(std::vector<BarcodeFormat>&& formats) : formats_(std::move(formats)) { normalize(); }
+
+	/// Constructs a collection from a textual representation (e.g. a comma-separated list of format identifiers).
+	explicit BarcodeFormats(std::string_view str);
+
+	BarcodeFormats(const BarcodeFormats&) = default;
+	BarcodeFormats(BarcodeFormats&&) = default;
+	BarcodeFormats& operator=(const BarcodeFormats&) = default;
+	BarcodeFormats& operator=(BarcodeFormats&&) = default;
+	bool operator==(const BarcodeFormats& o) const noexcept { return formats_ == o.formats_; }
+	bool operator!=(const BarcodeFormats& o) const noexcept { return !(*this == o); }
+	// ~BarcodeFormats() = default;
+
+	auto begin() const noexcept { return formats_.cbegin(); }
+	auto end() const noexcept { return formats_.cend(); }
+
+	using value_type = typename std::vector<BarcodeFormat>::value_type;
+	using pointer = typename std::vector<BarcodeFormat>::pointer;
+	auto data() const noexcept { return formats_.data(); }
+
+	bool empty() const noexcept { return formats_.empty(); }
+	int size() const noexcept { return static_cast<int>(formats_.size()); }
+
+	// BarcodeFormats&& operator|(BarcodeFormat bt) &&;
+	// BarcodeFormats&& operator|(const BarcodeFormats& other) &&;
+
+	/// Returns a BarcodeFormats containing the intersection of this collection and other.
+	BarcodeFormats operator&(const BarcodeFormats& other);
+
+	/// Returns a list of available/supported barcode formats, optionally filtered by the provided formats.
+	/// e.g. `BarcodeFormats::list(BarcodeFormat::AllReadable);`
+	static BarcodeFormats list(const BarcodeFormats& filter = {});
+
+	/// @cond DEPRECATED
+	[[deprecated]] inline int count() const noexcept { return size(); }
+	[[deprecated]] inline bool testFlag(BarcodeFormat format) const noexcept
+	{
+		return std::any_of(begin(), end(), [format](BarcodeFormat f) { return f & format; });
+	}
+	[[deprecated]] inline bool testFlags(const BarcodeFormats& formats) const noexcept
+	{
+		return std::any_of(begin(), end(), [formats](BarcodeFormat fo) {
+			return std::any_of(formats.begin(), formats.end(), [fo](BarcodeFormat fi) { return fo & fi; });
+		});
+	}
+	/// @endcond
+};
+
+inline bool operator<=(BarcodeFormat lhs, const BarcodeFormats& rhs)
+{
+	return std::any_of(rhs.begin(), rhs.end(), [lhs](BarcodeFormat bf) { return lhs <= bf; });
+}
+
+inline bool operator&(BarcodeFormat lhs, const BarcodeFormats& rhs)
+{
+	return std::any_of(rhs.begin(), rhs.end(), [lhs](BarcodeFormat bf) { return lhs & bf; });
+}
+
+/// @brief Parses a string into a set of BarcodeFormats.
+/// Separators can be (any combination of) '|' or ','. Input can be lower case and any of '-', '_', '/' or ' ' are optional,
+/// e.g. "EAN-8 | qrcode, Itf" would be parsed into [EAN8, QRCode, ITF].
+/// @throws std::invalid_parameter if the string can not be fully parsed.
+BarcodeFormats BarcodeFormatsFromString(std::string_view str);
+
+std::string ToString(const BarcodeFormats& formats);
+
+} // namespace ZXing
+
+#endif // __cplusplus

package/cpp/zxing-core/core/src/BinaryBitmap.cpp

@@ -0,0 +1,111 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BinaryBitmap.h"
+
+#include "BitMatrix.h"
+
+namespace ZXing {
+
+struct BinaryBitmap::Cache
+{
+	std::shared_ptr<const BitMatrix> matrix, transposed;
+};
+
+BitMatrix BinaryBitmap::binarize(const uint8_t threshold) const
+{
+	BitMatrix res(width(), height());
+
+	if (_buffer.pixStride() == 1 && _buffer.rowStride() == _buffer.width()) {
+		// Specialize for a packed buffer with pixStride 1 to support auto vectorization (16x speedup on AVX2)
+		auto dst = res.row(0).begin();
+		for (auto src = _buffer.data(0, 0), end = _buffer.data(0, height()); src != end; ++src, ++dst)
+			*dst = (*src <= threshold) * BitMatrix::SET_V;
+	} else {
+		auto processLine = [&res, threshold](int y, const auto* src, const int stride) {
+			for (auto& dst : res.row(y)) {
+				dst = (*src <= threshold) * BitMatrix::SET_V;
+				src += stride;
+			}
+		};
+		for (int y = 0; y < res.height(); ++y) {
+			auto src = _buffer.data(0, y) + GreenIndex(_buffer.format());
+			// Specialize the inner loop for strides 1 and 4 to support auto vectorization
+			switch (_buffer.pixStride()) {
+			case 1: processLine(y, src, 1); break;
+			case 4: processLine(y, src, 4); break;
+			default: processLine(y, src, _buffer.pixStride()); break;
+			}
+		}
+	}
+
+	return res;
+}
+
+BinaryBitmap::BinaryBitmap(const ImageView& buffer) : _cache(new Cache), _buffer(buffer) {}
+
+BinaryBitmap::~BinaryBitmap() = default;
+
+const BitMatrix* BinaryBitmap::getBitMatrix(bool transposed) const
+{
+	if (!_cache->matrix) {
+		_cache->matrix = getBlackMatrix();
+	}
+	if (transposed) {
+		if (!_cache->transposed) {
+			auto copy = std::make_shared<BitMatrix>(_cache->matrix->copy());
+			copy->rotate90();
+			_cache->transposed = std::move(copy);
+		}
+		return _cache->transposed.get();
+	}
+	return _cache->matrix.get();
+}
+
+void BinaryBitmap::invert()
+{
+	if (_cache->matrix)
+		const_cast<BitMatrix*>(_cache->matrix.get())->flipAll();
+
+	if (_cache->transposed)
+		const_cast<BitMatrix*>(_cache->transposed.get())->flipAll();
+
+	_inverted = !_inverted;
+}
+
+template <typename F>
+void SumFilter(const BitMatrix& in, BitMatrix& out, F func)
+{
+	assert(in.height() >= 3);
+
+	const auto* in0 = in.row(0).begin();
+	const auto* in1 = in.row(1).begin();
+	const auto* in2 = in.row(2).begin();
+
+	for (auto *out1 = out.row(1).begin() + 1, *end = out.row(out.height() - 1).begin() - 1; out1 != end; ++in0, ++in1, ++in2, ++out1) {
+		int sum = 0;
+		for (int j = 0; j < 3; ++j)
+			sum += in0[j] + in1[j] + in2[j];
+
+		*out1 = func(sum);
+	}
+}
+
+void BinaryBitmap::close()
+{
+	if (_cache->matrix) {
+		auto& matrix = *const_cast<BitMatrix*>(_cache->matrix.get());
+		BitMatrix tmp(matrix.width(), matrix.height());
+
+		// dilate
+		SumFilter(matrix, tmp, [](int sum) { return (sum > 0 * BitMatrix::SET_V) * BitMatrix::SET_V; });
+		// erode
+		SumFilter(tmp, matrix, [](int sum) { return (sum == 9 * BitMatrix::SET_V) * BitMatrix::SET_V; });
+	}
+	_cache->transposed.reset();
+	_closed = true;
+}
+
+} // ZXing