rss-tools/vendor/golang.org/x/text/internal/language/compose.go (view raw)
| 1 | // Copyright 2018 The Go Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style |
| 3 | // license that can be found in the LICENSE file. |
| 4 | |
| 5 | package language |
| 6 | |
| 7 | import ( |
| 8 | "sort" |
| 9 | "strings" |
| 10 | ) |
| 11 | |
| 12 | // A Builder allows constructing a Tag from individual components. |
| 13 | // Its main user is Compose in the top-level language package. |
| 14 | type Builder struct { |
| 15 | Tag Tag |
| 16 | |
| 17 | private string // the x extension |
| 18 | variants []string |
| 19 | extensions []string |
| 20 | } |
| 21 | |
| 22 | // Make returns a new Tag from the current settings. |
| 23 | func (b *Builder) Make() Tag { |
| 24 | t := b.Tag |
| 25 | |
| 26 | if len(b.extensions) > 0 || len(b.variants) > 0 { |
| 27 | sort.Sort(sortVariants(b.variants)) |
| 28 | sort.Strings(b.extensions) |
| 29 | |
| 30 | if b.private != "" { |
| 31 | b.extensions = append(b.extensions, b.private) |
| 32 | } |
| 33 | n := maxCoreSize + tokenLen(b.variants...) + tokenLen(b.extensions...) |
| 34 | buf := make([]byte, n) |
| 35 | p := t.genCoreBytes(buf) |
| 36 | t.pVariant = byte(p) |
| 37 | p += appendTokens(buf[p:], b.variants...) |
| 38 | t.pExt = uint16(p) |
| 39 | p += appendTokens(buf[p:], b.extensions...) |
| 40 | t.str = string(buf[:p]) |
| 41 | // We may not always need to remake the string, but when or when not |
| 42 | // to do so is rather tricky. |
| 43 | scan := makeScanner(buf[:p]) |
| 44 | t, _ = parse(&scan, "") |
| 45 | return t |
| 46 | |
| 47 | } else if b.private != "" { |
| 48 | t.str = b.private |
| 49 | t.RemakeString() |
| 50 | } |
| 51 | return t |
| 52 | } |
| 53 | |
| 54 | // SetTag copies all the settings from a given Tag. Any previously set values |
| 55 | // are discarded. |
| 56 | func (b *Builder) SetTag(t Tag) { |
| 57 | b.Tag.LangID = t.LangID |
| 58 | b.Tag.RegionID = t.RegionID |
| 59 | b.Tag.ScriptID = t.ScriptID |
| 60 | // TODO: optimize |
| 61 | b.variants = b.variants[:0] |
| 62 | if variants := t.Variants(); variants != "" { |
| 63 | for _, vr := range strings.Split(variants[1:], "-") { |
| 64 | b.variants = append(b.variants, vr) |
| 65 | } |
| 66 | } |
| 67 | b.extensions, b.private = b.extensions[:0], "" |
| 68 | for _, e := range t.Extensions() { |
| 69 | b.AddExt(e) |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | // AddExt adds extension e to the tag. e must be a valid extension as returned |
| 74 | // by Tag.Extension. If the extension already exists, it will be discarded, |
| 75 | // except for a -u extension, where non-existing key-type pairs will added. |
| 76 | func (b *Builder) AddExt(e string) { |
| 77 | if e[0] == 'x' { |
| 78 | if b.private == "" { |
| 79 | b.private = e |
| 80 | } |
| 81 | return |
| 82 | } |
| 83 | for i, s := range b.extensions { |
| 84 | if s[0] == e[0] { |
| 85 | if e[0] == 'u' { |
| 86 | b.extensions[i] += e[1:] |
| 87 | } |
| 88 | return |
| 89 | } |
| 90 | } |
| 91 | b.extensions = append(b.extensions, e) |
| 92 | } |
| 93 | |
| 94 | // SetExt sets the extension e to the tag. e must be a valid extension as |
| 95 | // returned by Tag.Extension. If the extension already exists, it will be |
| 96 | // overwritten, except for a -u extension, where the individual key-type pairs |
| 97 | // will be set. |
| 98 | func (b *Builder) SetExt(e string) { |
| 99 | if e[0] == 'x' { |
| 100 | b.private = e |
| 101 | return |
| 102 | } |
| 103 | for i, s := range b.extensions { |
| 104 | if s[0] == e[0] { |
| 105 | if e[0] == 'u' { |
| 106 | b.extensions[i] = e + s[1:] |
| 107 | } else { |
| 108 | b.extensions[i] = e |
| 109 | } |
| 110 | return |
| 111 | } |
| 112 | } |
| 113 | b.extensions = append(b.extensions, e) |
| 114 | } |
| 115 | |
| 116 | // AddVariant adds any number of variants. |
| 117 | func (b *Builder) AddVariant(v ...string) { |
| 118 | for _, v := range v { |
| 119 | if v != "" { |
| 120 | b.variants = append(b.variants, v) |
| 121 | } |
| 122 | } |
| 123 | } |
| 124 | |
| 125 | // ClearVariants removes any variants previously added, including those |
| 126 | // copied from a Tag in SetTag. |
| 127 | func (b *Builder) ClearVariants() { |
| 128 | b.variants = b.variants[:0] |
| 129 | } |
| 130 | |
| 131 | // ClearExtensions removes any extensions previously added, including those |
| 132 | // copied from a Tag in SetTag. |
| 133 | func (b *Builder) ClearExtensions() { |
| 134 | b.private = "" |
| 135 | b.extensions = b.extensions[:0] |
| 136 | } |
| 137 | |
| 138 | func tokenLen(token ...string) (n int) { |
| 139 | for _, t := range token { |
| 140 | n += len(t) + 1 |
| 141 | } |
| 142 | return |
| 143 | } |
| 144 | |
| 145 | func appendTokens(b []byte, token ...string) int { |
| 146 | p := 0 |
| 147 | for _, t := range token { |
| 148 | b[p] = '-' |
| 149 | copy(b[p+1:], t) |
| 150 | p += 1 + len(t) |
| 151 | } |
| 152 | return p |
| 153 | } |
| 154 | |
| 155 | type sortVariants []string |
| 156 | |
| 157 | func (s sortVariants) Len() int { |
| 158 | return len(s) |
| 159 | } |
| 160 | |
| 161 | func (s sortVariants) Swap(i, j int) { |
| 162 | s[j], s[i] = s[i], s[j] |
| 163 | } |
| 164 | |
| 165 | func (s sortVariants) Less(i, j int) bool { |
| 166 | return variantIndex[s[i]] < variantIndex[s[j]] |
| 167 | } |