taler-mailbox

tag.go (2415B)

---

 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package tag contains functionality handling tags and related data.
 package tag // import "golang.org/x/text/internal/tag"
 
 import "sort"
 
 // An Index converts tags to a compact numeric value.
 //
 // All elements are of size 4. Tags may be up to 4 bytes long. Excess bytes can
 // be used to store additional information about the tag.
 type Index string
 
 // Elem returns the element data at the given index.
 func (s Index) Elem(x int) string {
 	return string(s[x*4 : x*4+4])
 }
 
 // Index reports the index of the given key or -1 if it could not be found.
 // Only the first len(key) bytes from the start of the 4-byte entries will be
 // considered for the search and the first match in Index will be returned.
 func (s Index) Index(key []byte) int {
 	n := len(key)
 	// search the index of the first entry with an equal or higher value than
 	// key in s.
 	index := sort.Search(len(s)/4, func(i int) bool {
 		return cmp(s[i*4:i*4+n], key) != -1
 	})
 	i := index * 4
 	if cmp(s[i:i+len(key)], key) != 0 {
 		return -1
 	}
 	return index
 }
 
 // Next finds the next occurrence of key after index x, which must have been
 // obtained from a call to Index using the same key. It returns x+1 or -1.
 func (s Index) Next(key []byte, x int) int {
 	if x++; x*4 < len(s) && cmp(s[x*4:x*4+len(key)], key) == 0 {
 		return x
 	}
 	return -1
 }
 
 // cmp returns an integer comparing a and b lexicographically.
 func cmp(a Index, b []byte) int {
 	n := len(a)
 	if len(b) < n {
 		n = len(b)
 	}
 	for i, c := range b[:n] {
 		switch {
 		case a[i] > c:
 			return 1
 		case a[i] < c:
 			return -1
 		}
 	}
 	switch {
 	case len(a) < len(b):
 		return -1
 	case len(a) > len(b):
 		return 1
 	}
 	return 0
 }
 
 // Compare returns an integer comparing a and b lexicographically.
 func Compare(a string, b []byte) int {
 	return cmp(Index(a), b)
 }
 
 // FixCase reformats b to the same pattern of cases as form.
 // If returns false if string b is malformed.
 func FixCase(form string, b []byte) bool {
 	if len(form) != len(b) {
 		return false
 	}
 	for i, c := range b {
 		if form[i] <= 'Z' {
 			if c >= 'a' {
 				c -= 'z' - 'Z'
 			}
 			if c < 'A' || 'Z' < c {
 				return false
 			}
 		} else {
 			if c <= 'Z' {
 				c += 'z' - 'Z'
 			}
 			if c < 'a' || 'z' < c {
 				return false
 			}
 		}
 		b[i] = c
 	}
 	return true
 }