161 lines
2.7 KiB
Go
161 lines
2.7 KiB
Go
// Copyright 2015 The 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 byteutil provides various operations on bytes and byte strings.
|
|
package byteutil
|
|
|
|
var (
|
|
digit [256]bool
|
|
hexdigit [256]bool
|
|
letter [256]bool
|
|
uppercase [256]bool
|
|
lowercase [256]bool
|
|
alphanum [256]bool
|
|
tolower [256]byte
|
|
toupper [256]byte
|
|
)
|
|
|
|
func init() {
|
|
for _, b := range "0123456789" {
|
|
digit[b] = true
|
|
}
|
|
for _, b := range "0123456789abcdefABCDEF" {
|
|
hexdigit[b] = true
|
|
}
|
|
for _, b := range "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" {
|
|
letter[b] = true
|
|
}
|
|
for _, b := range "abcdefghijklmnopqrstuvwxyz" {
|
|
lowercase[b] = true
|
|
}
|
|
for _, b := range "ABCDEFGHIJKLMNOPQRSTUVWXYZ" {
|
|
uppercase[b] = true
|
|
}
|
|
for _, b := range "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" {
|
|
alphanum[b] = true
|
|
}
|
|
for i := 0; i < 256; i++ {
|
|
tolower[i] = byte(i)
|
|
toupper[i] = byte(i)
|
|
}
|
|
for _, b := range "ABCDEFGHIJKLMNOPQRSTUVWXYZ" {
|
|
tolower[b] = byte(b) - 'A' + 'a'
|
|
}
|
|
for _, b := range "abcdefghijklmnopqrstuvwxyz" {
|
|
toupper[b] = byte(b) - 'a' + 'A'
|
|
}
|
|
}
|
|
|
|
func IsDigit(b byte) bool {
|
|
return digit[b]
|
|
}
|
|
|
|
func IsHexDigit(b byte) bool {
|
|
return hexdigit[b]
|
|
}
|
|
|
|
func IsLetter(b byte) bool {
|
|
return letter[b]
|
|
}
|
|
|
|
func IsLowercaseLetter(b byte) bool {
|
|
return lowercase[b]
|
|
}
|
|
|
|
func IsUppercaseLetter(b byte) bool {
|
|
return uppercase[b]
|
|
}
|
|
|
|
func IsAlphaNum(b byte) bool {
|
|
return alphanum[b]
|
|
}
|
|
|
|
func ToLower(s string) string {
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
|
|
hasUpper := false
|
|
for i := 0; i < len(s); i++ {
|
|
if uppercase[s[i]] {
|
|
hasUpper = true
|
|
break
|
|
}
|
|
}
|
|
if !hasUpper {
|
|
return s
|
|
}
|
|
|
|
buf := make([]byte, len(s))
|
|
for i := 0; i < len(s); i++ {
|
|
buf[i] = tolower[s[i]]
|
|
}
|
|
return string(buf)
|
|
}
|
|
|
|
func ToUpper(s string) string {
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
|
|
hasLower := false
|
|
for i := 0; i < len(s); i++ {
|
|
if lowercase[s[i]] {
|
|
hasLower = true
|
|
break
|
|
}
|
|
}
|
|
if !hasLower {
|
|
return s
|
|
}
|
|
|
|
buf := make([]byte, len(s))
|
|
for i := 0; i < len(s); i++ {
|
|
buf[i] = toupper[s[i]]
|
|
}
|
|
return string(buf)
|
|
}
|
|
|
|
func ByteToLower(b byte) byte {
|
|
return tolower[b]
|
|
}
|
|
|
|
func ByteToUpper(b byte) byte {
|
|
return toupper[b]
|
|
}
|
|
|
|
func IndexAny(s, chars string) int {
|
|
var t [256]bool
|
|
for i := 0; i < len(chars); i++ {
|
|
t[chars[i]] = true
|
|
}
|
|
for i := 0; i < len(s); i++ {
|
|
if t[s[i]] {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func IndexAnyTable(s string, t *[256]bool) int {
|
|
for i := 0; i < len(s); i++ {
|
|
if t[s[i]] {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func Unhex(d byte) byte {
|
|
switch {
|
|
case digit[d]:
|
|
return d - '0'
|
|
case uppercase[d]:
|
|
return d - 'A' + 10
|
|
case lowercase[d]:
|
|
return d - 'a' + 10
|
|
}
|
|
panic("unhex: not hex digit")
|
|
}
|