base.go

package k4id

import (
	"bytes"
	"errors"
)

var Base36 = NewBase([]rune("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
var Base63 = NewBase([]rune("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz?"))

func NewBase(alpha []rune) *Base {
	b := &Base{
		base:    len(alpha),
		alpha:   alpha,
		baseMap: make(map[rune]int),
	}

	for i := 0; i < b.base; i++ {
		b.baseMap[b.alpha[i]] = i
	}
	return b
}

type Base struct {
	base    int
	alpha   []rune
	baseMap map[rune]int
}

func (b Base) Encode(source []byte) string {
	if len(source) == 0 {
		return ""
	}

	digits := []int{0}

	for i := 0; i < len(source); i++ {
		carry := int(source[i])

		for j := 0; j < len(digits); j++ {
			carry += digits[j] << 8
			digits[j] = carry % b.base
			carry = carry / b.base
		}

		for carry > 0 {
			digits = append(digits, carry%b.base)
			carry = carry / b.base
		}
	}

	var res bytes.Buffer

	for k := 0; source[k] == 0 && k < len(source)-1; k++ {
		res.WriteRune(b.alpha[0])
	}

	for q := len(digits) - 1; q >= 0; q-- {
		res.WriteRune(b.alpha[digits[q]])
	}

	return res.String()
}

func (b Base) Decode(source string) ([]byte, error) {
	if len(source) == 0 {
		return []byte{}, nil
	}

	runes := []rune(source)

	byts := []byte{0}
	for i := 0; i < len(runes); i++ {
		value, ok := b.baseMap[runes[i]]

		if !ok {
			return nil, errors.New("non base62 character")
		}

		carry := value

		for j := 0; j < len(byts); j++ {
			carry += int(byts[j]) * b.base
			byts[j] = byte(carry & 0xff)
			carry >>= 8
		}

		for carry > 0 {
			byts = append(byts, byte(carry&0xff))
			carry >>= 8
		}
	}

	for k := 0; runes[k] == b.alpha[0] && k < len(runes)-1; k++ {
		byts = append(byts, 0)
	}

	// Reverse bytes
	for i, j := 0, len(byts)-1; i < j; i, j = i+1, j-1 {
		byts[i], byts[j] = byts[j], byts[i]
	}

	return byts, nil
}