mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-24 04:36:38 +00:00
5004e0a9da
* fix error check of prune to allow missing files * update go-store library, add test for pruning item with db entry but no file Signed-off-by: kim <grufwub@gmail.com> * remove now-unneccessary error check Signed-off-by: kim <grufwub@gmail.com> Co-authored-by: kim <grufwub@gmail.com>
130 lines
3.2 KiB
Go
130 lines
3.2 KiB
Go
package byteutil
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
var (
|
|
// ensure we conform to interfaces.
|
|
_ interface {
|
|
io.Writer
|
|
io.ByteWriter
|
|
WriteRune(rune) (int, error)
|
|
io.StringWriter
|
|
io.WriterAt
|
|
WriteStringAt(string, int64) (int, error)
|
|
} = (*Buffer)(nil)
|
|
|
|
// ErrBeyondBufferLen is returned if .WriteAt() is attempted beyond buffer length.
|
|
ErrBeyondBufferLen = errors.New("start beyond buffer length")
|
|
)
|
|
|
|
// Buffer is a simple wrapper around a byte slice.
|
|
type Buffer struct{ B []byte }
|
|
|
|
// WriteByte will append given byte to buffer, fulfilling io.ByteWriter.
|
|
func (buf *Buffer) WriteByte(c byte) error {
|
|
buf.B = append(buf.B, c)
|
|
return nil
|
|
}
|
|
|
|
// WriteRune will append given rune to buffer.
|
|
func (buf *Buffer) WriteRune(r rune) (int, error) {
|
|
// Check for single-byte rune
|
|
if r < utf8.RuneSelf {
|
|
buf.B = append(buf.B, byte(r))
|
|
return 1, nil
|
|
}
|
|
|
|
// Before-len
|
|
l := len(buf.B)
|
|
|
|
// Grow to max size rune
|
|
buf.Grow(utf8.UTFMax)
|
|
|
|
// Write encoded rune to buffer
|
|
n := utf8.EncodeRune(buf.B[l:len(buf.B)], r)
|
|
buf.B = buf.B[:l+n]
|
|
|
|
return n, nil
|
|
}
|
|
|
|
// Write will append given byte slice to buffer, fulfilling io.Writer.
|
|
func (buf *Buffer) Write(b []byte) (int, error) {
|
|
buf.B = append(buf.B, b...)
|
|
return len(b), nil
|
|
}
|
|
|
|
// WriteString will append given string to buffer, fulfilling io.StringWriter.
|
|
func (buf *Buffer) WriteString(s string) (int, error) {
|
|
buf.B = append(buf.B, s...)
|
|
return len(s), nil
|
|
}
|
|
|
|
// WriteAt will append given byte slice to buffer at index 'start', fulfilling io.WriterAt.
|
|
func (buf *Buffer) WriteAt(b []byte, start int64) (int, error) {
|
|
if start > int64(len(buf.B)) {
|
|
return 0, ErrBeyondBufferLen
|
|
}
|
|
buf.Grow(len(b) - int(int64(len(buf.B))-start))
|
|
return copy(buf.B[start:], b), nil
|
|
}
|
|
|
|
// WriteStringAt will append given string to buffer at index 'start'.
|
|
func (buf *Buffer) WriteStringAt(s string, start int64) (int, error) {
|
|
if start > int64(len(buf.B)) {
|
|
return 0, ErrBeyondBufferLen
|
|
}
|
|
buf.Grow(len(s) - int(int64(len(buf.B))-start))
|
|
return copy(buf.B[start:], s), nil
|
|
}
|
|
|
|
// Len returns the length of the buffer's underlying byte slice.
|
|
func (buf *Buffer) Len() int {
|
|
return len(buf.B)
|
|
}
|
|
|
|
// Cap returns the capacity of the buffer's underlying byte slice.
|
|
func (buf *Buffer) Cap() int {
|
|
return cap(buf.B)
|
|
}
|
|
|
|
// Grow will increase the buffers length by 'sz', and the capacity by at least this.
|
|
func (buf *Buffer) Grow(sz int) {
|
|
buf.Guarantee(sz)
|
|
buf.B = buf.B[:len(buf.B)+sz]
|
|
}
|
|
|
|
// Guarantee will guarantee buffer containers at least 'sz' remaining capacity.
|
|
func (buf *Buffer) Guarantee(sz int) {
|
|
if sz > cap(buf.B)-len(buf.B) {
|
|
nb := make([]byte, 2*cap(buf.B)+sz)
|
|
copy(nb, buf.B)
|
|
buf.B = nb[:len(buf.B)]
|
|
}
|
|
}
|
|
|
|
// Truncate will reduce the length of the buffer by 'n'.
|
|
func (buf *Buffer) Truncate(n int) {
|
|
if n > len(buf.B) {
|
|
n = len(buf.B)
|
|
}
|
|
buf.B = buf.B[:len(buf.B)-n]
|
|
}
|
|
|
|
// Reset will reset the buffer length to 0 (retains capacity).
|
|
func (buf *Buffer) Reset() {
|
|
buf.B = buf.B[:0]
|
|
}
|
|
|
|
// String returns the underlying byte slice as a string. Please note
|
|
// this value is tied directly to the underlying byte slice, if you
|
|
// write to the buffer then returned string values will also change.
|
|
//
|
|
// To get an immutable string from buffered data, use string(buf.B).
|
|
func (buf *Buffer) String() string {
|
|
return B2S(buf.B)
|
|
}
|