mirror of
https://github.com/restic/restic.git
synced 2024-08-21 11:53:22 +02:00
Among others, this updates minio-go, so that the new "eu-west-3" zone for AWS is supported.
130 lines
2.8 KiB
Go
130 lines
2.8 KiB
Go
// Copyright 2017 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package catalog
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"golang.org/x/text/internal"
|
|
"golang.org/x/text/internal/catmsg"
|
|
"golang.org/x/text/language"
|
|
)
|
|
|
|
// TODO:
|
|
// Dictionary returns a Dictionary that returns the first Message, using the
|
|
// given language tag, that matches:
|
|
// 1. the last one registered by one of the Set methods
|
|
// 2. returned by one of the Loaders
|
|
// 3. repeat from 1. using the parent language
|
|
// This approach allows messages to be underspecified.
|
|
// func (c *Catalog) Dictionary(tag language.Tag) (Dictionary, error) {
|
|
// // TODO: verify dictionary exists.
|
|
// return &dict{&c.index, tag}, nil
|
|
// }
|
|
|
|
type dict struct {
|
|
s *store
|
|
tag language.Tag // TODO: make compact tag.
|
|
}
|
|
|
|
func (d *dict) Lookup(key string) (data string, ok bool) {
|
|
return d.s.lookup(d.tag, key)
|
|
}
|
|
|
|
func (b *Builder) lookup(tag language.Tag, key string) (data string, ok bool) {
|
|
return b.index.lookup(tag, key)
|
|
}
|
|
|
|
func (c *Builder) set(tag language.Tag, key string, s *store, msg ...Message) error {
|
|
data, err := catmsg.Compile(tag, &dict{&c.macros, tag}, firstInSequence(msg))
|
|
|
|
s.mutex.Lock()
|
|
defer s.mutex.Unlock()
|
|
|
|
m := s.index[tag]
|
|
if m == nil {
|
|
m = msgMap{}
|
|
if s.index == nil {
|
|
s.index = map[language.Tag]msgMap{}
|
|
}
|
|
c.matcher = nil
|
|
s.index[tag] = m
|
|
}
|
|
|
|
m[key] = data
|
|
return err
|
|
}
|
|
|
|
func (c *Builder) Matcher() language.Matcher {
|
|
c.index.mutex.RLock()
|
|
m := c.matcher
|
|
c.index.mutex.RUnlock()
|
|
if m != nil {
|
|
return m
|
|
}
|
|
|
|
c.index.mutex.Lock()
|
|
if c.matcher == nil {
|
|
c.matcher = language.NewMatcher(c.unlockedLanguages())
|
|
}
|
|
m = c.matcher
|
|
c.index.mutex.Unlock()
|
|
return m
|
|
}
|
|
|
|
type store struct {
|
|
mutex sync.RWMutex
|
|
index map[language.Tag]msgMap
|
|
}
|
|
|
|
type msgMap map[string]string
|
|
|
|
func (s *store) lookup(tag language.Tag, key string) (data string, ok bool) {
|
|
s.mutex.RLock()
|
|
defer s.mutex.RUnlock()
|
|
|
|
for ; ; tag = tag.Parent() {
|
|
if msgs, ok := s.index[tag]; ok {
|
|
if msg, ok := msgs[key]; ok {
|
|
return msg, true
|
|
}
|
|
}
|
|
if tag == language.Und {
|
|
break
|
|
}
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
// Languages returns all languages for which the Catalog contains variants.
|
|
func (b *Builder) Languages() []language.Tag {
|
|
s := &b.index
|
|
s.mutex.RLock()
|
|
defer s.mutex.RUnlock()
|
|
|
|
return b.unlockedLanguages()
|
|
}
|
|
|
|
func (b *Builder) unlockedLanguages() []language.Tag {
|
|
s := &b.index
|
|
if len(s.index) == 0 {
|
|
return nil
|
|
}
|
|
tags := make([]language.Tag, 0, len(s.index))
|
|
_, hasFallback := s.index[b.options.fallback]
|
|
offset := 0
|
|
if hasFallback {
|
|
tags = append(tags, b.options.fallback)
|
|
offset = 1
|
|
}
|
|
for t := range s.index {
|
|
if t != b.options.fallback {
|
|
tags = append(tags, t)
|
|
}
|
|
}
|
|
internal.SortTags(tags[offset:])
|
|
return tags
|
|
}
|