switched to new high level encoder ported from zxing code

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Run-Tests",
+            "type": "go",
+            "request": "launch",
+            "mode": "debug",
+            "remotePath": "",
+            "port": 2345,
+            "host": "127.0.0.1",
+            //"program": "${workspaceRoot}",
+            "program": "/Users/boombuler/Sources/barcode",
+            "env": {},
+            "args": [],
+            "showLog": true
+        }
+    ]
+}

pdf417/data_encoder.go

@@ -1,122 +0,0 @@
-package pdf417
-
-import (
-	"fmt"
-)
-
-const (
-	switchCodeText   = 900
-	switchCodeNumber = 902
-)
-
-type encoder interface {
-	CanEncode(char rune) bool
-	GetSwitchCode(data string) int
-	Encode(data string) ([]int, error)
-}
-
-type dataEncoder struct {
-	Encoders       []encoder
-	DefaultEncoder encoder
-}
-
-type chain struct {
-	Data    string
-	Encoder encoder
-}
-
-func (c chain) Encode() ([]int, error) {
-	return c.Encoder.Encode(c.Data)
-}
-
-func (c chain) GetSwitchCode() int {
-	return c.Encoder.GetSwitchCode(c.Data)
-}
-
-func newDataEncoder() *dataEncoder {
-	textEncoder := newTextEncoder()
-
-	encoder := &dataEncoder{
-		[]encoder{
-			newNumberEncoder(),
-			textEncoder,
-		},
-		textEncoder,
-	}
-
-	return encoder
-}
-
-func (dataEncoder *dataEncoder) Encode(data string) ([]int, error) {
-	if len(data) == 0 {
-		return nil, fmt.Errorf("Nothing to encode")
-	}
-
-	chains, err := dataEncoder.SplitToChains(data)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(chains) == 0 {
-		return nil, fmt.Errorf("%q can not be encoded!", data)
-	}
-
-	currentSwitchCode := switchCodeText
-
-	cws := []int{}
-
-	for _, chain := range chains {
-		encoded, err := chain.Encode()
-		if err != nil {
-			return cws, err
-		}
-
-		if switchCode := chain.GetSwitchCode(); currentSwitchCode != switchCode {
-			cws = append(cws, switchCode)
-			currentSwitchCode = switchCode
-		}
-
-		cws = append(cws, encoded...)
-	}
-
-	return cws, nil
-}
-
-func (dataEncoder *dataEncoder) SplitToChains(data string) ([]chain, error) {
-	chains := []chain{}
-	chainData := ""
-	encoder := dataEncoder.DefaultEncoder
-
-	for _, char := range data {
-		newEncoder, err := dataEncoder.getEncoder(char)
-		if err != nil {
-			return nil, err
-		}
-
-		if newEncoder != encoder {
-			if len(chainData) > 0 {
-				chains = append(chains, chain{chainData, encoder})
-				chainData = ""
-			}
-
-			encoder = newEncoder
-		}
-
-		chainData = chainData + string(char)
-	}
-
-	if len(chainData) > 0 {
-		chains = append(chains, chain{chainData, encoder})
-	}
-
-	return chains, nil
-}
-
-func (dataEncoder *dataEncoder) getEncoder(char rune) (encoder, error) {
-	for _, encoder := range dataEncoder.Encoders {
-		if encoder.CanEncode(char) {
-			return encoder, nil
-		}
-	}
-	return nil, fmt.Errorf("Cannot encode character %q", string(char))
-}

pdf417/data_encoder_test.go

@@ -1,36 +0,0 @@
-package pdf417
-
-import "testing"
-
-func TestEncode(t *testing.T) {
-	encoder := newDataEncoder()
-
-	// When starting with text, the first code word does not need to be the switch
-	if result, err := encoder.Encode("ABC123"); err != nil {
-		t.Error(err)
-	} else {
-		compareIntSlice(t, []int{1, 89, 902, 1, 223}, result)
-	}
-	// When starting with numbers, we do need to switchresult := encoder.Encode("ABC123")
-	if result, err := encoder.Encode("123ABC"); err != nil {
-		t.Error(err)
-	} else {
-		compareIntSlice(t, []int{902, 1, 223, 900, 1, 89}, result)
-	}
-
-	/*
-		// Also with bytes
-		if result, err := encoder.Encode("\x0B"); err != nil {
-			t.Error(err)
-		} else {
-			compareIntSlice(t, []int{901, 11}, result)
-		}
-
-		// Alternate bytes switch code when number of bytes is divisble by 6
-		if result, err := encoder.Encode("\x0B\x0B\x0B\x0B\x0B\x0B"); err != nil {
-			t.Error(err)
-		} else {
-			compareIntSlice(t, []int{924, 18, 455, 694, 754, 291}, result)
-		}
-	*/
-}

