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

package/cpp/zxing-core/core/src/datamatrix/DMHighLevelEncoder.h

@@ -0,0 +1,29 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2006-2007 Jeremias Maerki.
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "CharacterSet.h"
+
+#include <string>
+
+namespace ZXing {
+
+class ByteArray;
+
+namespace DataMatrix {
+
+enum class SymbolShape;
+
+/**
+* DataMatrix ECC 200 data encoder following the algorithm described in ISO/IEC 16022:200(E) in
+* annex S.
+*/
+ByteArray Encode(const std::wstring& msg);
+ByteArray Encode(const std::wstring& msg, CharacterSet charset, SymbolShape shape, int minWidth, int minHeight, int maxWidth, int maxHeight);
+
+} // DataMatrix
+} // ZXing

package/cpp/zxing-core/core/src/datamatrix/DMReader.cpp

@@ -0,0 +1,40 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "DMReader.h"
+
+#include "BinaryBitmap.h"
+#include "DMDecoder.h"
+#include "DMDetector.h"
+#include "ReaderOptions.h"
+#include "DecoderResult.h"
+#include "DetectorResult.h"
+#include "BarcodeData.h"
+
+#include <utility>
+
+namespace ZXing::DataMatrix {
+
+BarcodesData Reader::read(const BinaryBitmap& image, int maxSymbols) const
+{
+	auto binImg = image.getBitMatrix();
+	if (binImg == nullptr)
+		return {};
+
+	BarcodesData res;
+	for (auto&& detRes : Detect(*binImg, _opts.tryHarder(), _opts.tryRotate(), _opts.isPure())) {
+		auto decRes = Decode(detRes.bits());
+		if (decRes.isValid(_opts.returnErrors())) {
+			res.emplace_back(MatrixBarcode(std::move(decRes), std::move(detRes), BarcodeFormat::DataMatrix));
+			if (maxSymbols > 0 && Size(res) >= maxSymbols)
+				break;
+		}
+	}
+
+	return res;
+}
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMReader.h

@@ -0,0 +1,21 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Reader.h"
+
+namespace ZXing::DataMatrix {
+
+class Reader : public ZXing::Reader
+{
+public:
+	using ZXing::Reader::Reader;
+
+	BarcodesData read(const BinaryBitmap& image, int maxSymbols) const override;
+};
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMSymbolInfo.cpp

@@ -0,0 +1,141 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "DMSymbolInfo.h"
+
+#include "ZXAlgorithms.h"
+#include "ZXTestSupport.h"
+
+#include <cstddef>
+#include <stdexcept>
+
+namespace ZXing::DataMatrix {
+
+static constexpr const SymbolInfo PROD_SYMBOLS[] = {
+	{ false, 3, 5, 8, 8, 1 },
+	{ false, 5, 7, 10, 10, 1 },
+	{ true, 5, 7, 16, 6, 1 },
+	{ false, 8, 10, 12, 12, 1 },
+	{ true, 10, 11, 14, 6, 2 },
+	{ false, 12, 12, 14, 14, 1 },
+	{ true, 16, 14, 24, 10, 1 },
+
+	{ false, 18, 14, 16, 16, 1 },
+	{ false, 22, 18, 18, 18, 1 },
+	{ true, 22, 18, 16, 10, 2 },
+	{ false, 30, 20, 20, 20, 1 },
+	{ true, 32, 24, 16, 14, 2 },
+	{ false, 36, 24, 22, 22, 1 },
+	{ false, 44, 28, 24, 24, 1 },
+	{ true, 49, 28, 22, 14, 2 },
+
+	{ false, 62, 36, 14, 14, 4 },
+	{ false, 86, 42, 16, 16, 4 },
+	{ false, 114, 48, 18, 18, 4 },
+	{ false, 144, 56, 20, 20, 4 },
+	{ false, 174, 68, 22, 22, 4 },
+
+	{ false, 204, 84, 24, 24, 4, 102, 42 },
+	{ false, 280, 112, 14, 14, 16, 140, 56 },
+	{ false, 368, 144, 16, 16, 16, 92, 36 },
+	{ false, 456, 192, 18, 18, 16, 114, 48 },
+	{ false, 576, 224, 20, 20, 16, 144, 56 },
+	{ false, 696, 272, 22, 22, 16, 174, 68 },
+	{ false, 816, 336, 24, 24, 16, 136, 56 },
+	{ false, 1050, 408, 18, 18, 36, 175, 68 },
+	{ false, 1304, 496, 20, 20, 36, 163, 62 },
+	{ false, 1558, 620, 22, 22, 36, -1, 62 },
+};
+
+static const SymbolInfo* ZXING_IF_NOT_TEST(const) s_symbols = PROD_SYMBOLS;
+static ZXING_IF_NOT_TEST(const) size_t s_symbolCount = Size(PROD_SYMBOLS);
+
+#ifdef ZXING_BUILD_FOR_TEST
+
+ZXING_EXPORT_TEST_ONLY
+void OverrideSymbolSet(const SymbolInfo* symbols, size_t count)
+{
+	s_symbols = symbols;
+	s_symbolCount = count;
+}
+
+ZXING_EXPORT_TEST_ONLY
+void UseDefaultSymbolSet()
+{
+	s_symbols = PROD_SYMBOLS;
+	s_symbolCount = Size(PROD_SYMBOLS);
+}
+
+#endif // ZXING_BUILD_FOR_TEST
+
+const SymbolInfo *
+SymbolInfo::Lookup(int dataCodewords)
+{
+	return Lookup(dataCodewords, SymbolShape::NONE);
+}
+
+const SymbolInfo *
+SymbolInfo::Lookup(int dataCodewords, SymbolShape shape)
+{
+	return Lookup(dataCodewords, shape, -1, -1, -1, -1);
+}
+
+const SymbolInfo *
+SymbolInfo::Lookup(int dataCodewords, bool allowRectangular)
+{
+	return Lookup(dataCodewords, allowRectangular ? SymbolShape::NONE : SymbolShape::SQUARE, -1, -1, -1, -1);
+}
+
+const SymbolInfo *
+SymbolInfo::Lookup(int dataCodewords, SymbolShape shape, int minWidth, int minHeight, int maxWidth, int maxHeight)
+{
+	for (size_t i = 0; i < s_symbolCount; ++i) {
+		auto& symbol = s_symbols[i];
+		if (shape == SymbolShape::SQUARE && symbol._rectangular) {
+			continue;
+		}
+		if (shape == SymbolShape::RECTANGLE && !symbol._rectangular) {
+			continue;
+		}
+		if (minWidth >= 0 && minHeight >= 0 && (symbol.symbolWidth() < minWidth || symbol.symbolHeight() < minHeight)) {
+			continue;
+		}
+		if (maxWidth >= 0 && maxHeight >= 0 && (symbol.symbolWidth() > maxWidth || symbol.symbolHeight() > maxHeight)) {
+			continue;
+		}
+		if (dataCodewords <= symbol._dataCapacity) {
+			return &symbol;
+		}
+	}
+	return nullptr;
+}
+
+int
+SymbolInfo::horizontalDataRegions() const
+{
+	switch (_dataRegions) {
+	case 1:  return 1;
+	case 2:  return 2;
+	case 4:  return 2;
+	case 16: return 4;
+	case 36: return 6;
+	default: throw std::out_of_range("Cannot handle this number of data regions");
+	}
+}
+
+int
+SymbolInfo::verticalDataRegions() const {
+	switch (_dataRegions) {
+	case 1:  return 1;
+	case 2:  return 1;
+	case 4:  return 2;
+	case 16: return 4;
+	case 36: return 6;
+	default: throw std::out_of_range("Cannot handle this number of data regions");
+	}
+}
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMSymbolInfo.h

@@ -0,0 +1,78 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "DMSymbolShape.h"
+
+namespace ZXing::DataMatrix {
+
+class SymbolInfo
+{
+	bool _rectangular;
+	int _dataCapacity;
+	int _errorCodewords;
+	int _matrixWidth;
+	int _matrixHeight;
+	int _dataRegions;
+	int _rsBlockData;
+	int _rsBlockError;
+
+public:
+	constexpr SymbolInfo(bool rectangular, int dataCapacity, int errorCodewords, int matrixWidth, int matrixHeight, int dataRegions)
+		: SymbolInfo(rectangular, dataCapacity, errorCodewords, matrixWidth, matrixHeight, dataRegions, dataCapacity, errorCodewords)
+	{}
+
+	constexpr SymbolInfo(bool rectangular, int dataCapacity, int errorCodewords, int matrixWidth, int matrixHeight, int dataRegions,
+						 int rsBlockData, int rsBlockError)
+		: _rectangular(rectangular),
+		  _dataCapacity(dataCapacity),
+		  _errorCodewords(errorCodewords),
+		  _matrixWidth(matrixWidth),
+		  _matrixHeight(matrixHeight),
+		  _dataRegions(dataRegions),
+		  _rsBlockData(rsBlockData),
+		  _rsBlockError(rsBlockError)
+	{}
+
+	static const SymbolInfo* Lookup(int dataCodewords);
+	static const SymbolInfo* Lookup(int dataCodewords, SymbolShape shape);
+	static const SymbolInfo* Lookup(int dataCodewords, bool allowRectangular);
+	static const SymbolInfo* Lookup(int dataCodewords, SymbolShape shape, int minWidth, int minHeight, int maxWidth, int maxHeight);
+
+	int horizontalDataRegions() const;
+
+	int verticalDataRegions() const;
+
+	int symbolDataWidth() const { return horizontalDataRegions() * _matrixWidth; }
+
+	int symbolDataHeight() const { return verticalDataRegions() * _matrixHeight; }
+
+	int symbolWidth() const { return symbolDataWidth() + (horizontalDataRegions() * 2); }
+
+	int symbolHeight() const { return symbolDataHeight() + (verticalDataRegions() * 2); }
+
+	int matrixWidth() const { return _matrixWidth; }
+
+	int matrixHeight() const { return _matrixHeight; }
+
+	int codewordCount() const { return _dataCapacity + _errorCodewords; }
+
+	int interleavedBlockCount() const { return _rsBlockData > 0 ? _dataCapacity / _rsBlockData : 10; /* Symbol 144 */ }
+
+	int dataCapacity() const { return _dataCapacity; }
+
+	int errorCodewords() const { return _errorCodewords; }
+
+	int dataLengthForInterleavedBlock(int index) const
+	{
+		return _rsBlockData > 0 ? _rsBlockData : (index <= 8 ? 156 : 155); /* Symbol 144 */
+	}
+
+	int errorLengthForInterleavedBlock() const { return _rsBlockError; }
+};
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMSymbolShape.h

@@ -0,0 +1,17 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing::DataMatrix {
+
+enum class SymbolShape {
+	NONE,
+	SQUARE,
+	RECTANGLE,
+};
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMVersion.cpp

@@ -0,0 +1,82 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "DMVersion.h"
+
+namespace ZXing::DataMatrix {
+
+const Version* VersionForDimensions(int height, int width)
+{
+	if ((height & 0x01) != 0 || (width & 0x01) != 0 || height < 8 || height > 144)
+		return nullptr;
+
+	/**
+	* See ISO 16022:2006 5.5.1 Table 7
+	* See ISO 21471:2020 (DMRE) 5.5.1 Table 7
+	*/
+	static const Version allVersions[] = {
+		// clang-format off
+		{1, 10, 10, 8, 8,      {5,  {{1, 3  }, {0, 0}}}},
+		{2, 12, 12, 10, 10,    {7,  {{1, 5  }, {0, 0}}}},
+		{3, 14, 14, 12, 12,    {10, {{1, 8  }, {0, 0}}}},
+		{4, 16, 16, 14, 14,    {12, {{1, 12 }, {0, 0}}}},
+		{5, 18, 18, 16, 16,    {14, {{1, 18 }, {0, 0}}}},
+		{6, 20, 20, 18, 18,    {18, {{1, 22 }, {0, 0}}}},
+		{7, 22, 22, 20, 20,    {20, {{1, 30 }, {0, 0}}}},
+		{8, 24, 24, 22, 22,    {24, {{1, 36 }, {0, 0}}}},
+		{9, 26, 26, 24, 24,    {28, {{1, 44 }, {0, 0}}}},
+		{10, 32, 32, 14, 14,   {36, {{1, 62 }, {0, 0}}}},
+		{11, 36, 36, 16, 16,   {42, {{1, 86 }, {0, 0}}}},
+		{12, 40, 40, 18, 18,   {48, {{1, 114}, {0, 0}}}},
+		{13, 44, 44, 20, 20,   {56, {{1, 144}, {0, 0}}}},
+		{14, 48, 48, 22, 22,   {68, {{1, 174}, {0, 0}}}},
+		{15, 52, 52, 24, 24,   {42, {{2, 102}, {0, 0}}}},
+		{16, 64, 64, 14, 14,   {56, {{2, 140}, {0, 0}}}},
+		{17, 72, 72, 16, 16,   {36, {{4, 92 }, {0, 0}}}},
+		{18, 80, 80, 18, 18,   {48, {{4, 114}, {0, 0}}}},
+		{19, 88, 88, 20, 20,   {56, {{4, 144}, {0, 0}}}},
+		{20, 96, 96, 22, 22,   {68, {{4, 174}, {0, 0}}}},
+		{21, 104, 104, 24, 24, {56, {{6, 136}, {0, 0}}}},
+		{22, 120, 120, 18, 18, {68, {{6, 175}, {0, 0}}}},
+		{23, 132, 132, 20, 20, {62, {{8, 163}, {0, 0}}}},
+		{24, 144, 144, 22, 22, {62, {{8, 156}, {2, 155}}}},
+		{25, 8, 18, 6, 16,     {7,  {{1, 5  }, {0, 0}}}},
+		{26, 8, 32, 6, 14,     {11, {{1, 10 }, {0, 0}}}},
+		{27, 12, 26, 10, 24,   {14, {{1, 16 }, {0, 0}}}},
+		{28, 12, 36, 10, 16,   {18, {{1, 22 }, {0, 0}}}},
+		{29, 16, 36, 14, 16,   {24, {{1, 32 }, {0, 0}}}},
+		{30, 16, 48, 14, 22,   {28, {{1, 49 }, {0, 0}}}},
+
+		// DMRE
+		{31, 8, 48, 6, 22,     {15, {{1, 18 }, {0, 0}}}},
+		{32, 8, 64, 6, 14,     {18, {{1, 24 }, {0, 0}}}},
+		{33, 8, 80, 6, 18,     {22, {{1, 32 }, {0, 0}}}},
+		{34, 8, 96, 6, 22,     {28, {{1, 38 }, {0, 0}}}},
+		{35, 8, 120, 6, 18,    {32, {{1, 49 }, {0, 0}}}},
+		{36, 8, 144, 6, 22,    {36, {{1, 63 }, {0, 0}}}},
+		{37, 12, 64, 10, 14,   {27, {{1, 43 }, {0, 0}}}},
+		{38, 12, 88, 10, 20,   {36, {{1, 64 }, {0, 0}}}},
+		{39, 16, 64, 14, 14,   {36, {{1, 62 }, {0, 0}}}},
+		{40, 20, 36, 18, 16,   {28, {{1, 44 }, {0, 0}}}},
+		{41, 20, 44, 18, 20,   {34, {{1, 56 }, {0, 0}}}},
+		{42, 20, 64, 18, 14,   {42, {{1, 84 }, {0, 0}}}},
+		{43, 22, 48, 20, 22,   {38, {{1, 72 }, {0, 0}}}},
+		{44, 24, 48, 22, 22,   {41, {{1, 80 }, {0, 0}}}},
+		{45, 24, 64, 22, 14,   {46, {{1, 108}, {0, 0}}}},
+		{46, 26, 40, 24, 18,   {38, {{1, 70 }, {0, 0}}}},
+		{47, 26, 48, 24, 22,   {42, {{1, 90 }, {0, 0}}}},
+		{48, 26, 64, 24, 14,   {50, {{1, 118}, {0, 0}}}},
+		// clang-format on
+	};
+
+	for (auto& version : allVersions)
+		if (version.symbolHeight == height && version.symbolWidth == width)
+			return &version;
+
+	return nullptr;
+}
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMVersion.h

@@ -0,0 +1,76 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing::DataMatrix {
+
+/**
+ * The Version object encapsulates attributes about a particular Data Matrix Symbol size.
+ */
+class Version
+{
+public:
+	/**
+	 * Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+	 * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+	 * each set of blocks. It also holds the number of error-correction codewords per block since it
+	 * will be the same across all blocks within one version.
+	 */
+	struct ECBlocks
+	{
+		int codewordsPerBlock;
+
+		/* Encapsulates the parameters for one error-correction block in one symbol version.
+		 * This includes the number of data codewords, and the number of times a block with these
+		 * parameters is used consecutively in the Data Matrix code version's format.
+		 */
+		struct
+		{
+			int count;
+			int dataCodewords;
+		} const blocks[2];
+
+		int numBlocks() const { return blocks[0].count + blocks[1].count; }
+
+		int totalDataCodewords() const
+		{
+			return blocks[0].count * (blocks[0].dataCodewords + codewordsPerBlock) +
+				   blocks[1].count * (blocks[1].dataCodewords + codewordsPerBlock);
+		}
+	};
+
+	const int versionNumber;
+	const int symbolHeight;
+	const int symbolWidth;
+	const int dataBlockHeight;
+	const int dataBlockWidth;
+	const ECBlocks ecBlocks;
+
+	int totalCodewords() const { return ecBlocks.totalDataCodewords(); }
+	int dataWidth() const { return (symbolWidth / dataBlockWidth) * dataBlockWidth; }
+	int dataHeight() const { return (symbolHeight / dataBlockHeight) * dataBlockHeight; }
+	int dataBlocksX() const { return symbolWidth / dataBlockWidth; }
+	int dataBlocksY() const { return symbolHeight / dataBlockHeight; }
+	bool isDMRE() const { return versionNumber >= 31 && versionNumber <= 48; }
+};
+
+/**
+ * @brief Looks up Version information based on symbol dimensions.
+ *
+ * @param height Number of rows in modules
+ * @param width Number of columns in modules
+ * @return Version for a Data Matrix Code of those dimensions, nullptr for invalid dimensions
+ */
+const Version* VersionForDimensions(int height, int width);
+
+template<typename MAT>
+const Version* VersionForDimensionsOf(const MAT& mat)
+{
+	return VersionForDimensions(mat.height(), mat.width());
+}
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMWriter.cpp

@@ -0,0 +1,114 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "DMWriter.h"
+
+#include "BitMatrix.h"
+#include "ByteArray.h"
+#include "CharacterSet.h"
+#include "DMBitLayout.h"
+#include "DMECEncoder.h"
+#include "DMHighLevelEncoder.h"
+#include "DMSymbolInfo.h"
+#include "Utf.h"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace ZXing::DataMatrix {
+
+/**
+* Encode the given symbol info to a bit matrix.
+*
+* @param placement  The DataMatrix placement.
+* @param symbolInfo The symbol info to encode.
+* @return The bit matrix generated.
+*/
+static BitMatrix EncodeLowLevel(const BitMatrix& placement, const SymbolInfo& symbolInfo) {
+	int symbolWidth = symbolInfo.symbolDataWidth();
+	int symbolHeight = symbolInfo.symbolDataHeight();
+
+	BitMatrix matrix(symbolInfo.symbolWidth(), symbolInfo.symbolHeight());
+	int matrixY = 0;
+	for (int y = 0; y < symbolHeight; y++) {
+		// Fill the top edge with alternate 0 / 1
+		int matrixX;
+		if ((y % symbolInfo.matrixHeight()) == 0) {
+			matrixX = 0;
+			for (int x = 0; x < matrix.width(); x++) {
+				matrix.set(matrixX, matrixY, (x % 2) == 0);
+				matrixX++;
+			}
+			matrixY++;
+		}
+		matrixX = 0;
+		for (int x = 0; x < symbolWidth; x++) {
+			// Fill the right edge with full 1
+			if ((x % symbolInfo.matrixWidth()) == 0) {
+				matrix.set(matrixX, matrixY, true);
+				matrixX++;
+			}
+			matrix.set(matrixX, matrixY, placement.get(x, y) == 1);
+			matrixX++;
+			// Fill the right edge with alternate 0 / 1
+			if ((x % symbolInfo.matrixWidth()) == symbolInfo.matrixWidth() - 1) {
+				matrix.set(matrixX, matrixY, (y % 2) == 0);
+				matrixX++;
+			}
+		}
+		matrixY++;
+		// Fill the bottom edge with full 1
+		if ((y % symbolInfo.matrixHeight()) == symbolInfo.matrixHeight() - 1) {
+			matrixX = 0;
+			for (int x = 0; x < matrix.width(); x++) {
+				matrix.set(matrixX, matrixY, true);
+				matrixX++;
+			}
+			matrixY++;
+		}
+	}
+
+	return matrix;
+}
+
+BitMatrix
+Writer::encode(const std::wstring& contents, int width, int height) const
+{
+	if (contents.empty()) {
+		throw std::invalid_argument("Found empty contents");
+	}
+
+	if (width < 0 || height < 0) {
+		throw std::invalid_argument("Requested dimensions are invalid");
+	}
+
+	//1. step: Data encodation
+	auto encoded = Encode(contents, _encoding, _shapeHint, _minWidth, _minHeight, _maxWidth, _maxHeight);
+	const SymbolInfo* symbolInfo = SymbolInfo::Lookup(Size(encoded), _shapeHint, _minWidth, _minHeight, _maxWidth, _maxHeight);
+	if (symbolInfo == nullptr) {
+		throw std::invalid_argument("Can't find a symbol arrangement that matches the message. Data codewords: " + std::to_string(encoded.size()));
+	}
+
+	//2. step: ECC generation
+	EncodeECC200(encoded, *symbolInfo);
+
+	//3. step: Module placement in Matrix
+	BitMatrix symbolData = BitMatrixFromCodewords(encoded, symbolInfo->symbolDataWidth(), symbolInfo->symbolDataHeight());
+
+	//4. step: low-level encoding
+	BitMatrix result = EncodeLowLevel(symbolData, *symbolInfo);
+
+	//5. step: scale-up to requested size, minimum required quiet zone is 1
+	return Inflate(std::move(result), width, height, _quietZone);
+}
+
+BitMatrix Writer::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::DataMatrix

package/cpp/zxing-core/core/src/datamatrix/DMWriter.h

@@ -0,0 +1,62 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "CharacterSet.h"
+#include "DMSymbolShape.h"
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace DataMatrix {
+
+class Writer
+{
+public:
+	Writer() = default;
+
+	Writer& setMargin(int margin) {
+		_quietZone = margin;
+		return *this;
+	}
+
+	Writer& setShapeHint(SymbolShape shape) {
+		_shapeHint = shape;
+		return *this;
+	}
+
+	Writer& setMinSize(int width, int height) {
+		_minWidth = width;
+		_minHeight = height;
+		return *this;
+	}
+
+	Writer& setMaxSize(int width, int height) {
+		_maxWidth = width;
+		_maxHeight = height;
+		return *this;
+	}
+
+	Writer& setEncoding(CharacterSet encoding) {
+		_encoding = encoding;
+		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:
+	SymbolShape _shapeHint = SymbolShape::NONE;
+	int _quietZone = 1, _minWidth = -1, _minHeight = -1, _maxWidth = -1, _maxHeight = -1;
+	CharacterSet _encoding = CharacterSet::Unknown;
+};
+
+} // DataMatrix
+} // ZXing