new repo

[bytom/vapor.git] / vendor / golang.org / x / text / language / display / display.go

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

//go:generate go run maketables.go -output tables.go

// Package display provides display names for languages, scripts and regions in
// a requested language.
//
// The data is based on CLDR's localeDisplayNames. It includes the names of the
// draft level "contributed" or "approved". The resulting tables are quite
// large. The display package is designed so that users can reduce the linked-in
// table sizes by cherry picking the languages one wishes to support. There is a
// Dictionary defined for a selected set of common languages for this purpose.
package display // import "golang.org/x/text/language/display"

import (
        "strings"

        "golang.org/x/text/language"
)

/*
TODO:
All fairly low priority at the moment:
  - Include alternative and variants as an option (using func options).
  - Option for returning the empty string for undefined values.
  - Support variants, currencies, time zones, option names and other data
    provided in CLDR.
  - Do various optimizations:
    - Reduce size of offset tables.
    - Consider compressing infrequently used languages and decompress on demand.
*/

// A Namer is used to get the name for a given value, such as a Tag, Language,
// Script or Region.
type Namer interface {
        // Name returns a display string for the given value. A Namer returns an
        // empty string for values it does not support. A Namer may support naming
        // an unspecified value. For example, when getting the name for a region for
        // a tag that does not have a defined Region, it may return the name for an
        // unknown region. It is up to the user to filter calls to Name for values
        // for which one does not want to have a name string.
        Name(x interface{}) string
}

var (
        // Supported lists the languages for which names are defined.
        Supported language.Coverage

        // The set of all possible values for which names are defined. Note that not
        // all Namer implementations will cover all the values of a given type.
        // A Namer will return the empty string for unsupported values.
        Values language.Coverage

        matcher language.Matcher
)

func init() {
        tags := make([]language.Tag, numSupported)
        s := supported
        for i := range tags {
                p := strings.IndexByte(s, '|')
                tags[i] = language.Raw.Make(s[:p])
                s = s[p+1:]
        }
        matcher = language.NewMatcher(tags)
        Supported = language.NewCoverage(tags)

        Values = language.NewCoverage(langTagSet.Tags, supportedScripts, supportedRegions)
}

// Languages returns a Namer for naming languages. It returns nil if there is no
// data for the given tag. The type passed to Name must be either language.Base
// or language.Tag. Note that the result may differ between passing a tag or its
// base language. For example, for English, passing "nl-BE" would return Flemish
// whereas passing "nl" returns "Dutch".
func Languages(t language.Tag) Namer {
        if _, index, conf := matcher.Match(t); conf != language.No {
                return languageNamer(index)
        }
        return nil
}

type languageNamer int

func (n languageNamer) name(i int) string {
        return lookup(langHeaders[:], int(n), i)
}

// Name implements the Namer interface for language names.
func (n languageNamer) Name(x interface{}) string {
        return nameLanguage(n, x)
}

// nonEmptyIndex walks up the parent chain until a non-empty header is found.
// It returns -1 if no index could be found.
func nonEmptyIndex(h []header, index int) int {
        for ; index != -1 && h[index].data == ""; index = int(parents[index]) {
        }
        return index
}

// Scripts returns a Namer for naming scripts. It returns nil if there is no
// data for the given tag. The type passed to Name must be either a
// language.Script or a language.Tag. It will not attempt to infer a script for
// tags with an unspecified script.
func Scripts(t language.Tag) Namer {
        if _, index, conf := matcher.Match(t); conf != language.No {
                if index = nonEmptyIndex(scriptHeaders[:], index); index != -1 {
                        return scriptNamer(index)
                }
        }
        return nil
}

type scriptNamer int

func (n scriptNamer) name(i int) string {
        return lookup(scriptHeaders[:], int(n), i)
}

// Name implements the Namer interface for script names.
func (n scriptNamer) Name(x interface{}) string {
        return nameScript(n, x)
}

// Regions returns a Namer for naming regions. It returns nil if there is no
// data for the given tag. The type passed to Name must be either a
// language.Region or a language.Tag. It will not attempt to infer a region for
// tags with an unspecified region.
func Regions(t language.Tag) Namer {
        if _, index, conf := matcher.Match(t); conf != language.No {
                if index = nonEmptyIndex(regionHeaders[:], index); index != -1 {
                        return regionNamer(index)
                }
        }
        return nil
}

type regionNamer int

func (n regionNamer) name(i int) string {
        return lookup(regionHeaders[:], int(n), i)
}

// Name implements the Namer interface for region names.
func (n regionNamer) Name(x interface{}) string {
        return nameRegion(n, x)
}

// Tags returns a Namer for giving a full description of a tag. The names of
// scripts and regions that are not already implied by the language name will
// in appended within parentheses. It returns nil if there is not data for the
// given tag. The type passed to Name must be a tag.
func Tags(t language.Tag) Namer {
        if _, index, conf := matcher.Match(t); conf != language.No {
                return tagNamer(index)
        }
        return nil
}

type tagNamer int