pdf417/encoder.go

@@ -20,8 +20,8 @@ func Encode(data string, securityLevel byte) (barcode.Barcode, error) {
 
 	sl := securitylevel(securityLevel)
 
-	dataEncoder := newDataEncoder()
-	dataWords, err := dataEncoder.Encode(data)
+	//dataEncoder := newDataEncoder()
+	dataWords, err := highlevelEncode(data)
 	if err != nil {
 		return nil, err
 	}

pdf417/highlevel.go

@@ -0,0 +1,354 @@
+package pdf417
+
+import (
+	"errors"
+	"math/big"
+
+	"github.com/boombuler/barcode/utils"
+)
+
+type encodingMode byte
+
+type subMode byte
+
+const (
+	encText encodingMode = iota
+	encNumeric
+	encBinary
+
+	subUpper subMode = iota
+	subLower
+	subMixed
+	subPunct
+
+	latch_to_text        = 900
+	latch_to_byte_padded = 901
+	latch_to_numeric     = 902
+	latch_to_byte        = 924
+	shift_to_byte        = 913
+
+	min_numeric_count = 13
+)
+
+var (
+	mixedMap map[rune]int
+	punctMap map[rune]int
+)
+
+func init() {
+	mixedMap = make(map[rune]int)
+	mixedRaw := []rune{
+		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 38, 13, 9, 44, 58,
+		35, 45, 46, 36, 47, 43, 37, 42, 61, 94, 0, 32, 0, 0, 0,
+	}
+	for idx, ch := range mixedRaw {
+		if ch > 0 {
+			mixedMap[ch] = idx
+		}
+	}
+
+	punctMap = make(map[rune]int)
+	punctRaw := []rune{
+		59, 60, 62, 64, 91, 92, 93, 95, 96, 126, 33, 13, 9, 44, 58,
+		10, 45, 46, 36, 47, 34, 124, 42, 40, 41, 63, 123, 125, 39, 0,
+	}
+	for idx, ch := range punctRaw {
+		if ch > 0 {
+			punctMap[ch] = idx
+		}
+	}
+}
+
+func determineConsecutiveDigitCount(data []rune) int {
+	cnt := 0
+	for _, r := range data {
+		if utils.RuneToInt(r) == -1 {
+			break
+		}
+		cnt++
+	}
+	return cnt
+}
+
+func encodeNumeric(digits []rune) ([]int, error) {
+	digitCount := len(digits)
+	chunkCount := digitCount / 44
+	if digitCount%44 != 0 {
+		chunkCount++
+	}
+
+	codeWords := []int{}
+
+	for i := 0; i < chunkCount; i++ {
+		start := i * 44
+		end := start + 44
+		if end > digitCount {
+			end = digitCount
+		}
+		chunk := digits[start:end]
+
+		chunkNum := big.NewInt(0)
+		_, ok := chunkNum.SetString("1"+string(chunk), 10)
+
+		if !ok {
+			return nil, errors.New("Failed converting: " + string(chunk))
+		}
+
+		cws := []int{}
+
+		for chunkNum.Cmp(big.NewInt(0)) > 0 {
+			newChunk, cw := chunkNum.DivMod(chunkNum, big.NewInt(900), big.NewInt(0))
+			chunkNum = newChunk
+			cws = append([]int{int(cw.Int64())}, cws...)
+		}
+
+		codeWords = append(codeWords, cws...)
+	}
+
+	return codeWords, nil
+}
+
+func determineConsecutiveTextCount(msg []rune) int {
+	result := 0
+
+	isText := func(ch rune) bool {
+		return ch == '\t' || ch == '\n' || ch == '\r' || (ch >= 32 && ch <= 126)
+	}
+
+	for i, ch := range msg {
+		numericCount := determineConsecutiveDigitCount(msg[i:])
+		if numericCount >= min_numeric_count || (numericCount == 0 && !isText(ch)) {
+			break
+		}
+
+		result++
+	}
+	return result
+}
+
+func encodeText(text []rune, submode subMode) (subMode, []int) {
+	isAlphaUpper := func(ch rune) bool {
+		return ch == ' ' || (ch >= 'A' && ch <= 'Z')
+	}
+	isAlphaLower := func(ch rune) bool {
+		return ch == ' ' || (ch >= 'a' && ch <= 'z')
+	}
+	isMixed := func(ch rune) bool {
+		_, ok := mixedMap[ch]
+		return ok
+	}
+	isPunctuation := func(ch rune) bool {
+		_, ok := punctMap[ch]
+		return ok
+	}
+
+	idx := 0
+	var tmp []int
+	for idx < len(text) {
+		ch := text[idx]
+		switch submode {
+		case subUpper:
+			if isAlphaUpper(ch) {
+				if ch == ' ' {
+					tmp = append(tmp, 26) //space
+				} else {
+					tmp = append(tmp, int(ch-'A'))
+				}
+			} else {
+				if isAlphaLower(ch) {
+					submode = subLower
+					tmp = append(tmp, 27) // lower latch
+					continue
+				} else if isMixed(ch) {
+					submode = subMixed
+					tmp = append(tmp, 28) // mixed latch
+					continue
+				} else {
+					tmp = append(tmp, 29) // punctuation switch
+					tmp = append(tmp, punctMap[ch])
+					break
+				}
+			}
+			break
+		case subLower:
+			if isAlphaLower(ch) {
+				if ch == ' ' {
+					tmp = append(tmp, 26) //space
+				} else {
+					tmp = append(tmp, int(ch-'a'))
+				}
+			} else {
+				if isAlphaUpper(ch) {
+					tmp = append(tmp, 27) //upper switch
+					tmp = append(tmp, int(ch-'A'))
+					break
+				} else if isMixed(ch) {
+					submode = subMixed
+					tmp = append(tmp, 28) //mixed latch
+					continue
+				} else {
+					tmp = append(tmp, 29) //punctuation switch
+					tmp = append(tmp, punctMap[ch])
+					break
+				}
+			}
+			break
+		case subMixed:
+			if isMixed(ch) {
+				tmp = append(tmp, mixedMap[ch])
+			} else {
+				if isAlphaUpper(ch) {
+					submode = subUpper
+					tmp = append(tmp, 28) //upper latch
+					continue
+				} else if isAlphaLower(ch) {
+					submode = subLower
+					tmp = append(tmp, 27) //lower latch
+					continue
+				} else {
+					if idx+1 < len(text) {
+						next := text[idx+1]
+						if isPunctuation(next) {
+							submode = subPunct
+							tmp = append(tmp, 25) //punctuation latch
+							continue
+						}
+					}
+					tmp = append(tmp, 29) //punctuation switch
+					tmp = append(tmp, punctMap[ch])
+				}
+			}
+			break
+		default: //subPunct
+			if isPunctuation(ch) {
+				tmp = append(tmp, punctMap[ch])
+			} else {
+				submode = subUpper
+				tmp = append(tmp, 29) //upper latch
+				continue
+			}
+		}
+		idx++
+	}
+
+	h := 0
+	result := []int{}
+	for i, val := range tmp {
+		if i%2 != 0 {
+			h = (h * 30) + val
+			result = append(result, h)
+		} else {
+			h = val
+		}
+	}
+	if len(tmp)%2 != 0 {
+		result = append(result, (h*30)+29)
+	}
+	return submode, result
+}
+
+func determineConsecutiveBinaryCount(msg []byte) int {
+	result := 0
+
+	for i, _ := range msg {
+		numericCount := determineConsecutiveDigitCount([]rune(string(msg[i:])))
+		if numericCount >= min_numeric_count {
+			break
+		}
+		textCount := determineConsecutiveTextCount([]rune(string(msg[i:])))
+		if textCount > 5 {
+			break
+		}
+		result++
+	}
+	return result
+}
+
+func encodeBinary(data []byte, startmode encodingMode) []int {
+	result := []int{}
+
+	count := len(data)
+	if count == 1 && startmode == encText {
+		result = append(result, shift_to_byte)
+	} else if (count % 6) == 0 {
+		result = append(result, latch_to_byte)
+	} else {
+		result = append(result, latch_to_byte_padded)
+	}
+
+	idx := 0
+	// Encode sixpacks
+	if count >= 6 {
+		words := make([]int, 5)
+		for (count - idx) >= 6 {
+			var t int64 = 0
+			for i := 0; i < 6; i++ {
+				t = t << 8
+				t += int64(data[idx+i])
+			}
+			for i := 0; i < 5; i++ {
+				words[4-i] = int(t % 900)
+				t = t / 900
+			}
+			result = append(result, words...)
+			idx += 6
+		}
+	}
+	//Encode rest (remaining n<5 bytes if any)
+	for i := idx; i < count; i++ {
+		result = append(result, int(data[i]&0xff))
+	}
+	return result
+}
+
+func highlevelEncode(dataStr string) ([]int, error) {
+	encodingMode := encText
+	textSubMode := subUpper
+
+	result := []int{}
+
+	data := []byte(dataStr)
+
+	for len(data) > 0 {
+		numericCount := determineConsecutiveDigitCount([]rune(string(data)))
+		if numericCount >= min_numeric_count || numericCount == len(data) {
+			result = append(result, latch_to_numeric)
+			encodingMode = encNumeric
+			textSubMode = subUpper
+			numData, err := encodeNumeric([]rune(string(data[:numericCount])))
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, numData...)
+			data = data[numericCount:]
+		} else {
+			textCount := determineConsecutiveTextCount([]rune(string(data)))
+			if textCount >= 5 || textCount == len(data) {
+				if encodingMode != encText {
+					result = append(result, latch_to_text)
+					encodingMode = encText
+					textSubMode = subUpper
+				}
+				var txtData []int
+				textSubMode, txtData = encodeText([]rune(string(data[:textCount])), textSubMode)
+				result = append(result, txtData...)
+				data = data[textCount:]
+			} else {
+				binaryCount := determineConsecutiveBinaryCount(data)
+				if binaryCount == 0 {
+					binaryCount = 1
+				}
+				bytes := data[:binaryCount]
+				if len(bytes) != 1 || encodingMode != encText {
+					encodingMode = encBinary
+					textSubMode = subUpper
+				}
+				byteData := encodeBinary(bytes, encodingMode)
+				result = append(result, byteData...)
+				data = data[binaryCount:]
+			}
+		}
+	}
+
+	return result, nil
+}

