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

189