type Tag … func makeTag(t language.Tag) (tag Tag) { … } func (t *Tag) tag() language.Tag { … } func (t *Tag) isCompact() bool { … } // TODO: improve performance. func (t *Tag) lang() language.Language { … } func (t *Tag) region() language.Region { … } func (t *Tag) script() language.Script { … } // Make is a convenience wrapper for Parse that omits the error. // In case of an error, a sensible default is returned. func Make(s string) Tag { … } // Make is a convenience wrapper for c.Parse that omits the error. // In case of an error, a sensible default is returned. func (c CanonType) Make(s string) Tag { … } // Raw returns the raw base language, script and region, without making an // attempt to infer their values. func (t Tag) Raw() (b Base, s Script, r Region) { … } // IsRoot returns true if t is equal to language "und". func (t Tag) IsRoot() bool { … } type CanonType … const DeprecatedBase … const DeprecatedScript … const DeprecatedRegion … const SuppressScript … const Legacy … const Macro … const CLDR … const Raw … const Deprecated … const BCP47 … const All … const Default … const canonLang … // canonicalize returns the canonicalized equivalent of the tag and // whether there was any change. func canonicalize(c CanonType, t language.Tag) (language.Tag, bool) { … } // Canonicalize returns the canonicalized equivalent of the tag. func (c CanonType) Canonicalize(t Tag) (Tag, error) { … } type Confidence … const No … const Low … const High … const Exact … var confName … func (c Confidence) String() string { … } // String returns the canonical string representation of the language tag. func (t Tag) String() string { … } // MarshalText implements encoding.TextMarshaler. func (t Tag) MarshalText() (text []byte, err error) { … } // UnmarshalText implements encoding.TextUnmarshaler. func (t *Tag) UnmarshalText(text []byte) error { … } // Base returns the base language of the language tag. If the base language is // unspecified, an attempt will be made to infer it from the context. // It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change. func (t Tag) Base() (Base, Confidence) { … } // Script infers the script for the language tag. If it was not explicitly given, it will infer // a most likely candidate. // If more than one script is commonly used for a language, the most likely one // is returned with a low confidence indication. For example, it returns (Cyrl, Low) // for Serbian. // If a script cannot be inferred (Zzzz, No) is returned. We do not use Zyyy (undetermined) // as one would suspect from the IANA registry for BCP 47. In a Unicode context Zyyy marks // common characters (like 1, 2, 3, '.', etc.) and is therefore more like multiple scripts. // See https://www.unicode.org/reports/tr24/#Values for more details. Zzzz is also used for // unknown value in CLDR. (Zzzz, Exact) is returned if Zzzz was explicitly specified. // Note that an inferred script is never guaranteed to be the correct one. Latin is // almost exclusively used for Afrikaans, but Arabic has been used for some texts // in the past. Also, the script that is commonly used may change over time. // It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change. func (t Tag) Script() (Script, Confidence) { … } // Region returns the region for the language tag. If it was not explicitly given, it will // infer a most likely candidate from the context. // It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change. func (t Tag) Region() (Region, Confidence) { … } // Variants returns the variants specified explicitly for this language tag. // or nil if no variant was specified. func (t Tag) Variants() []Variant { … } // Parent returns the CLDR parent of t. In CLDR, missing fields in data for a // specific language are substituted with fields from the parent language. // The parent for a language may change for newer versions of CLDR. // // Parent returns a tag for a less specific language that is mutually // intelligible or Und if there is no such language. This may not be the same as // simply stripping the last BCP 47 subtag. For instance, the parent of "zh-TW" // is "zh-Hant", and the parent of "zh-Hant" is "und". func (t Tag) Parent() Tag { … } // nextToken returns token t and the rest of the string. func nextToken(s string) (t, tail string) { … } type Extension … // String returns the string representation of the extension, including the // type tag. func (e Extension) String() string { … } // ParseExtension parses s as an extension and returns it on success. func ParseExtension(s string) (e Extension, err error) { … } // Type returns the one-byte extension type of e. It returns 0 for the zero // exception. func (e Extension) Type() byte { … } // Tokens returns the list of tokens of e. func (e Extension) Tokens() []string { … } // Extension returns the extension of type x for tag t. It will return // false for ok if t does not have the requested extension. The returned // extension will be invalid in this case. func (t Tag) Extension(x byte) (ext Extension, ok bool) { … } // Extensions returns all extensions of t. func (t Tag) Extensions() []Extension { … } // TypeForKey returns the type associated with the given key, where key and type // are of the allowed values defined for the Unicode locale extension ('u') in // https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers. // TypeForKey will traverse the inheritance chain to get the correct value. // // If there are multiple types associated with a key, only the first will be // returned. If there is no type associated with a key, it returns the empty // string. func (t Tag) TypeForKey(key string) string { … } // SetTypeForKey returns a new Tag with the key set to type, where key and type // are of the allowed values defined for the Unicode locale extension ('u') in // https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers. // An empty value removes an existing pair with the same key. func (t Tag) SetTypeForKey(key, value string) (Tag, error) { … } const NumCompactTags … // CompactIndex returns an index, where 0 <= index < NumCompactTags, for tags // for which data exists in the text repository.The index will change over time // and should not be stored in persistent storage. If t does not match a compact // index, exact will be false and the compact index will be returned for the // first match after repeatedly taking the Parent of t. func CompactIndex(t Tag) (index int, exact bool) { … } var root … type Base … // ParseBase parses a 2- or 3-letter ISO 639 code. // It returns a ValueError if s is a well-formed but unknown language identifier // or another error if another error occurred. func ParseBase(s string) (Base, error) { … } // String returns the BCP 47 representation of the base language. func (b Base) String() string { … } // ISO3 returns the ISO 639-3 language code. func (b Base) ISO3() string { … } // IsPrivateUse reports whether this language code is reserved for private use. func (b Base) IsPrivateUse() bool { … } type Script … // ParseScript parses a 4-letter ISO 15924 code. // It returns a ValueError if s is a well-formed but unknown script identifier // or another error if another error occurred. func ParseScript(s string) (Script, error) { … } // String returns the script code in title case. // It returns "Zzzz" for an unspecified script. func (s Script) String() string { … } // IsPrivateUse reports whether this script code is reserved for private use. func (s Script) IsPrivateUse() bool { … } type Region … // EncodeM49 returns the Region for the given UN M.49 code. // It returns an error if r is not a valid code. func EncodeM49(r int) (Region, error) { … } // ParseRegion parses a 2- or 3-letter ISO 3166-1 or a UN M.49 code. // It returns a ValueError if s is a well-formed but unknown region identifier // or another error if another error occurred. func ParseRegion(s string) (Region, error) { … } // String returns the BCP 47 representation for the region. // It returns "ZZ" for an unspecified region. func (r Region) String() string { … } // ISO3 returns the 3-letter ISO code of r. // Note that not all regions have a 3-letter ISO code. // In such cases this method returns "ZZZ". func (r Region) ISO3() string { … } // M49 returns the UN M.49 encoding of r, or 0 if this encoding // is not defined for r. func (r Region) M49() int { … } // IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This // may include private-use tags that are assigned by CLDR and used in this // implementation. So IsPrivateUse and IsCountry can be simultaneously true. func (r Region) IsPrivateUse() bool { … } // IsCountry returns whether this region is a country or autonomous area. This // includes non-standard definitions from CLDR. func (r Region) IsCountry() bool { … } // IsGroup returns whether this region defines a collection of regions. This // includes non-standard definitions from CLDR. func (r Region) IsGroup() bool { … } // Contains returns whether Region c is contained by Region r. It returns true // if c == r. func (r Region) Contains(c Region) bool { … } // TLD returns the country code top-level domain (ccTLD). UK is returned for GB. // In all other cases it returns either the region itself or an error. // // This method may return an error for a region for which there exists a // canonical form with a ccTLD. To get that ccTLD canonicalize r first. The // region will already be canonicalized it was obtained from a Tag that was // obtained using any of the default methods. func (r Region) TLD() (Region, error) { … } // Canonicalize returns the region or a possible replacement if the region is // deprecated. It will not return a replacement for deprecated regions that // are split into multiple regions. func (r Region) Canonicalize() Region { … } type Variant … // ParseVariant parses and returns a Variant. An error is returned if s is not // a valid variant. func ParseVariant(s string) (Variant, error) { … } // String returns the string representation of the variant. func (v Variant) String() string { … }
Codebase Browser
kubernetes