1 // Copyright 2014 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4 5 package language
6 7 import (
8 "fmt"
9 "sort"
10 11 "golang.org/x/text/internal/language"
12 )
13 14 // The Coverage interface is used to define the level of coverage of an
15 // internationalization service. Note that not all types are supported by all
16 // services. As lists may be generated on the fly, it is recommended that users
17 // of a Coverage cache the results.
18 type Coverage interface {
19 // Tags returns the list of supported tags.
20 Tags() []Tag
21 22 // BaseLanguages returns the list of supported base languages.
23 BaseLanguages() []Base
24 25 // Scripts returns the list of supported scripts.
26 Scripts() []Script
27 28 // Regions returns the list of supported regions.
29 Regions() []Region
30 }
31 32 var (
33 // Supported defines a Coverage that lists all supported subtags. Tags
34 // always returns nil.
35 Supported Coverage = allSubtags{}
36 )
37 38 // TODO:
39 // - Support Variants, numbering systems.
40 // - CLDR coverage levels.
41 // - Set of common tags defined in this package.
42 43 type allSubtags struct{}
44 45 // Regions returns the list of supported regions. As all regions are in a
46 // consecutive range, it simply returns a slice of numbers in increasing order.
47 // The "undefined" region is not returned.
48 func (s allSubtags) Regions() []Region {
49 reg := make([]Region, language.NumRegions)
50 for i := range reg {
51 reg[i] = Region{language.Region(i + 1)}
52 }
53 return reg
54 }
55 56 // Scripts returns the list of supported scripts. As all scripts are in a
57 // consecutive range, it simply returns a slice of numbers in increasing order.
58 // The "undefined" script is not returned.
59 func (s allSubtags) Scripts() []Script {
60 scr := make([]Script, language.NumScripts)
61 for i := range scr {
62 scr[i] = Script{language.Script(i + 1)}
63 }
64 return scr
65 }
66 67 // BaseLanguages returns the list of all supported base languages. It generates
68 // the list by traversing the internal structures.
69 func (s allSubtags) BaseLanguages() []Base {
70 bs := language.BaseLanguages()
71 base := make([]Base, len(bs))
72 for i, b := range bs {
73 base[i] = Base{b}
74 }
75 return base
76 }
77 78 // Tags always returns nil.
79 func (s allSubtags) Tags() []Tag {
80 return nil
81 }
82 83 // coverage is used by NewCoverage which is used as a convenient way for
84 // creating Coverage implementations for partially defined data. Very often a
85 // package will only need to define a subset of slices. coverage provides a
86 // convenient way to do this. Moreover, packages using NewCoverage, instead of
87 // their own implementation, will not break if later new slice types are added.
88 type coverage struct {
89 tags func() []Tag
90 bases func() []Base
91 scripts func() []Script
92 regions func() []Region
93 }
94 95 func (s *coverage) Tags() []Tag {
96 if s.tags == nil {
97 return nil
98 }
99 return s.tags()
100 }
101 102 // bases implements sort.Interface and is used to sort base languages.
103 type bases []Base
104 105 func (b bases) Len() int {
106 return len(b)
107 }
108 109 func (b bases) Swap(i, j int) {
110 b[i], b[j] = b[j], b[i]
111 }
112 113 func (b bases) Less(i, j int) bool {
114 return b[i].langID < b[j].langID
115 }
116 117 // BaseLanguages returns the result from calling s.bases if it is specified or
118 // otherwise derives the set of supported base languages from tags.
119 func (s *coverage) BaseLanguages() []Base {
120 if s.bases == nil {
121 tags := s.Tags()
122 if len(tags) == 0 {
123 return nil
124 }
125 a := make([]Base, len(tags))
126 for i, t := range tags {
127 a[i] = Base{language.Language(t.lang())}
128 }
129 sort.Sort(bases(a))
130 k := 0
131 for i := 1; i < len(a); i++ {
132 if a[k] != a[i] {
133 k++
134 a[k] = a[i]
135 }
136 }
137 return a[:k+1]
138 }
139 return s.bases()
140 }
141 142 func (s *coverage) Scripts() []Script {
143 if s.scripts == nil {
144 return nil
145 }
146 return s.scripts()
147 }
148 149 func (s *coverage) Regions() []Region {
150 if s.regions == nil {
151 return nil
152 }
153 return s.regions()
154 }
155 156 // NewCoverage returns a Coverage for the given lists. It is typically used by
157 // packages providing internationalization services to define their level of
158 // coverage. A list may be of type []T or func() []T, where T is either Tag,
159 // Base, Script or Region. The returned Coverage derives the value for Bases
160 // from Tags if no func or slice for []Base is specified. For other unspecified
161 // types the returned Coverage will return nil for the respective methods.
162 func NewCoverage(list ...interface{}) Coverage {
163 s := &coverage{}
164 for _, x := range list {
165 switch v := x.(type) {
166 case func() []Base:
167 s.bases = v
168 case func() []Script:
169 s.scripts = v
170 case func() []Region:
171 s.regions = v
172 case func() []Tag:
173 s.tags = v
174 case []Base:
175 s.bases = func() []Base { return v }
176 case []Script:
177 s.scripts = func() []Script { return v }
178 case []Region:
179 s.regions = func() []Region { return v }
180 case []Tag:
181 s.tags = func() []Tag { return v }
182 default:
183 panic(fmt.Sprintf("language: unsupported set type %T", v))
184 }
185 }
186 return s
187 }
188