gtsocial-umbx

coverage.go (4897B)

---

 // Copyright 2014 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 language
 
 import (
 	"fmt"
 	"sort"
 
 	"golang.org/x/text/internal/language"
 )
 
 // The Coverage interface is used to define the level of coverage of an
 // internationalization service. Note that not all types are supported by all
 // services. As lists may be generated on the fly, it is recommended that users
 // of a Coverage cache the results.
 type Coverage interface {
 	// Tags returns the list of supported tags.
 	Tags() []Tag
 
 	// BaseLanguages returns the list of supported base languages.
 	BaseLanguages() []Base
 
 	// Scripts returns the list of supported scripts.
 	Scripts() []Script
 
 	// Regions returns the list of supported regions.
 	Regions() []Region
 }
 
 var (
 	// Supported defines a Coverage that lists all supported subtags. Tags
 	// always returns nil.
 	Supported Coverage = allSubtags{}
 )
 
 // TODO:
 // - Support Variants, numbering systems.
 // - CLDR coverage levels.
 // - Set of common tags defined in this package.
 
 type allSubtags struct{}
 
 // Regions returns the list of supported regions. As all regions are in a
 // consecutive range, it simply returns a slice of numbers in increasing order.
 // The "undefined" region is not returned.
 func (s allSubtags) Regions() []Region {
 	reg := make([]Region, language.NumRegions)
 	for i := range reg {
 		reg[i] = Region{language.Region(i + 1)}
 	}
 	return reg
 }
 
 // Scripts returns the list of supported scripts. As all scripts are in a
 // consecutive range, it simply returns a slice of numbers in increasing order.
 // The "undefined" script is not returned.
 func (s allSubtags) Scripts() []Script {
 	scr := make([]Script, language.NumScripts)
 	for i := range scr {
 		scr[i] = Script{language.Script(i + 1)}
 	}
 	return scr
 }
 
 // BaseLanguages returns the list of all supported base languages. It generates
 // the list by traversing the internal structures.
 func (s allSubtags) BaseLanguages() []Base {
 	bs := language.BaseLanguages()
 	base := make([]Base, len(bs))
 	for i, b := range bs {
 		base[i] = Base{b}
 	}
 	return base
 }
 
 // Tags always returns nil.
 func (s allSubtags) Tags() []Tag {
 	return nil
 }
 
 // coverage is used by NewCoverage which is used as a convenient way for
 // creating Coverage implementations for partially defined data. Very often a
 // package will only need to define a subset of slices. coverage provides a
 // convenient way to do this. Moreover, packages using NewCoverage, instead of
 // their own implementation, will not break if later new slice types are added.
 type coverage struct {
 	tags    func() []Tag
 	bases   func() []Base
 	scripts func() []Script
 	regions func() []Region
 }
 
 func (s *coverage) Tags() []Tag {
 	if s.tags == nil {
 		return nil
 	}
 	return s.tags()
 }
 
 // bases implements sort.Interface and is used to sort base languages.
 type bases []Base
 
 func (b bases) Len() int {
 	return len(b)
 }
 
 func (b bases) Swap(i, j int) {
 	b[i], b[j] = b[j], b[i]
 }
 
 func (b bases) Less(i, j int) bool {
 	return b[i].langID < b[j].langID
 }
 
 // BaseLanguages returns the result from calling s.bases if it is specified or
 // otherwise derives the set of supported base languages from tags.
 func (s *coverage) BaseLanguages() []Base {
 	if s.bases == nil {
 		tags := s.Tags()
 		if len(tags) == 0 {
 			return nil
 		}
 		a := make([]Base, len(tags))
 		for i, t := range tags {
 			a[i] = Base{language.Language(t.lang())}
 		}
 		sort.Sort(bases(a))
 		k := 0
 		for i := 1; i < len(a); i++ {
 			if a[k] != a[i] {
 				k++
 				a[k] = a[i]
 			}
 		}
 		return a[:k+1]
 	}
 	return s.bases()
 }
 
 func (s *coverage) Scripts() []Script {
 	if s.scripts == nil {
 		return nil
 	}
 	return s.scripts()
 }
 
 func (s *coverage) Regions() []Region {
 	if s.regions == nil {
 		return nil
 	}
 	return s.regions()
 }
 
 // NewCoverage returns a Coverage for the given lists. It is typically used by
 // packages providing internationalization services to define their level of
 // coverage. A list may be of type []T or func() []T, where T is either Tag,
 // Base, Script or Region. The returned Coverage derives the value for Bases
 // from Tags if no func or slice for []Base is specified. For other unspecified
 // types the returned Coverage will return nil for the respective methods.
 func NewCoverage(list ...interface{}) Coverage {
 	s := &coverage{}
 	for _, x := range list {
 		switch v := x.(type) {
 		case func() []Base:
 			s.bases = v
 		case func() []Script:
 			s.scripts = v
 		case func() []Region:
 			s.regions = v
 		case func() []Tag:
 			s.tags = v
 		case []Base:
 			s.bases = func() []Base { return v }
 		case []Script:
 			s.scripts = func() []Script { return v }
 		case []Region:
 			s.regions = func() []Region { return v }
 		case []Tag:
 			s.tags = func() []Tag { return v }
 		default:
 			panic(fmt.Sprintf("language: unsupported set type %T", v))
 		}
 	}
 	return s
 }