pdf417/highlevel_test.go

@@ -0,0 +1,34 @@
+package pdf417
+
+import "testing"
+
+func compareIntSlice(t *testing.T, expected, actual []int, testStr string) {
+	if len(actual) != len(expected) {
+		t.Errorf("Invalid slice size. Expected %d got %d while encoding %q", len(expected), len(actual), testStr)
+		return
+	}
+	for i, a := range actual {
+		if e := expected[i]; e != a {
+			t.Errorf("Unexpected value at position %d. Expected %d got %d while encoding %q", i, e, a, testStr)
+		}
+	}
+}
+
+func TestHighlevelEncode(t *testing.T) {
+	runTest := func(msg string, expected []int) {
+		if codes, err := highlevelEncode(msg); err != nil {
+			t.Error(err)
+		} else {
+			compareIntSlice(t, expected, codes, msg)
+		}
+	}
+
+	runTest("01234", []int{902, 112, 434})
+	runTest("Super !", []int{567, 615, 137, 809, 329})
+	runTest("Super ", []int{567, 615, 137, 809})
+	runTest("ABC123", []int{1, 88, 32, 119})
+	runTest("123ABC", []int{841, 63, 840, 32})
+
+	runTest("\x0B", []int{913, 11})
+	runTest("\x0B\x0B\x0B\x0B\x0B\x0B", []int{924, 18, 455, 694, 754, 291})
+}

