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

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

@@ -0,0 +1,92 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Content.h"
+#include "Error.h"
+#include "JSON.h"
+#include "StructuredAppend.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace ZXing {
+
+struct CustomData
+{
+	virtual ~CustomData() = default;
+};
+
+class DecoderResult
+{
+	Content _content;
+	std::string _ecLevel;
+	int _lineCount = 0;
+	int _versionNumber = 0;
+	StructuredAppendInfo _structuredAppend;
+	bool _isMirrored = false;
+	bool _readerInit = false;
+	Error _error;
+	std::string _json;
+	std::shared_ptr<CustomData> _customData;
+
+public:
+	DecoderResult() = default;
+	DecoderResult(Error error) : _error(std::move(error)) {}
+	DecoderResult(Content&& bytes) : _content(std::move(bytes)) {}
+
+	DecoderResult(DecoderResult&&) noexcept = default;
+	DecoderResult& operator=(DecoderResult&&) noexcept = default;
+
+	DecoderResult(const DecoderResult&) = delete;
+	DecoderResult& operator=(const DecoderResult&) = delete;
+
+	bool isValid(bool includeErrors = false) const
+	{
+		return (!_content.bytes.empty() && !_error) || (includeErrors && !!_error);
+	}
+
+	const Content& content() const & { return _content; }
+	Content&& content() && { return std::move(_content); }
+
+	// to keep the unit tests happy for now:
+	std::wstring text() const { return _content.utfW(); }
+	std::string symbologyIdentifier() const { return _content.symbology.toString(false); }
+
+	// Simple macro to set up getter/setter methods that save lots of boilerplate.
+	// It sets up a standard 'const & () const', 2 setters for setting lvalues via
+	// copy and 2 for setting rvalues via move. They are provided each to work
+	// either on lvalues (normal 'void (...)') or on rvalues (returning '*this' as
+	// rvalue). The latter can be used to optionally initialize a temporary in a
+	// return statement, e.g.
+	//    return DecoderResult(bytes, text).setEcLevel(level);
+#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
+	const TYPE& GETTER() const & { return _##GETTER; } \
+	TYPE&& GETTER() && { return std::move(_##GETTER); } \
+	void SETTER(const TYPE& v) & { _##GETTER = v; } \
+	void SETTER(TYPE&& v) & { _##GETTER = std::move(v); } \
+	DecoderResult&& SETTER(const TYPE& v) && { _##GETTER = v; return std::move(*this); } \
+	DecoderResult&& SETTER(TYPE&& v) && { _##GETTER = std::move(v); return std::move(*this); }
+
+	ZX_PROPERTY(std::string, ecLevel, setEcLevel)
+	ZX_PROPERTY(int, lineCount, setLineCount)
+	ZX_PROPERTY(int, versionNumber, setVersionNumber)
+	ZX_PROPERTY(StructuredAppendInfo, structuredAppend, setStructuredAppend)
+	ZX_PROPERTY(Error, error, setError)
+	ZX_PROPERTY(bool, isMirrored, setIsMirrored)
+	ZX_PROPERTY(bool, readerInit, setReaderInit)
+	ZX_PROPERTY(std::string, json, setJson)
+	ZX_PROPERTY(std::shared_ptr<CustomData>, customData, setCustomData)
+#undef ZX_PROPERTY
+
+	template<typename T>
+	DecoderResult&& addExtra(std::string_view key, T val, T ignore = {}) { _json += JsonProp(key, val, ignore); return std::move(*this); }
+
+};
+
+} // ZXing

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

@@ -0,0 +1,44 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrix.h"
+#include "Quadrilateral.h"
+
+#include <utility>
+
+namespace ZXing {
+
+/**
+* Encapsulates the result of detecting a barcode in an image. This includes the raw
+* matrix of black/white pixels corresponding to the barcode and the position of the code
+* in the input image.
+*/
+class DetectorResult
+{
+	BitMatrix _bits;
+	QuadrilateralI _position;
+
+public:
+	DetectorResult() = default;
+	DetectorResult(DetectorResult&&) noexcept = default;
+	DetectorResult& operator=(DetectorResult&&) noexcept = default;
+
+	DetectorResult(const DetectorResult&) = delete;
+	DetectorResult& operator=(const DetectorResult&) = delete;
+
+	DetectorResult(BitMatrix&& bits, QuadrilateralI&& position) : _bits(std::move(bits)), _position(std::move(position)) {}
+
+	const BitMatrix& bits() const & { return _bits; }
+	BitMatrix&& bits() && { return std::move(_bits); }
+	const QuadrilateralI& position() const & { return _position; }
+	QuadrilateralI&& position() && { return std::move(_position); }
+
+	bool isValid() const { return !_bits.empty(); }
+};
+
+} // ZXing

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

@@ -0,0 +1,81 @@
+/*
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ECI.h"
+
+#include "ZXAlgorithms.h"
+
+#include <map>
+
+namespace ZXing {
+
+static const std::map<ECI, CharacterSet> ECI_TO_CHARSET = {
+	{ECI(0), CharacterSet::Cp437},     // Obsolete
+	{ECI(1), CharacterSet::ISO8859_1}, // Obsolete
+	{ECI::Cp437, CharacterSet::Cp437}, // Obsolete but still used by PDF417 Macro fields (ISO/IEC 15438:2015 Annex H.2.3)
+	{ECI::ISO8859_1, CharacterSet::ISO8859_1},
+	{ECI::ISO8859_2, CharacterSet::ISO8859_2},
+	{ECI::ISO8859_3, CharacterSet::ISO8859_3},
+	{ECI::ISO8859_4, CharacterSet::ISO8859_4},
+	{ECI::ISO8859_5, CharacterSet::ISO8859_5},
+	{ECI::ISO8859_6, CharacterSet::ISO8859_6},
+	{ECI::ISO8859_7, CharacterSet::ISO8859_7},
+	{ECI::ISO8859_8, CharacterSet::ISO8859_8},
+	{ECI::ISO8859_9, CharacterSet::ISO8859_9},
+	{ECI::ISO8859_10, CharacterSet::ISO8859_10},
+	{ECI::ISO8859_11, CharacterSet::ISO8859_11},
+	{ECI::ISO8859_13, CharacterSet::ISO8859_13},
+	{ECI::ISO8859_14, CharacterSet::ISO8859_14},
+	{ECI::ISO8859_15, CharacterSet::ISO8859_15},
+	{ECI::ISO8859_16, CharacterSet::ISO8859_16},
+	{ECI::Shift_JIS, CharacterSet::Shift_JIS},
+	{ECI::Cp1250, CharacterSet::Cp1250},
+	{ECI::Cp1251, CharacterSet::Cp1251},
+	{ECI::Cp1252, CharacterSet::Cp1252},
+	{ECI::Cp1256, CharacterSet::Cp1256},
+	{ECI::UTF8, CharacterSet::UTF8},
+	{ECI::UTF16BE, CharacterSet::UTF16BE},
+	{ECI::UTF16LE, CharacterSet::UTF16LE},
+	{ECI::UTF32BE, CharacterSet::UTF32BE},
+	{ECI::UTF32LE, CharacterSet::UTF32LE},
+	{ECI::ASCII, CharacterSet::ASCII},
+	{ECI::Big5, CharacterSet::Big5},
+	{ECI::GB18030, CharacterSet::GB18030},
+	{ECI::GB2312, CharacterSet::GB2312},
+	{ECI::EUC_KR, CharacterSet::EUC_KR},
+	{ECI::ISO646_Inv, CharacterSet::ASCII},
+	{ECI::Binary, CharacterSet::BINARY},
+};
+
+std::string ToString(ECI eci)
+{
+	return '\\' + ToString(ToInt(eci), 6);
+}
+
+CharacterSet ToCharacterSet(ECI eci)
+{
+	if (auto it = ECI_TO_CHARSET.find(eci); it != ECI_TO_CHARSET.end())
+		return it->second;
+
+	return CharacterSet::Unknown;
+}
+
+ECI ToECI(CharacterSet cs)
+{
+	// Special case ISO8859_1 to avoid obsolete ECI 1
+	if (cs == CharacterSet::ISO8859_1)
+		return ECI::ISO8859_1;
+	// Special case Cp437 to avoid obsolete ECI 0 for slightly less obsolete ECI 2
+	if (cs == CharacterSet::Cp437)
+		return ECI::Cp437;
+
+	for (auto& [key, value] : ECI_TO_CHARSET)
+		if (value == cs)
+			return key;
+
+	return ECI::Unknown;
+}
+
+} // namespace ZXing

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

@@ -0,0 +1,78 @@
+/*
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "CharacterSet.h"
+
+#include <string>
+
+namespace ZXing {
+
+enum class ECI : int
+{
+	Unknown    = -1,
+	Cp437      = 2, // obsolete
+	ISO8859_1  = 3,
+	ISO8859_2  = 4,
+	ISO8859_3  = 5,
+	ISO8859_4  = 6,
+	ISO8859_5  = 7,
+	ISO8859_6  = 8,
+	ISO8859_7  = 9,
+	ISO8859_8  = 10,
+	ISO8859_9  = 11,
+	ISO8859_10 = 12,
+	ISO8859_11 = 13,
+	ISO8859_13 = 15,
+	ISO8859_14 = 16,
+	ISO8859_15 = 17,
+	ISO8859_16 = 18,
+	Shift_JIS  = 20,
+	Cp1250     = 21,
+	Cp1251     = 22,
+	Cp1252     = 23,
+	Cp1256     = 24,
+	UTF16BE    = 25,
+	UTF8       = 26,
+	ASCII      = 27,
+	Big5       = 28,
+	GB2312     = 29,
+	EUC_KR     = 30,
+	GB18030    = 32,
+	UTF16LE    = 33,
+	UTF32BE    = 34,
+	UTF32LE    = 35,
+	ISO646_Inv = 170,
+	Binary     = 899
+};
+
+inline constexpr int ToInt(ECI eci)
+{
+	return static_cast<int>(eci);
+}
+
+inline constexpr bool IsText(ECI eci)
+{
+	return ToInt(eci) >= 0 && ToInt(eci) <= 170;
+}
+
+inline constexpr bool CanProcess(ECI eci)
+{
+	// see https://github.com/zxing-cpp/zxing-cpp/commit/d8587545434d533c4e568181e1c12ef04a8e42d9#r74864359
+	return ToInt(eci) <= 899;
+}
+
+/**
+ * @brief ToString converts the numerical ECI value to a 7 character string as used in the ECI protocol
+ * @return e.g. "\000020"
+ */
+std::string ToString(ECI eci);
+
+CharacterSet ToCharacterSet(ECI eci);
+
+ECI ToECI(CharacterSet cs);
+
+} // namespace ZXing

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2022 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "Error.h"
+
+namespace ZXing {
+
+std::string Error::location() const
+{
+	if (!_file)
+		return {};
+	std::string file(_file);
+	return file.substr(file.find_last_of("/\\") + 1) + ":" + std::to_string(_line);
+}
+
+std::string ToString(const Error& e)
+{
+	const char* name[] = {"", "FormatError", "ChecksumError", "Unsupported"};
+	std::string ret = name[static_cast<int>(e.type())];
+	if (!e.msg().empty())
+		ret += " (" + e.msg() + ")";
+	if (auto location = e.location(); !location.empty())
+		ret += " @ " + e.location();
+	return ret;
+}
+
+}

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2022 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+namespace ZXing {
+
+/**
+ * @brief The Error class is a value type for the error() member of Barcode
+ *
+ * The use-case of this class is to communicate whether or not a particular Barcode
+ * symbol is in error. It is (primarily) not meant to be thrown as an exception and
+ * therefore not derived from std::exception. The library code may throw (and catch!)
+ * objects of this class as a convenient means of flow control (c++23's std::expected
+ * will allow to replace those use-cases with something similarly convenient). In
+ * those situations, the author is advised to make sure any thrown Error object is
+ * caught before leaking into user/wrapper code, i.e. the functions of the public
+ * API should be considered `noexcept` with respect to this class.
+ */
+
+class Error
+{
+public:
+	enum class Type : uint8_t
+	{
+		None,       ///< No error
+		Format,     ///< Format error (i.e. the decoded data is not valid for the detected symbology)
+		Checksum,   ///< Checksum error (i.e. the decoded data does not pass the checksum validation)
+		Unsupported ///< Unsupported error (i.e. a particular feature detected is not supported by zxing-cpp)
+	};
+	Type type() const noexcept { return _type; }
+	const std::string& msg() const noexcept { return _msg; }
+	explicit operator bool() const noexcept { return _type != Type::None; }
+
+	/// The source code location where the error was detected (if available)
+	std::string location() const;
+
+	Error() = default;
+	Error(Type type, std::string msg = {}) : _msg(std::move(msg)), _type(type) {}
+	Error(const char* file, short line, Type type, std::string msg = {}) : _msg(std::move(msg)), _file(file), _line(line), _type(type) {}
+
+	static constexpr auto Format = Type::Format;
+	static constexpr auto Checksum = Type::Checksum;
+	static constexpr auto Unsupported = Type::Unsupported;
+
+	inline bool operator==(const Error& o) const noexcept
+	{
+		return _type == o._type && _msg == o._msg && _file == o._file && _line == o._line;
+	}
+	inline bool operator!=(const Error& o) const noexcept { return !(*this == o); }
+
+protected:
+	/// @cond INTERNAL
+	std::string _msg;
+	const char* _file = nullptr;
+	short _line = -1;
+	Type _type = Type::None;
+	/// @endcond
+};
+
+/// @cond INTERNAL
+inline bool operator==(const Error& e, Error::Type t) noexcept { return e.type() == t; }
+inline bool operator!=(const Error& e, Error::Type t) noexcept { return !(e == t); }
+inline bool operator==(Error::Type t, const Error& e) noexcept { return e.type() == t; }
+inline bool operator!=(Error::Type t, const Error& e) noexcept { return !(t == e); }
+
+#define FormatError(...) Error(__FILE__, __LINE__, Error::Format, std::string(__VA_ARGS__))
+#define ChecksumError(...) Error(__FILE__, __LINE__, Error::Checksum, std::string(__VA_ARGS__))
+#define UnsupportedError(...) Error(__FILE__, __LINE__, Error::Unsupported, std::string(__VA_ARGS__))
+/// @endcond
+
+std::string ToString(const Error& e);
+
+}

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

@@ -0,0 +1,165 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+#include <version>
+#ifdef __cpp_lib_bitops
+#include <bit>
+#else
+namespace std {
+template <class T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+constexpr int popcount(T x) noexcept
+{
+	int n = 0;
+	for (; x; ++n)
+		x &= x - 1; // clear lowest bit
+	return n;
+}
+
+template <class T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+constexpr int countr_zero(T x) noexcept
+{
+	if (x == 0)
+		return std::numeric_limits<T>::digits;
+
+	int n = 0;
+	while ((x & T(1)) == 0) {
+		x >>= 1;
+		++n;
+	}
+	return n;
+}
+
+template <class T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
+constexpr int countl_zero(T x) noexcept
+{
+	if (x == 0)
+		return std::numeric_limits<T>::digits;
+
+	int n = 0;
+	for (int i = std::numeric_limits<T>::digits; i-- && !(x & (T(1) << i)); ++n)
+		;
+	return n;
+}
+} // namespace std
+#endif
+
+namespace ZXing {
+
+template<typename Enum>
+class Flags
+{
+	static_assert(std::is_enum<Enum>::value, "Flags is only usable on enumeration types.");
+
+	using Int = std::make_unsigned_t<typename std::underlying_type<Enum>::type>;
+	Int i = 0;
+
+	constexpr inline Flags(Int other) : i(other) {}
+
+	constexpr static inline auto highestBitSet(Int x) noexcept
+	{
+		return std::numeric_limits<Int>::digits - 1 - std::countl_zero(x);
+	}
+
+public:
+	using enum_type = Enum;
+
+	constexpr inline Flags() noexcept = default;
+	constexpr inline Flags(Enum flag) noexcept : i(Int(flag)) {}
+
+//	constexpr inline Flags(std::initializer_list<Enum> flags) noexcept
+//		: i(initializer_list_helper(flags.begin(), flags.end()))
+//	{}
+
+	class iterator
+	{
+		friend class Flags;
+		const Int _flags = 0;
+		int _pos = 0;
+		iterator(Int i, int p) : _flags(i), _pos(p) {}
+	public:
+		using iterator_category = std::input_iterator_tag;
+		using value_type = Enum;
+		using difference_type = std::ptrdiff_t;
+		using pointer = Enum*;
+		using reference = Enum&;
+
+		Enum operator*() const noexcept { return Enum(Int(1) << _pos); }
+
+		iterator& operator++() noexcept
+		{
+			while (++_pos < highestBitSet(_flags) && !((Int(1) << _pos) & _flags))
+				;
+			return *this;
+		}
+
+		bool operator==(const iterator& rhs) const noexcept { return _pos == rhs._pos; }
+		bool operator!=(const iterator& rhs) const noexcept { return !(*this == rhs); }
+	};
+
+	iterator begin() const noexcept { return {i, std::countr_zero(i)}; }
+	iterator end() const noexcept { return {i, highestBitSet(i) + 1}; }
+
+	bool empty() const noexcept { return i == 0; }
+	int count() const noexcept { return std::popcount(i); }
+
+	constexpr inline bool operator==(Flags other) const noexcept { return i == other.i; }
+
+	inline Flags& operator&=(Flags mask) noexcept { return i &= mask.i, *this; }
+	inline Flags& operator&=(Enum mask) noexcept { return i &= Int(mask), *this; }
+	inline Flags& operator|=(Flags other) noexcept { return i |= other.i, *this; }
+	inline Flags& operator|=(Enum other) noexcept { return i |= Int(other), *this; }
+//	inline Flags &operator^=(Flags other) noexcept { return i ^= other.i, *this; }
+//	inline Flags &operator^=(Enum other) noexcept { return i ^= Int(other), *this; }
+
+	constexpr inline Flags operator&(Flags other) const noexcept { return i & other.i; }
+	constexpr inline Flags operator&(Enum other) const noexcept { return i & Int(other); }
+	constexpr inline Flags operator|(Flags other) const noexcept { return i | other.i; }
+	constexpr inline Flags operator|(Enum other) const noexcept { return i | Int(other); }
+//	constexpr inline Flags operator^(Flags other) const noexcept { return i ^ other.i; }
+//	constexpr inline Flags operator^(Enum other) const noexcept { return i ^ Int(other); }
+//	constexpr inline Flags operator~() const noexcept { return ~i; }
+
+//	constexpr inline operator Int() const noexcept { return i; }
+//	constexpr inline bool operator!() const noexcept { return !i; }
+//	constexpr inline Int asInt() const noexcept { return i; }
+
+	constexpr inline bool testFlag(Enum flag) const noexcept
+	{
+		return (i & Int(flag)) == Int(flag) && (Int(flag) != 0 || i == Int(flag));
+	}
+	constexpr inline bool testFlags(Flags mask) const noexcept { return i & mask.i; }
+	inline Flags& setFlag(Enum flag, bool on = true) noexcept
+	{
+		return on ? (*this |= flag) : (*this &= ~Int(flag));
+	}
+	inline void clear() noexcept { i = 0; }
+
+	constexpr static Flags all() noexcept { return ~(Int(~0) << highestBitSet(Int(Enum::_max))); }
+
+private:
+//	constexpr static inline Int
+//	initializer_list_helper(typename std::initializer_list<Enum>::const_iterator it,
+//							typename std::initializer_list<Enum>::const_iterator end) noexcept
+//	{
+//		return (it == end ? Int(0) : (Int(*it) | initializer_list_helper(it + 1, end)));
+//	}
+};
+
+#define ZX_DECLARE_FLAGS(FLAGS, ENUM) \
+	using FLAGS = Flags<ENUM>; \
+	constexpr inline FLAGS operator|(FLAGS::enum_type e1, FLAGS::enum_type e2) noexcept { return FLAGS(e1) | e2; } \
+	constexpr inline FLAGS operator|(FLAGS::enum_type e, FLAGS f) noexcept { return f | e; } \
+	constexpr inline bool operator==(FLAGS::enum_type e, FLAGS f) noexcept { return FLAGS(e) == f; } \
+	constexpr inline bool operator==(FLAGS f, FLAGS::enum_type e) noexcept { return FLAGS(e) == f; }
+
+} // ZXing
+