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 }
168