gotosocial/vendor/git.iim.gay/grufwub/go-bytes/bytes.go
kim (grufwub) e43a46e982 add git.iim.gay/grufwub/go-store for storage backend, replacing blob.Storage
Signed-off-by: kim (grufwub) <grufwub@gmail.com>
2021-09-11 20:12:47 +01:00

261 lines
6.9 KiB
Go

package bytes
import (
"bytes"
"reflect"
"unsafe"
)
var (
_ Bytes = &Buffer{}
_ Bytes = bytesType{}
)
// Bytes defines a standard way of retrieving the content of a
// byte buffer of some-kind.
type Bytes interface {
// Bytes returns the byte slice content
Bytes() []byte
// String returns byte slice cast directly to string, this
// will cause an allocation but comes with the safety of
// being an immutable Go string
String() string
// StringPtr returns byte slice cast to string via the unsafe
// package. This comes with the same caveats of accessing via
// .Bytes() in that the content is liable change and is NOT
// immutable, despite being a string type
StringPtr() string
}
type bytesType []byte
func (b bytesType) Bytes() []byte {
return b
}
func (b bytesType) String() string {
return string(b)
}
func (b bytesType) StringPtr() string {
return BytesToString(b)
}
// ToBytes casts the provided byte slice as the simplest possible
// Bytes interface implementation
func ToBytes(b []byte) Bytes {
return bytesType(b)
}
// Copy returns a new copy of slice b, does NOT maintain nil values
func Copy(b []byte) []byte {
p := make([]byte, len(b))
copy(p, b)
return p
}
// BytesToString returns byte slice cast to string via the "unsafe" package
func BytesToString(b []byte) string {
return *(*string)(unsafe.Pointer(&b))
}
// StringToBytes returns the string cast to string via the "unsafe" and "reflect" packages
func StringToBytes(s string) []byte {
// thank you to https://github.com/valyala/fasthttp/blob/master/bytesconv.go
var b []byte
// Get byte + string headers
bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
// Manually set bytes to string
bh.Data = sh.Data
bh.Len = sh.Len
bh.Cap = sh.Len
return b
}
// // InsertByte inserts the supplied byte into the slice at provided position
// func InsertByte(b []byte, at int, c byte) []byte {
// return append(append(b[:at], c), b[at:]...)
// }
// // Insert inserts the supplied byte slice into the slice at provided position
// func Insert(b []byte, at int, s []byte) []byte {
// return append(append(b[:at], s...), b[at:]...)
// }
// ToUpper offers a faster ToUpper implementation using a lookup table
func ToUpper(b []byte) {
for i := 0; i < len(b); i++ {
c := &b[i]
*c = toUpperTable[*c]
}
}
// ToLower offers a faster ToLower implementation using a lookup table
func ToLower(b []byte) {
for i := 0; i < len(b); i++ {
c := &b[i]
*c = toLowerTable[*c]
}
}
// HasBytePrefix returns whether b has the provided byte prefix
func HasBytePrefix(b []byte, c byte) bool {
return (len(b) > 0) && (b[0] == c)
}
// HasByteSuffix returns whether b has the provided byte suffix
func HasByteSuffix(b []byte, c byte) bool {
return (len(b) > 0) && (b[len(b)-1] == c)
}
// HasBytePrefix returns b without the provided leading byte
func TrimBytePrefix(b []byte, c byte) []byte {
if HasBytePrefix(b, c) {
return b[1:]
}
return b
}
// TrimByteSuffix returns b without the provided trailing byte
func TrimByteSuffix(b []byte, c byte) []byte {
if HasByteSuffix(b, c) {
return b[:len(b)-1]
}
return b
}
// Compare is a direct call-through to standard library bytes.Compare()
func Compare(b, s []byte) int {
return bytes.Compare(b, s)
}
// Contains is a direct call-through to standard library bytes.Contains()
func Contains(b, s []byte) bool {
return bytes.Contains(b, s)
}
// TrimPrefix is a direct call-through to standard library bytes.TrimPrefix()
func TrimPrefix(b, s []byte) []byte {
return bytes.TrimPrefix(b, s)
}
// TrimSuffix is a direct call-through to standard library bytes.TrimSuffix()
func TrimSuffix(b, s []byte) []byte {
return bytes.TrimSuffix(b, s)
}
// Equal is a direct call-through to standard library bytes.Equal()
func Equal(b, s []byte) bool {
return bytes.Equal(b, s)
}
// EqualFold is a direct call-through to standard library bytes.EqualFold()
func EqualFold(b, s []byte) bool {
return bytes.EqualFold(b, s)
}
// Fields is a direct call-through to standard library bytes.Fields()
func Fields(b []byte) [][]byte {
return bytes.Fields(b)
}
// FieldsFunc is a direct call-through to standard library bytes.FieldsFunc()
func FieldsFunc(b []byte, fn func(rune) bool) [][]byte {
return bytes.FieldsFunc(b, fn)
}
// HasPrefix is a direct call-through to standard library bytes.HasPrefix()
func HasPrefix(b, s []byte) bool {
return bytes.HasPrefix(b, s)
}
// HasSuffix is a direct call-through to standard library bytes.HasSuffix()
func HasSuffix(b, s []byte) bool {
return bytes.HasSuffix(b, s)
}
// Index is a direct call-through to standard library bytes.Index()
func Index(b, s []byte) int {
return bytes.Index(b, s)
}
// IndexByte is a direct call-through to standard library bytes.IndexByte()
func IndexByte(b []byte, c byte) int {
return bytes.IndexByte(b, c)
}
// IndexAny is a direct call-through to standard library bytes.IndexAny()
func IndexAny(b []byte, s string) int {
return bytes.IndexAny(b, s)
}
// IndexRune is a direct call-through to standard library bytes.IndexRune()
func IndexRune(b []byte, r rune) int {
return bytes.IndexRune(b, r)
}
// IndexFunc is a direct call-through to standard library bytes.IndexFunc()
func IndexFunc(b []byte, fn func(rune) bool) int {
return bytes.IndexFunc(b, fn)
}
// LastIndex is a direct call-through to standard library bytes.LastIndex()
func LastIndex(b, s []byte) int {
return bytes.LastIndex(b, s)
}
// LastIndexByte is a direct call-through to standard library bytes.LastIndexByte()
func LastIndexByte(b []byte, c byte) int {
return bytes.LastIndexByte(b, c)
}
// LastIndexAny is a direct call-through to standard library bytes.LastIndexAny()
func LastIndexAny(b []byte, s string) int {
return bytes.LastIndexAny(b, s)
}
// LastIndexFunc is a direct call-through to standard library bytes.LastIndexFunc()
func LastIndexFunc(b []byte, fn func(rune) bool) int {
return bytes.LastIndexFunc(b, fn)
}
// Replace is a direct call-through to standard library bytes.Replace()
func Replace(b, s, r []byte, c int) []byte {
return bytes.Replace(b, s, r, c)
}
// ReplaceAll is a direct call-through to standard library bytes.ReplaceAll()
func ReplaceAll(b, s, r []byte) []byte {
return bytes.ReplaceAll(b, s, r)
}
// Split is a direct call-through to standard library bytes.Split()
func Split(b, s []byte) [][]byte {
return bytes.Split(b, s)
}
// SplitAfter is a direct call-through to standard library bytes.SplitAfter()
func SplitAfter(b, s []byte) [][]byte {
return bytes.SplitAfter(b, s)
}
// SplitN is a direct call-through to standard library bytes.SplitN()
func SplitN(b, s []byte, c int) [][]byte {
return bytes.SplitN(b, s, c)
}
// SplitAfterN is a direct call-through to standard library bytes.SplitAfterN()
func SplitAfterN(b, s []byte, c int) [][]byte {
return bytes.SplitAfterN(b, s, c)
}
// NewReader is a direct call-through to standard library bytes.NewReader()
func NewReader(b []byte) *bytes.Reader {
return bytes.NewReader(b)
}