ml
115 lines
2.9 KiB
Go
115 lines
2.9 KiB
Go
package text
|
|
|
|
import (
|
|
"io/ioutil"
|
|
|
|
"github.com/inkyblackness/hacked/ss1/resource"
|
|
)
|
|
|
|
type keyResolver func(resource.Key) resource.Key
|
|
type textReader func(resource.Selector, resource.Key, Codepage) (string, error)
|
|
|
|
// Cache retrieves texts from a localizer and keeps them decoded until they are invalidated.
|
|
type Cache struct {
|
|
cp Codepage
|
|
localizer resource.Localizer
|
|
reader textReader
|
|
|
|
keyResolver keyResolver
|
|
texts map[resource.Key]string
|
|
}
|
|
|
|
func newCache(cp Codepage, localizer resource.Localizer, keyResolver keyResolver, reader textReader) *Cache {
|
|
cache := &Cache{
|
|
cp: cp,
|
|
localizer: localizer,
|
|
reader: reader,
|
|
|
|
keyResolver: keyResolver,
|
|
texts: make(map[resource.Key]string),
|
|
}
|
|
return cache
|
|
}
|
|
|
|
// NewLineCache returns a cache for single-block texts.
|
|
func NewLineCache(cp Codepage, localizer resource.Localizer) *Cache {
|
|
return newCache(cp, localizer, func(key resource.Key) resource.Key { return key }, readLine)
|
|
}
|
|
|
|
// NewPageCache returns a cache for resource-based texts.
|
|
func NewPageCache(cp Codepage, localizer resource.Localizer) *Cache {
|
|
return newCache(cp, localizer, func(key resource.Key) resource.Key {
|
|
return resource.KeyOf(key.ID.Plus(key.Index), key.Lang, 0)
|
|
}, readPage)
|
|
}
|
|
|
|
func readLine(selector resource.Selector, key resource.Key, cp Codepage) (string, error) {
|
|
view, err := selector.Select(key.ID)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if view.ContentType() != resource.Text {
|
|
return "", resource.ErrWrongType(key, resource.Text)
|
|
}
|
|
reader, err := view.Block(key.Index)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
raw, err := ioutil.ReadAll(reader)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return cp.Decode(raw), nil
|
|
}
|
|
|
|
func readPage(selector resource.Selector, key resource.Key, cp Codepage) (string, error) {
|
|
view, err := selector.Select(key.ID.Plus(key.Index))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if view.ContentType() != resource.Text {
|
|
return "", resource.ErrWrongType(key, resource.Text)
|
|
}
|
|
blockCount := view.BlockCount()
|
|
value := ""
|
|
for block := 0; block < blockCount; block++ {
|
|
reader, err := view.Block(block)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
raw, err := ioutil.ReadAll(reader)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
value += cp.Decode(raw)
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
// InvalidateResources lets the cache remove any texts from resources that are specified in the given slice.
|
|
func (cache *Cache) InvalidateResources(ids []resource.ID) {
|
|
for _, id := range ids {
|
|
for key := range cache.texts {
|
|
if key.ID == id {
|
|
delete(cache.texts, key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Text retrieves and caches the text of given key.
|
|
func (cache *Cache) Text(key resource.Key) (string, error) {
|
|
cacheKey := cache.keyResolver(key)
|
|
value, existing := cache.texts[cacheKey]
|
|
if existing {
|
|
return value, nil
|
|
}
|
|
selector := cache.localizer.LocalizedResources(key.Lang)
|
|
value, err := cache.reader(selector, key, cache.cp)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
cache.texts[cacheKey] = value
|
|
return value, nil
|
|
}
|