kubernetes/vendor/golang.org/x/text/cases/map.go

type mapFunc

type spanFunc

const maxIgnorable

const supported

func init() {}

var matcher

var Supported

var upperFunc

var undUpper

var undLower

var undLowerIgnoreSigma

var lowerFunc

var titleInfos

func makeUpper(t language.Tag, o options) transform.SpanningTransformer {}

func makeLower(t language.Tag, o options) transform.SpanningTransformer {}

func makeTitle(t language.Tag, o options) transform.SpanningTransformer {}

func noSpan(c *context) bool {}

type undUpperCaser

// undUpperCaser implements the Transformer interface for doing an upper case
// mapping for the root locale (und). It eliminates the need for an allocation
// as it prevents escaping by not using function pointers.
func (t undUpperCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

func (t undUpperCaser) Span(src []byte, atEOF bool) (n int, err error) {}

type undLowerIgnoreSigmaCaser

func (t undLowerIgnoreSigmaCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

// Span implements a generic lower-casing. This is possible as isLower works
// for all lowercasing variants. All lowercase variants only vary in how they
// transform a non-lowercase letter. They will never change an already lowercase
// letter. In addition, there is no state.
func (t undLowerIgnoreSigmaCaser) Span(src []byte, atEOF bool) (n int, err error) {}

type simpleCaser

// simpleCaser implements the Transformer interface for doing a case operation
// on a rune-by-rune basis.
func (t *simpleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

func (t *simpleCaser) Span(src []byte, atEOF bool) (n int, err error) {}

type undLowerCaser

func (t undLowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

func (t undLowerCaser) Span(src []byte, atEOF bool) (n int, err error) {}

type lowerCaser

func (t *lowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

type titleCaser

// Transform implements the standard Unicode title case algorithm as defined in
// Chapter 3 of The Unicode Standard:
// toTitlecase(X): Find the word boundaries in X according to Unicode Standard
// Annex #29, "Unicode Text Segmentation." For each word boundary, find the
// first cased character F following the word boundary. If F exists, map F to
// Titlecase_Mapping(F); then map all characters C between F and the following
// word boundary to Lowercase_Mapping(C).
func (t *titleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {}

func (t *titleCaser) Span(src []byte, atEOF bool) (n int, err error) {}

// finalSigma adds Greek final Sigma handing to another casing function. It
// determines whether a lowercased sigma should be σ or ς, by looking ahead for
// case-ignorables and a cased letters.
func finalSigma(f mapFunc) mapFunc {}

func finalSigmaBody(c *context) bool {}

// elUpper implements Greek upper casing, which entails removing a predefined
// set of non-blocked modifiers. Note that these accents should not be removed
// for title casing!
// Example: "Οδός" -> "ΟΔΟΣ".
func elUpper(c *context) bool {}

func ltLower(c *context) bool {}

func ltUpper(f mapFunc) mapFunc {}

func aztrUpper(f mapFunc) mapFunc {}

func aztrLower(c *context) (done bool) {}

func nlTitle(c *context) bool {}

func nlTitleSpan(c *context) bool {}

// Not part of CLDR, but see https://unicode.org/cldr/trac/ticket/7078.
func afnlRewrite(c *context) {}