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
5package language
6
7import (
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.
18type 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
32var (
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
43type 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.
48func (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.
59func (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.
69func (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.
79func (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.
88type coverage struct {
89	tags    func() []Tag
90	bases   func() []Base
91	scripts func() []Script
92	regions func() []Region
93}
94
95func (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.
103type bases []Base
104
105func (b bases) Len() int {
106	return len(b)
107}
108
109func (b bases) Swap(i, j int) {
110	b[i], b[j] = b[j], b[i]
111}
112
113func (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.
119func (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
142func (s *coverage) Scripts() []Script {
143	if s.scripts == nil {
144		return nil
145	}
146	return s.scripts()
147}
148
149func (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.
162func 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