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

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

@@ -0,0 +1,176 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODCode39Writer.h"
+
+#include "CharacterSet.h"
+#include "ODWriterHelper.h"
+#include "TextEncoder.h"
+#include "Utf.h"
+#include "ZXAlgorithms.h"
+
+#include <array>
+#include <stdexcept>
+#include <vector>
+
+namespace ZXing::OneD {
+
+static constexpr char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
+
+/**
+* These represent the encodings of characters, as patterns of wide and narrow bars.
+* The 9 least-significant bits of each int correspond to the pattern of wide and narrow,
+* with 1s representing "wide" and 0s representing narrow.
+*/
+static constexpr int CHARACTER_ENCODINGS[] = {
+	0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9
+	0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J
+	0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T
+	0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, // U-*
+	0x0A8, 0x0A2, 0x08A, 0x02A // $-%
+};
+
+static_assert(Size(ALPHABET) == Size(CHARACTER_ENCODINGS), "table size mismatch");
+
+static const int ASTERISK_ENCODING = CHARACTER_ENCODINGS[39];
+
+static void ToIntArray(int a, std::array<int, 9>& toReturn) {
+	for (int i = 0; i < 9; ++i) {
+		toReturn[i] = (a & (1 << (8 - i))) == 0 ? 1 : 2;
+	}
+}
+
+static std::string ToHexString(int c)
+{
+	const char* digits = "0123456789abcdef";
+	std::string val(4, '0');
+	val[1] = 'x';
+	val[2] = digits[(c >> 4) & 0xf];
+	val[3] = digits[c & 0xf];
+	return val;
+}
+
+static std::string TryToConvertToExtendedMode(const std::wstring& contents) {
+	size_t length = contents.length();
+	std::string extendedContent;
+	extendedContent.reserve(length * 2);
+
+	for (size_t i = 0; i < length; i++) {
+		int character = contents[i];
+		switch (character) {
+			case '\0':
+				extendedContent.append("%U");
+				break;
+			case ' ':
+			case '-':
+			case '.':
+				extendedContent.push_back((char)character);
+				break;
+			case '@':
+				extendedContent.append("%V");
+				break;
+			case '`':
+				extendedContent.append("%W");
+				break;
+			default:
+				if (character > 0 && character < 27) {
+					extendedContent.push_back('$');
+					extendedContent.push_back((char)('A' + (character - 1)));
+				}
+				else if (character > 26 && character < ' ') {
+					extendedContent.push_back('%');
+					extendedContent.push_back((char)('A' + (character - 27)));
+				}
+				else if ((character > ' ' && character < '-') || character == '/' || character == ':') {
+					extendedContent.push_back('/');
+					extendedContent.push_back((char)('A' + (character - 33)));
+				}
+				else if (character > '/' && character < ':') {
+					extendedContent.push_back((char)('0' + (character - 48)));
+				}
+				else if (character > ':' && character < '@') {
+					extendedContent.push_back('%');
+					extendedContent.push_back((char)('F' + (character - 59)));
+				}
+				else if (character > '@' && character < '[') {
+					extendedContent.push_back((char)('A' + (character - 65)));
+				}
+				else if (character > 'Z' && character < '`') {
+					extendedContent.push_back('%');
+					extendedContent.push_back((char)('K' + (character - 91)));
+				}
+				else if (character > '`' && character < '{') {
+					extendedContent.push_back('+');
+					extendedContent.push_back((char)('A' + (character - 97)));
+				}
+				else if (character > 'z' && character < 128) {
+					extendedContent.push_back('%');
+					extendedContent.push_back((char)('P' + (character - 123)));
+				}
+				else {
+					throw std::invalid_argument("Requested content contains a non-encodable character: '" + ToHexString(character) + "'");
+				}
+				break;
+		}
+	}
+
+	return extendedContent;
+}
+
+BitMatrix
+Code39Writer::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 > 80) {
+		throw std::invalid_argument("Requested contents should be less than 80 digits long");
+	}
+
+	std::string extendedContent;
+	for (size_t i = 0; i < length; i++) {
+		int indexInString = IndexOf(ALPHABET, contents[i]);
+		if (indexInString < 0) {
+			extendedContent = TryToConvertToExtendedMode(contents);
+			length = extendedContent.length();
+			if (length > 80) {
+				throw std::invalid_argument("Requested contents should be less than 80 digits long, but got " + std::to_string(length) + " (extended full ASCII mode)");
+			}
+			break;
+		}
+	}
+	
+	if (extendedContent.empty()) {
+		extendedContent = TextEncoder::FromUnicode(contents, CharacterSet::ISO8859_1);
+	}
+
+	std::array<int, 9> widths = {};
+	size_t codeWidth = 24 + 1 + (13 * length);
+
+	std::vector<bool> result(codeWidth, false);
+	ToIntArray(ASTERISK_ENCODING, widths);
+	int pos = WriterHelper::AppendPattern(result, 0, widths, true);
+	std::array<int, 1> narrowWhite = { 1 };
+	pos += WriterHelper::AppendPattern(result, pos, narrowWhite, false);
+	//append next character to byte matrix
+	for (size_t i = 0; i < length; ++i) {
+		int indexInString = IndexOf(ALPHABET, extendedContent[i]);
+		ToIntArray(CHARACTER_ENCODINGS[indexInString], widths);
+		pos += WriterHelper::AppendPattern(result, pos, widths, true);
+		pos += WriterHelper::AppendPattern(result, pos, narrowWhite, false);
+	}
+	ToIntArray(ASTERISK_ENCODING, widths);
+	WriterHelper::AppendPattern(result, pos, widths, true);
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 10);
+}
+
+BitMatrix Code39Writer::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/ODCode39Writer.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 CODE39 code as a {@link BitMatrix}.
+* 
+* @author erik.barbara@gmail.com (Erik Barbara)
+*/
+class Code39Writer
+{
+public:
+	Code39Writer& 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/ODCode93Patterns.h

@@ -0,0 +1,80 @@
+/*
+* Copyright 2025 wooyechan
+* Copyright 2026 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Pattern.h"
+
+namespace ZXing::OneD::Code93 {
+
+// Each character consist of 3 bars and 3 spaces and is 9 modules wide in total.
+// Each bar and space is from 1 to 4 modules wide.
+constexpr int CHAR_LEN = 6;
+constexpr int CHAR_MODS = 9;
+
+constexpr std::array<FixedPattern<CHAR_LEN, CHAR_MODS>, 48> CODE_PATTERNS = { {
+	{ 1, 3, 1, 1, 1, 2 }, // 0
+	{ 1, 1, 1, 2, 1, 3 },
+	{ 1, 1, 1, 3, 1, 2 },
+	{ 1, 1, 1, 4, 1, 1 },
+	{ 1, 2, 1, 1, 1, 3 },
+	{ 1, 2, 1, 2, 1, 2 }, // 5
+	{ 1, 2, 1, 3, 1, 1 },
+	{ 1, 1, 1, 1, 1, 4 },
+	{ 1, 3, 1, 2, 1, 1 },
+	{ 1, 4, 1, 1, 1, 1 },
+	{ 2, 1, 1, 1, 1, 3 }, // 10
+	{ 2, 1, 1, 2, 1, 2 }, 
+	{ 2, 1, 1, 3, 1, 1 },
+	{ 2, 2, 1, 1, 1, 2 },
+	{ 2, 2, 1, 2, 1, 1 },
+	{ 2, 3, 1, 1, 1, 1 }, // 15
+	{ 1, 1, 2, 1, 1, 3 },
+	{ 1, 1, 2, 2, 1, 2 },
+	{ 1, 1, 2, 3, 1, 1 },
+	{ 1, 2, 2, 1, 1, 2 },
+	{ 1, 3, 2, 1, 1, 1 }, // 20
+	{ 1, 1, 1, 1, 2, 3 },
+	{ 1, 1, 1, 2, 2, 2 },
+	{ 1, 1, 1, 3, 2, 1 },
+	{ 1, 2, 1, 1, 2, 2 },
+	{ 1, 3, 1, 1, 2, 1 }, // 25
+	{ 2, 1, 2, 1, 1, 2 },
+	{ 2, 1, 2, 2, 1, 1 },
+	{ 2, 1, 1, 1, 2, 2 },
+	{ 2, 1, 1, 2, 2, 1 },
+	{ 2, 2, 1, 1, 2, 1 }, // 30
+	{ 2, 2, 2, 1, 1, 1 },
+	{ 1, 1, 2, 1, 2, 2 },
+	{ 1, 1, 2, 2, 2, 1 },
+	{ 1, 2, 2, 1, 2, 1 },
+	{ 1, 2, 3, 1, 1, 1 }, // 35
+	{ 1, 2, 1, 1, 3, 1 },
+	{ 3, 1, 1, 1, 1, 2 },
+	{ 3, 1, 1, 2, 1, 1 },
+	{ 3, 2, 1, 1, 1, 1 },
+	{ 1, 1, 2, 1, 3, 1 }, // 40
+	{ 1, 1, 3, 1, 2, 1 },
+	{ 2, 1, 1, 1, 3, 1 },
+	{ 1, 2, 1, 2, 2, 1 },
+	{ 3, 1, 2, 1, 1, 1 },
+	{ 3, 1, 1, 1, 2, 1 }, // 45
+	{ 1, 2, 2, 2, 1, 1 },
+	{ 1, 1, 1, 1, 4, 1 }  // STOP_CODE / Asterisk
+} };
+
+constexpr auto E2E_PATTERNS = PatternsToE2EInts(CODE_PATTERNS);
+
+
+// Note that 'abcd' are dummy characters in place of control characters.
+// Control chars ($)==a, (%)==b, (/)==c, (+)==d
+constexpr char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
+
+static_assert(Size(ALPHABET) == Size(CODE_PATTERNS), "table size mismatch");
+
+constexpr int ASTERISK_ENCODING = E2E_PATTERNS[47];
+
+} // namespace ZXing::OneD::Code93

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

@@ -0,0 +1,112 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODCode93Reader.h"
+
+#include "ODCode93Patterns.h"
+#include "BarcodeData.h"
+#include "SymbologyIdentifier.h"
+#include "ZXAlgorithms.h"
+
+#include <array>
+#include <string>
+
+namespace ZXing::OneD {
+
+using namespace Code93;
+
+static bool
+CheckOneChecksum(const std::string& result, int checkPosition, int weightMax)
+{
+	int weight = 1;
+	int checksum = 0;
+	for (int i = checkPosition - 1; i >= 0; i--) {
+		checksum += weight * IndexOf(ALPHABET, result[i]);
+		if (++weight > weightMax) {
+			weight = 1;
+		}
+	}
+	return result[checkPosition] == ALPHABET[checksum % 47];
+}
+
+static bool
+CheckChecksums(const std::string& result)
+{
+	int length = Size(result);
+	return CheckOneChecksum(result, length - 2, 20) && CheckOneChecksum(result, length - 1, 15);
+}
+
+// forward declare here. see ODCode39Reader.cpp. Not put in header to not pollute the public facing API
+std::string DecodeCode39AndCode93FullASCII(std::string encoded, const char ctrl[4]);
+
+// quiet zone is half the width of a character symbol
+constexpr float QUIET_ZONE_SCALE = 0.5f;
+
+static bool IsStartGuard(const PatternView& window, int spaceInPixel)
+{
+	// The complete start pattern is FixedPattern<CHAR_LEN, CHAR_MODS>{1, 1, 1, 1, 4, 1}.
+	// Use only the first 4 elements which results in more than a 2x speedup. This is counter-intuitive since we save at
+	// most 1/3rd of the loop iterations in FindPattern. The reason might be a successful vectorization with the limited
+	// pattern size that is missed otherwise. We check for the remaining 2 slots for plausibility of the 4:1 ratio.
+	return IsPattern(window, FixedPattern<4, 4>{1, 1, 1, 1}, spaceInPixel, QUIET_ZONE_SCALE * 12) &&
+		   window[4] > 3 * window[5] - 2 &&
+		   ToInt(NormalizedE2EPattern<CHAR_LEN, CHAR_MODS>(window)) == ASTERISK_ENCODING;
+}
+
+BarcodeData Code93Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+{
+	// minimal number of characters that must be present (including start, stop, checksum and 1 payload characters)
+	int minCharCount = 5;
+
+	next = FindLeftGuard<CHAR_LEN>(next, minCharCount * CHAR_LEN, IsStartGuard);
+	if (!next.isValid())
+		return {};
+
+	int xStart = next.pixelsInFront();
+
+	std::string txt;
+	txt.reserve(20);
+
+	do {
+		// check remaining input width
+		if (!next.skipSymbol())
+			return {};
+
+		txt += LookupBitPattern(ToInt(NormalizedE2EPattern<CHAR_LEN, CHAR_MODS>(next)), E2E_PATTERNS, ALPHABET);
+
+		if (txt.back() == 0)
+			return {};
+	} while (txt.back() != '*');
+
+	txt.pop_back(); // remove asterisk
+
+	if (Size(txt) < minCharCount - 2)
+		return {};
+
+	// check termination bar (is present and not wider than about 2 modules) and quiet zone
+	next = next.subView(0, CHAR_LEN + 1);
+	if (!next.isValid() || next[CHAR_LEN] > next.sum(CHAR_LEN) / 4 || !next.hasQuietZoneAfter(QUIET_ZONE_SCALE))
+		return {};
+
+	Error error;
+	if (!CheckChecksums(txt))
+		error = ChecksumError();
+
+	// Remove checksum digits
+	txt.resize(txt.size() - 2);
+
+	if (!error && (txt = DecodeCode39AndCode93FullASCII(txt, "abcd")).empty())
+		error = FormatError("ASCII decoding of Code93 failed");
+
+	// Symbology identifier ISO/IEC 15424:2008 4.4.10 no modifiers
+	SymbologyIdentifier symbologyIdentifier = {'G', '0'};
+
+	int xStop = next.pixelsTillEnd();
+	return LinearBarcode(BarcodeFormat::Code93, txt, rowNumber, xStart, xStop, symbologyIdentifier, error);
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,21 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+class Code93Reader : 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/ODCode93Writer.cpp

@@ -0,0 +1,192 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODCode93Writer.h"
+
+#include "ODWriterHelper.h"
+#include "Utf.h"
+#include "ZXAlgorithms.h"
+#include "ZXTestSupport.h"
+
+#include <stdexcept>
+
+namespace ZXing::OneD {
+
+static constexpr char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
+
+/**
+* These represent the encodings of characters, as patterns of wide and narrow bars.
+* The 9 least-significant bits of each int correspond to the pattern of wide and narrow.
+*/
+static constexpr int CHARACTER_ENCODINGS[] = {
+	0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9
+	0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J
+	0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T
+	0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z
+	0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %
+	0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars? $-*
+};
+
+static_assert(Size(ALPHABET) == Size(CHARACTER_ENCODINGS), "table size mismatch");
+
+static const int ASTERISK_ENCODING = CHARACTER_ENCODINGS[47];
+
+static int AppendPattern(std::vector<bool>& target, int pos, int a)
+{
+	for (int i = 0; i < 9; i++) {
+		int temp = a & (1 << (8 - i));
+		target[pos + i] = temp != 0;
+	}
+	return 9;
+}
+
+
+static int ComputeChecksumIndex(const std::string& contents, int maxWeight)
+{
+	int weight = 1;
+	int total = 0;
+
+	for (int i = Size(contents) - 1; i >= 0; i--) {
+		int indexInString = IndexOf(ALPHABET, contents[i]);
+		total += indexInString * weight;
+		if (++weight > maxWeight) {
+			weight = 1;
+		}
+	}
+	return total % 47;
+}
+
+
+ZXING_EXPORT_TEST_ONLY
+std::string Code93ConvertToExtended(const std::wstring& contents)
+{
+	size_t length = contents.length();
+	std::string extendedContent;
+	extendedContent.reserve(length * 2);
+
+	for (size_t i = 0; i < length; i++) {
+		int character = contents[i];
+		// ($)=a, (%)=b, (/)=c, (+)=d. see Code93Reader.ALPHABET
+		if (character == 0) {
+			// NUL: (%)U
+			extendedContent.append("bU");
+		}
+		else if (character <= 26) {
+			// SOH - SUB: ($)A - ($)Z
+			extendedContent.push_back('a');
+			extendedContent.push_back((char)('A' + character - 1));
+		}
+		else if (character <= 31) {
+			// ESC - US: (%)A - (%)E
+			extendedContent.push_back('b');
+			extendedContent.push_back((char)('A' + character - 27));
+		}
+		else if (character == ' ' || character == '$' || character == '%' || character == '+') {
+			// space $ % +
+			extendedContent.push_back(character);
+		}
+		else if (character <= ',') {
+			// ! " # & ' ( ) * ,: (/)A - (/)L
+			extendedContent.push_back('c');
+			extendedContent.push_back((char)('A' + character - '!'));
+		}
+		else if (character <= '9') {
+			extendedContent.push_back(character);
+		}
+		else if (character == ':') {
+			// :: (/)Z
+			extendedContent.append("cZ");
+		}
+		else if (character <= '?') {
+			// ; - ?: (%)F - (%)J
+			extendedContent.push_back('b');
+			extendedContent.push_back((char)('F' + character - ';'));
+		}
+		else if (character == '@') {
+			// @: (%)V
+			extendedContent.append("bV");
+		}
+		else if (character <= 'Z') {
+			// A - Z
+			extendedContent.push_back(character);
+		}
+		else if (character <= '_') {
+			// [ - _: (%)K - (%)O
+			extendedContent.push_back('b');
+			extendedContent.push_back((char)('K' + character - '['));
+		}
+		else if (character == '`') {
+			// `: (%)W
+			extendedContent.append("bW");
+		}
+		else if (character <= 'z') {
+			// a - z: (*)A - (*)Z
+			extendedContent.push_back('d');
+			extendedContent.push_back((char)('A' + character - 'a'));
+		}
+		else if (character <= 127) {
+			// { - DEL: (%)P - (%)T
+			extendedContent.push_back('b');
+			extendedContent.push_back((char)('P' + character - '{'));
+		}
+		else {
+			throw std::invalid_argument(StrCat("Requested content contains a non-encodable character: '", (char)character, "'"));
+		}
+	}
+	return extendedContent;
+}
+
+BitMatrix
+Code93Writer::encode(const std::wstring& contents_, int width, int height) const
+{
+	std::string contents = Code93ConvertToExtended(contents_);
+
+	size_t length = contents.length();
+	if (length == 0) {
+		throw std::invalid_argument("Found empty contents");
+	}
+	if (length > 80) {
+		throw std::invalid_argument("Requested contents should be less than 80 digits long after converting to extended encoding");
+	}
+
+	//length of code + 2 start/stop characters + 2 checksums, each of 9 bits, plus a termination bar
+	size_t codeWidth = (contents.length() + 2 + 2) * 9 + 1;
+
+	std::vector<bool> result(codeWidth, false);
+
+	//start character (*)
+	int pos = AppendPattern(result, 0, ASTERISK_ENCODING);
+
+	for (size_t i = 0; i < length; i++) {
+		int indexInString = IndexOf(ALPHABET, contents[i]);
+		pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[indexInString]);
+	}
+
+	//add two checksums
+	int check1 = ComputeChecksumIndex(contents, 20);
+	pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[check1]);
+
+	//append the contents to reflect the first checksum added
+	contents += static_cast<wchar_t>(ALPHABET[check1]);
+
+	int check2 = ComputeChecksumIndex(contents, 15);
+	pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[check2]);
+
+	//end character (*)
+	pos += AppendPattern(result, pos, ASTERISK_ENCODING);
+
+	//termination bar (single black bar)
+	result[pos] = true;
+
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 10);
+}
+
+BitMatrix Code93Writer::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/ODCode93Writer.h

@@ -0,0 +1,32 @@
+/*
+* 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 CODE93 code as a BitMatrix
+*/
+class Code93Writer
+{
+public:
+	Code93Writer& 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