summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/message/catalog/dict.go
blob: a0eb81810bafec4735222e856de2a5370f580ba7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// 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
}