compose.go

     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
View as plain text