pdf417/number_encoder.go

@@ -1,76 +0,0 @@
-package pdf417
-
-import (
-	"errors"
-	"math/big"
-
-	"github.com/boombuler/barcode/utils"
-)
-
-type numberEncoder struct{}
-
-func newNumberEncoder() *numberEncoder {
-	return new(numberEncoder)
-}
-
-func (encoder numberEncoder) CanEncode(char rune) bool {
-	return utils.RuneToInt(char) != -1
-}
-
-func (encoder numberEncoder) GetSwitchCode(data string) int {
-	return switchCodeNumber
-}
-
-func (encoder numberEncoder) Encode(digits string) ([]int, error) {
-	digitCount := len(digits)
-	chunkCount := digitCount / 44
-	if digitCount%44 != 0 {
-		chunkCount++
-	}
-
-	codeWords := []int{}
-
-	for i := 0; i < chunkCount; i++ {
-		start := i * 44
-		end := start + 44
-		if end > digitCount {
-			end = digitCount
-		}
-		chunk := digits[start:end]
-
-		cws, err := encodeChunk(chunk)
-		if err != nil {
-			return codeWords, err
-		}
-
-		codeWords = append(codeWords, cws...)
-	}
-
-	return codeWords, nil
-}
-
-func encodeChunk(chunkInput string) ([]int, error) {
-	chunk := big.NewInt(0)
-
-	_, ok := chunk.SetString("1"+chunkInput, 10)
-
-	if !ok {
-		return nil, errors.New("Failed converting")
-	}
-
-	cws := []int{}
-
-	for chunk.Cmp(big.NewInt(0)) > 0 {
-		newChunk, cw := chunk.DivMod(
-			chunk,
-			big.NewInt(900),
-			big.NewInt(0),
-		)
-
-		chunk = newChunk
-
-		cws = append([]int{int(cw.Int64())}, cws...)
-	}
-
-	return cws, nil
-}

