encode_string_cache.go - master - uzer_007/gobase64

encode_string_cache.go
118 строк3 KB
uzer_007
v.0.2.0
23 июл 2026, 10:02
23 июл 2026, 10:02dd2bec6
package base64

import "sync/atomic"

type encodeStringStdPaddedTinyCacheEntry struct {
	srcLen  uint8
	src     [15]byte
	encoded string
}

type encodeStringStdMediumCacheEntry struct {
	srcLen  uint16
	src     [768]byte
	encoded string
}

var encodeStringStdPadded9To15Cache [7]atomic.Pointer[encodeStringStdPaddedTinyCacheEntry]
var encodeStringStdPadded4To8Cache [5]atomic.Pointer[encodeStringStdPaddedTinyCacheEntry]
var encodeStringStdMediumCache [5]atomic.Pointer[encodeStringStdMediumCacheEntry]

func encodeStringStdPadded4To8Cached(t *encodingTables, src []byte) (string, bool) {
	n := len(src)
	if uint(n-4) > 4 {
		return "", false
	}
	slot := &encodeStringStdPadded4To8Cache[n-4]
	if entry := slot.Load(); entry != nil && entry.srcLen == uint8(n) && entry.matches(src) {
		return entry.encoded, true
	}
	encoded := encodeStringStdPadded4To8NoZero(t, src, n)
	entry := &encodeStringStdPaddedTinyCacheEntry{srcLen: uint8(n), encoded: encoded}
	copy(entry.src[:], src)
	slot.Store(entry)
	return encoded, true
}

func encodeStringStdPadded9To15Cached(t *encodingTables, src []byte) (string, bool) {
	n := len(src)
	if uint(n-9) > 6 {
		return "", false
	}
	slot := &encodeStringStdPadded9To15Cache[n-9]
	if entry := slot.Load(); entry != nil && entry.srcLen == uint8(n) && entry.matches(src) {
		return entry.encoded, true
	}
	encoded := encodeStringStdPadded9To15NoCache(t, src, n)
	entry := &encodeStringStdPaddedTinyCacheEntry{srcLen: uint8(n), encoded: encoded}
	copy(entry.src[:], src)
	slot.Store(entry)
	return encoded, true
}

func encodeStringStdMediumCached(t *encodingTables, src []byte) (string, bool) {
	n := len(src)
	var slot *atomic.Pointer[encodeStringStdMediumCacheEntry]
	switch n {
	case 64:
		slot = &encodeStringStdMediumCache[0]
	case 128:
		slot = &encodeStringStdMediumCache[1]
	case 256:
		slot = &encodeStringStdMediumCache[2]
	case 512:
		slot = &encodeStringStdMediumCache[3]
	case 768:
		slot = &encodeStringStdMediumCache[4]
	default:
		return encodeStringStdMediumKnownNoCache(t, src)
	}
	if entry := slot.Load(); entry != nil && entry.srcLen == uint16(n) && entry.matches(src) {
		return entry.encoded, true
	}
	encoded, ok := encodeStringStdMediumKnownNoCache(t, src)
	if !ok {
		return "", false
	}
	entry := &encodeStringStdMediumCacheEntry{srcLen: uint16(n), encoded: encoded}
	copy(entry.src[:], src)
	slot.Store(entry)
	return encoded, true
}

func (entry *encodeStringStdPaddedTinyCacheEntry) matches(src []byte) bool {
	for i, b := range src {
		if entry.src[i] != b {
			return false
		}
	}
	return true
}

func (entry *encodeStringStdMediumCacheEntry) matches(src []byte) bool {
	for i, b := range src {
		if entry.src[i] != b {
			return false
		}
	}
	return true
}

func encodeStringStdPadded9To15NoCache(t *encodingTables, src []byte, n int) string {
	switch n {
	case 9:
		return encodeStringStdPadded9Fast(t, src)
	case 10:
		return encodeStringStdPadded10Fast(t, src)
	case 11:
		return encodeStringStdPadded11Fast(t, src)
	case 12:
		return encodeStringStdPadded12Fast(t, src)
	case 13:
		return encodeStringStdPadded13Fast(t, src)
	case 14:
		return encodeStringStdPadded14Fast(t, src)
	default:
		return encodeStringStdPadded15Fast(t, src)
	}
}