mirror of
https://github.com/miniflux/v2.git
synced 2024-08-30 16:17:20 +02:00
101 lines
2.4 KiB
Go
101 lines
2.4 KiB
Go
// 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
|
|
}
|