// Name implements the Namer interface for tag names.
func (n tagNamer) Name(x interface{}) string {
        return nameTag(languageNamer(n), scriptNamer(n), regionNamer(n), x)
}

// lookup finds the name for an entry in a global table, traversing the
// inheritance hierarchy if needed.
func lookup(table []header, dict, want int) string {
        for dict != -1 {
                if s := table[dict].name(want); s != "" {
                        return s
                }
                dict = int(parents[dict])
        }
        return ""
}

// A Dictionary holds a collection of Namers for a single language. One can
// reduce the amount of data linked in to a binary by only referencing
// Dictionaries for the languages one needs to support instead of using the
// generic Namer factories.
type Dictionary struct {
        parent *Dictionary
        lang   header
        script header
        region header
}

// Tags returns a Namer for giving a full description of a tag. The names of
// scripts and regions that are not already implied by the language name will
// in appended within parentheses. It returns nil if there is not data for the
// given tag. The type passed to Name must be a tag.
func (d *Dictionary) Tags() Namer {
        return dictTags{d}
}

type dictTags struct {
        d *Dictionary
}

// Name implements the Namer interface for tag names.
func (n dictTags) Name(x interface{}) string {
        return nameTag(dictLanguages{n.d}, dictScripts{n.d}, dictRegions{n.d}, x)
}

// Languages returns a Namer for naming languages. It returns nil if there is no
// data for the given tag. The type passed to Name must be either language.Base
// or language.Tag. Note that the result may differ between passing a tag or its
// base language. For example, for English, passing "nl-BE" would return Flemish
// whereas passing "nl" returns "Dutch".
func (d *Dictionary) Languages() Namer {
        return dictLanguages{d}
}

type dictLanguages struct {
        d *Dictionary
}

func (n dictLanguages) name(i int) string {
        for d := n.d; d != nil; d = d.parent {
                if s := d.lang.name(i); s != "" {
                        return s
                }
        }
        return ""
}

// Name implements the Namer interface for language names.
func (n dictLanguages) Name(x interface{}) string {
        return nameLanguage(n, x)
}

// Scripts returns a Namer for naming scripts. It returns nil if there is no
// data for the given tag. The type passed to Name must be either a
// language.Script or a language.Tag. It will not attempt to infer a script for
// tags with an unspecified script.
func (d *Dictionary) Scripts() Namer {
        return dictScripts{d}
}

type dictScripts struct {
        d *Dictionary
}

func (n dictScripts) name(i int) string {
        for d := n.d; d != nil; d = d.parent {
                if s := d.script.name(i); s != "" {
                        return s
                }
        }
        return ""
}

// Name implements the Namer interface for script names.
func (n dictScripts) Name(x interface{}) string {
        return nameScript(n, x)
}

// Regions returns a Namer for naming regions. It returns nil if there is no
// data for the given tag. The type passed to Name must be either a
// language.Region or a language.Tag. It will not attempt to infer a region for
// tags with an unspecified region.
func (d *Dictionary) Regions() Namer {
        return dictRegions{d}
}

type dictRegions struct {
        d *Dictionary
}

func (n dictRegions) name(i int) string {
        for d := n.d; d != nil; d = d.parent {
                if s := d.region.name(i); s != "" {
                        return s
                }
        }
        return ""
}

// Name implements the Namer interface for region names.
func (n dictRegions) Name(x interface{}) string {
        return nameRegion(n, x)
}

// A SelfNamer implements a Namer that returns the name of language in this same
// language. It provides a very compact mechanism to provide a comprehensive
// list of languages to users in their native language.
type SelfNamer struct {
        // Supported defines the values supported by this Namer.
        Supported language.Coverage
}

var (
        // Self is a shared instance of a SelfNamer.
        Self *SelfNamer = &self

        self = SelfNamer{language.NewCoverage(selfTagSet.Tags)}
)

// Name returns the name of a given language tag in the language identified by
// this tag. It supports both the language.Base and language.Tag types.
func (n SelfNamer) Name(x interface{}) string {
        t, _ := language.All.Compose(x)
        base, scr, reg := t.Raw()
        baseScript := language.Script{}
        if (scr == language.Script{} && reg != language.Region{}) {
                // For looking up in the self dictionary, we need to select the
                // maximized script. This is even the case if the script isn't
                // specified.
                s1, _ := t.Script()
                if baseScript = getScript(base); baseScript != s1 {
                        scr = s1
                }
        }

        i, scr, reg := selfTagSet.index(base, scr, reg)
        if i == -1 {
                return ""
        }

        // Only return the display name if the script matches the expected script.
        if (scr != language.Script{}) {
                if (baseScript == language.Script{}) {
                        baseScript = getScript(base)
                }
                if baseScript != scr {
                        return ""
                }
        }

        return selfHeaders[0].name(i)
}

// getScript returns the maximized script for a base language.
func getScript(b language.Base) language.Script {
        tag, _ := language.Raw.Compose(b)
        scr, _ := tag.Script()
        return scr
}