rss-tools @ master

// 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

}