status-go/vendor/github.com/russolsen/transit/rolling_cache.go

129 lines
3.2 KiB
Go

// Copyright 2016 Russ Olsen. All Rights Reserved.
//
// This code is a Go port of the Java version created and maintained by Cognitect, therefore:
//
// Copyright 2014 Cognitect. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package transit
import (
"fmt"
)
const cacheCodeDigits = 44
const baseCharIndex = 48
const firstOrd = 48
const cacheSize = (cacheCodeDigits * cacheCodeDigits)
const minSizeCacheable = 4
type StringMap map[string]string
type RollingCache struct {
keyToValue StringMap
valueToKey StringMap
}
func NewRollingCache() *RollingCache {
return &RollingCache{keyToValue: make(StringMap), valueToKey: make(StringMap)}
}
func (rc *RollingCache) String() string {
return fmt.Sprintf("Cache: %v", rc.keyToValue)
}
func (rc *RollingCache) HasKey(name string) bool {
_, present := rc.keyToValue[name]
return present
}
func (rc *RollingCache) Read(name string) string {
return rc.keyToValue[name]
}
// Enter the name into the cache if it passes the cacheable critieria.
// Returns either the name or the value that was previously cached for
// the name.
func (rc *RollingCache) Write(name string) string {
existing_key, present := rc.valueToKey[name]
if present {
return existing_key
}
if rc.isCacheFull() {
rc.Clear()
}
var key = rc.encodeKey(len(rc.keyToValue))
rc.keyToValue[key] = name
rc.valueToKey[name] = key
return name
}
// IsCacheable returns true if the string is long enough to be cached
// and either asKey is true or the string represents a symbol, keyword
// or tag.
func (rc *RollingCache) IsCacheable(s string, asKey bool) bool {
if len(s) < minSizeCacheable {
return false
} else if asKey {
return true
} else {
var firstTwo = s[0:2]
//return firstTwo == "~#" || firstTwo == "~$" || firstTwo == "~:"
return firstTwo == startTag || firstTwo == startKW || firstTwo == startSym
}
}
// IsCacheKey returns true if the string looks like a cache key.
func (rc *RollingCache) IsCacheKey(name string) bool {
if len(name) == 0 {
return false
} else if (name[0:1] == sub) && (name != mapAsArray) {
return true
} else {
return false
}
}
func (rc *RollingCache) encodeKey(index int) string {
var hi = index / cacheCodeDigits
var lo = index % cacheCodeDigits
if hi == 0 {
return sub + string(lo+baseCharIndex)
} else {
return sub + string(hi+baseCharIndex) + string(lo+baseCharIndex)
}
}
func (rc *RollingCache) codeToIndex(s string) int {
var sz = len(s)
if sz == 2 {
return int(s[1]) - baseCharIndex
} else {
return ((int(s[1]) - baseCharIndex) * cacheCodeDigits) + (int(s[2]) - baseCharIndex)
}
}
func (rc *RollingCache) isCacheFull() bool {
return len(rc.keyToValue) >= cacheSize
}
func (rc *RollingCache) Clear() {
rc.valueToKey = make(StringMap)
rc.keyToValue = make(StringMap)
}