pdf417/number_encoder_test.go

@@ -1,47 +0,0 @@
-package pdf417
-
-import (
-	"testing"
-)
-
-func TestNumberEncoder_CanEncode(t *testing.T) {
-	encoder := newNumberEncoder()
-
-	shouldEncode := func(tests ...rune) {
-		for _, test := range tests {
-			if !encoder.CanEncode(test) {
-				t.Errorf("NumberEncoder should be able to encode %q", string(test))
-			}
-		}
-	}
-	shouldEncode('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
-
-	shouldNotEncode := func(tests ...rune) {
-		for _, test := range tests {
-			if encoder.CanEncode(test) {
-				t.Errorf("NumberEncoder should not be able to encode %q", string(test))
-			}
-		}
-	}
-	shouldNotEncode('a', 'q', '\t')
-}
-
-func TestNumberEncoder_GetSwitchCode(t *testing.T) {
-	encoder := newNumberEncoder()
-	if sc := encoder.GetSwitchCode("123"); sc != switchCodeNumber {
-		t.Errorf("Unexpected switchcode. Got %v", sc)
-	}
-	if sc := encoder.GetSwitchCode("foo"); sc != switchCodeNumber {
-		t.Errorf("Unexpected switchcode. Got %v", sc)
-	}
-}
-
-func TestNumberEncoder_Encode(t *testing.T) {
-	encoder := newNumberEncoder()
-
-	if codes, err := encoder.Encode("01234"); err != nil {
-		t.Error(err)
-	} else {
-		compareIntSlice(t, []int{112, 434}, codes)
-	}
-}

pdf417/text_encoder.go

@@ -1,249 +0,0 @@
-package pdf417
-
-import "fmt"
-
-// Since each code word consists of 2 characters, a padding value is
-// needed when encoding a single character. 29 is used as padding because
-// it's a switch in all 4 submodes, and doesn't add any data.
-const padding_value = 29
-
-type subMode byte
-
-const (
-	subUpper subMode = iota
-	subLower
-	subMixed
-	subPunct
-)
-
-const (
-	switchUpper       = '\u00f1'
-	switchUpperSingle = '\u00f2'
-	switchLower       = '\u00f3'
-	switchMixed       = '\u00f4'
-	switchPunct       = '\u00f5'
-	switchPunctSingle = '\u00f6'
-)
-
-type textEncoder struct {
-	Switching     map[subMode]map[subMode][]rune
-	SwitchSubmode map[rune]subMode
-	ReverseLookup map[rune]map[subMode]int
-}
-
-func newTextEncoder() *textEncoder {
-	encoder := new(textEncoder)
-
-	characterTables := map[subMode][]rune{
-		subUpper: []rune{
-			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
-			'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-			'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ',
-			switchLower,
-			switchMixed,
-			switchPunctSingle,
-		},
-
-		subLower: []rune{
-			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
-			'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
-			's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' ',
-			switchUpperSingle,
-			switchMixed,
-			switchPunctSingle,
-		},
-
-		subMixed: []rune{
-			'0', '1', '2', '3', '4', '5', '6', '7', '8',
-			'9', '&', '\r', '\t', ',', ':', '#', '-', '.',
-			'$', '/', '+', '%', '*', '=', '^',
-			switchPunct, ' ',
-			switchLower,
-			switchUpper,
-			switchPunctSingle,
-		},
-
-		subPunct: []rune{
-			';', '<', '>', '@', '[', '\\', ']', '_', '`',
-			'~', '!', '\r', '\t', ',', ':', '\n', '-', '.',
-			'$', '/', 'g', '|', '*', '(', ')', '?', '{', '}', '\'',
-			switchUpper,
-		},
-	}
-
-	encoder.Switching = map[subMode]map[subMode][]rune{
-		subUpper: map[subMode][]rune{
-			subLower: []rune{switchLower},
-			subMixed: []rune{switchMixed},
-			subPunct: []rune{switchMixed, switchPunct},
-		},
-
-		subLower: map[subMode][]rune{
-			subUpper: []rune{switchMixed, switchUpper},
-			subMixed: []rune{switchMixed},
-			subPunct: []rune{switchMixed, switchPunct},
-		},
-
-		subMixed: map[subMode][]rune{
-			subUpper: []rune{switchUpper},
-			subLower: []rune{switchLower},
-			subPunct: []rune{switchPunct},
-		},
-
-		subPunct: map[subMode][]rune{
-			subUpper: []rune{switchUpper},
-			subLower: []rune{switchUpper, switchLower},
-			subMixed: []rune{switchUpper, switchMixed},
-		},
-	}
-
-	encoder.SwitchSubmode = map[rune]subMode{
-		switchUpper: subUpper,
-		switchLower: subLower,
-		switchPunct: subPunct,
-		switchMixed: subMixed,
-	}
-
-	encoder.ReverseLookup = make(map[rune]map[subMode]int)
-	for submode, codes := range characterTables {
-		for row, char := range codes {
-			if encoder.ReverseLookup[char] == nil {
-				encoder.ReverseLookup[char] = make(map[subMode]int)
-			}
-
-			encoder.ReverseLookup[char][submode] = int(row)
-		}
-	}
-
-	return encoder
-}
-
-func (encoder *textEncoder) CanEncode(char rune) bool {
-	switch char {
-	case switchUpper,
-		switchUpperSingle,
-		switchLower,
-		switchMixed,
-		switchPunct,
-		switchPunctSingle:
-		return false
-	default:
-		return encoder.ReverseLookup[char] != nil
-	}
-}
-
-func (*textEncoder) GetSwitchCode(data string) int {
-	return switchCodeText
-}
-
-func (encoder *textEncoder) Encode(data string) ([]int, error) {
-	interim, err := encoder.encodeInterim(data)
-	if err != nil {
-		return interim, err
-	}
-
-	return encoder.encodeFinal(interim), nil
-}
-
-func (encoder *textEncoder) encodeInterim(data string) ([]int, error) {
-	submode := subUpper
-
-	codes := []int{}
-	var err error
-	for _, char := range data {
-		if !encoder.existsInSubmode(char, submode) {
-			prevSubmode := submode
-
-			submode, err = encoder.getSubmode(char)
-			if err != nil {
-				return codes, err
-			}
-
-			switchCodes := encoder.getSwitchCodes(prevSubmode, submode)
-
-			codes = append(codes, switchCodes...)
-		}
-
-		codes = append(
-			codes,
-			encoder.getCharacterCode(char, submode),
-		)
-	}
-
-	return codes, nil
-}
-
-func (encoder *textEncoder) getSubmode(char rune) (subMode, error) {
-	if lookup, ok := encoder.ReverseLookup[char]; ok {
-		for key := range lookup {
-			return key, nil
-		}
-	}
-	return subLower, fmt.Errorf("unable to find submode for %q", char)
-}
-
-func (encoder *textEncoder) getSwitchCodes(from, to subMode) []int {
-	switches := encoder.Switching[from][to]
-
-	codes := []int{}
-
-	for _, switcher := range switches {
-		codes = append(codes, encoder.getCharacterCode(switcher, from))
-
-		from = encoder.SwitchSubmode[switcher]
-	}
-
-	return codes
-}
-
-func (*textEncoder) encodeFinal(codes []int) []int {
-	codeWords := []int{}
-
-	chunks := [][]int{}
-	chunkPart := []int{}
-	i := 0
-	for _, code := range codes {
-		chunkPart = append(chunkPart, code)
-
-		i++
-
-		if i%2 == 0 {
-			chunks = append(chunks, chunkPart)
-
-			chunkPart = []int{}
-		}
-	}
-
-	if len(chunkPart) > 0 {
-		chunks = append(chunks, chunkPart)
-	}
-
-	for _, chunk := range chunks {
-		if len(chunk) == 1 {
-			chunk = append(chunk, padding_value)
-		}
-
-		codeWords = append(
-			codeWords,
-			30*chunk[0]+chunk[1],
-		)
-	}
-
-	return codeWords
-}
-
-func (encoder *textEncoder) getCharacterCode(char rune, submode subMode) int {
-	cw, ok := encoder.ReverseLookup[char][submode]
-
-	if !ok {
-		panic("This is not possible")
-	}
-
-	return cw
-}
-
-func (encoder *textEncoder) existsInSubmode(char rune, submode subMode) bool {
-	_, ok := encoder.ReverseLookup[char][submode]
-
-	return ok
-}

pdf417/text_encoder_test.go

@@ -1,59 +0,0 @@
-package pdf417
-
-import (
-	"testing"
-)
-
-func compareIntSlice(t *testing.T, expected, actual []int) {
-	if len(actual) != len(expected) {
-		t.Errorf("Invalid slice size. Expected %d got %d", len(expected), len(actual))
-		return
-	}
-	for i, a := range actual {
-		if e := expected[i]; e != a {
-			t.Errorf("Unexpected value at position %d. Expected %d got %d", i, e, a)
-		}
-	}
-}
-
-func TestTextEncoder_CanEncode(t *testing.T) {
-	encoder := newTextEncoder()
-
-	for ord := int(' '); ord < int('Z'); ord++ {
-		chr := rune(ord)
-
-		if chr == '"' {
-			continue
-		}
-
-		if !encoder.CanEncode(chr) {
-			t.Errorf("Unable to encode: %d %c", ord, chr)
-		}
-	}
-}
-
-func TestTextEncoder_GetSwitchCode(t *testing.T) {
-	encoder := newTextEncoder()
-	if sc := encoder.GetSwitchCode("123"); sc != switchCodeText {
-		t.Errorf("Unexpected switchcode. Got %v", sc)
-	}
-	if sc := encoder.GetSwitchCode("foo"); sc != switchCodeText {
-		t.Errorf("Unexpected switchcode. Got %v", sc)
-	}
-}
-
-func TestTextEncoder_Encode(t *testing.T) {
-	encoder := newTextEncoder()
-
-	if codes, err := encoder.Encode("Super !"); err != nil {
-		t.Error(err)
-	} else {
-		compareIntSlice(t, []int{567, 615, 137, 808, 760}, codes)
-	}
-
-	if codes, err := encoder.Encode("Super "); err != nil {
-		t.Error(err)
-	} else {
-		compareIntSlice(t, []int{567, 615, 137, 809}, codes)
-	}
-}