141 lines
2.9 KiB
Go
141 lines
2.9 KiB
Go
// License: GPLv3 Copyright: 2022, Kovid Goyal, <kovid at kovidgoyal.net>
|
|
|
|
package utils
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
var _ = fmt.Print
|
|
|
|
func Capitalize(x string) string {
|
|
if x == "" {
|
|
return x
|
|
}
|
|
s, sz := utf8.DecodeRuneInString(x)
|
|
cr := strings.ToUpper(string(s))
|
|
return cr + x[sz:]
|
|
}
|
|
|
|
type ScanLines struct {
|
|
entries []string
|
|
|
|
scanner *StringScanner
|
|
}
|
|
|
|
func NewScanLines(entries ...string) *ScanLines {
|
|
return &ScanLines{entries: entries}
|
|
}
|
|
|
|
func (self *ScanLines) Scan() bool {
|
|
if self.scanner == nil {
|
|
if len(self.entries) == 0 {
|
|
return false
|
|
}
|
|
self.scanner = NewLineScanner(self.entries[0])
|
|
self.entries = self.entries[1:]
|
|
return self.Scan()
|
|
} else {
|
|
if self.scanner.Scan() {
|
|
return true
|
|
}
|
|
self.scanner = nil
|
|
return self.Scan()
|
|
}
|
|
}
|
|
|
|
func (self *ScanLines) Text() string {
|
|
if self.scanner == nil {
|
|
return ""
|
|
}
|
|
return self.scanner.Text()
|
|
}
|
|
|
|
type StringScannerScanFunc = func(data string) (remaining_data, token string)
|
|
type StringScannerPostprocessFunc = func(token string) string
|
|
|
|
func ScanFuncForSeparator(sep string) StringScannerScanFunc {
|
|
if len(sep) == 1 {
|
|
sb := sep[0]
|
|
return func(data string) (remaining_data, token string) {
|
|
idx := strings.IndexByte(data, sb)
|
|
if idx < 0 {
|
|
return "", data
|
|
}
|
|
return data[idx+len(sep):], data[:idx]
|
|
}
|
|
|
|
}
|
|
return func(data string) (remaining_data, token string) {
|
|
idx := strings.Index(data, sep)
|
|
if idx < 0 {
|
|
return "", data
|
|
}
|
|
return data[idx+len(sep):], data[:idx]
|
|
}
|
|
}
|
|
|
|
// Faster, better designed, zero-allocation version of bufio.Scanner for strings
|
|
type StringScanner struct {
|
|
ScanFunc StringScannerScanFunc
|
|
PostProcessTokenFunc StringScannerPostprocessFunc
|
|
|
|
data string
|
|
token string
|
|
}
|
|
|
|
func (self *StringScanner) Scan() bool {
|
|
if self.data == "" {
|
|
self.token = ""
|
|
return false
|
|
}
|
|
self.data, self.token = self.ScanFunc(self.data)
|
|
if self.PostProcessTokenFunc != nil {
|
|
self.token = self.PostProcessTokenFunc(self.token)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (self *StringScanner) Err() error { return nil }
|
|
|
|
func (self *StringScanner) Text() string {
|
|
return self.token
|
|
}
|
|
|
|
func (self *StringScanner) Split(data string, expected_number ...int) (ans []string) {
|
|
if len(expected_number) != 0 {
|
|
ans = make([]string, 0, expected_number[0])
|
|
} else {
|
|
ans = []string{}
|
|
}
|
|
self.data = data
|
|
for self.Scan() {
|
|
ans = append(ans, self.Text())
|
|
}
|
|
return
|
|
}
|
|
|
|
func NewLineScanner(text string) *StringScanner {
|
|
return &StringScanner{
|
|
data: text, ScanFunc: ScanFuncForSeparator("\n"),
|
|
PostProcessTokenFunc: func(s string) string {
|
|
if len(s) > 0 && s[len(s)-1] == '\r' {
|
|
s = s[:len(s)-1]
|
|
}
|
|
return s
|
|
},
|
|
}
|
|
}
|
|
|
|
func NewSeparatorScanner(text, separator string) *StringScanner {
|
|
return &StringScanner{
|
|
data: text, ScanFunc: ScanFuncForSeparator(separator),
|
|
}
|
|
}
|
|
|
|
func Splitlines(x string, expected_number_of_lines ...int) (ans []string) {
|
|
return NewLineScanner("").Split(x, expected_number_of_lines...)
|
|
}
|