mirror of https://go.googlesource.com/go
111 lines
3.2 KiB
Go
111 lines
3.2 KiB
Go
// Copyright 2017 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 strings
|
|
|
|
import (
|
|
"internal/abi"
|
|
"internal/bytealg"
|
|
"unicode/utf8"
|
|
"unsafe"
|
|
)
|
|
|
|
// A Builder is used to efficiently build a string using [Builder.Write] methods.
|
|
// It minimizes memory copying. The zero value is ready to use.
|
|
// Do not copy a non-zero Builder.
|
|
type Builder struct {
|
|
addr *Builder // of receiver, to detect copies by value
|
|
|
|
// External users should never get direct access to this buffer, since
|
|
// the slice at some point will be converted to a string using unsafe, also
|
|
// data between len(buf) and cap(buf) might be uninitialized.
|
|
buf []byte
|
|
}
|
|
|
|
func (b *Builder) copyCheck() {
|
|
if b.addr == nil {
|
|
// This hack works around a failing of Go's escape analysis
|
|
// that was causing b to escape and be heap allocated.
|
|
// See issue 23382.
|
|
// TODO: once issue 7921 is fixed, this should be reverted to
|
|
// just "b.addr = b".
|
|
b.addr = (*Builder)(abi.NoEscape(unsafe.Pointer(b)))
|
|
} else if b.addr != b {
|
|
panic("strings: illegal use of non-zero Builder copied by value")
|
|
}
|
|
}
|
|
|
|
// String returns the accumulated string.
|
|
func (b *Builder) String() string {
|
|
return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
|
|
}
|
|
|
|
// Len returns the number of accumulated bytes; b.Len() == len(b.String()).
|
|
func (b *Builder) Len() int { return len(b.buf) }
|
|
|
|
// Cap returns the capacity of the builder's underlying byte slice. It is the
|
|
// total space allocated for the string being built and includes any bytes
|
|
// already written.
|
|
func (b *Builder) Cap() int { return cap(b.buf) }
|
|
|
|
// Reset resets the [Builder] to be empty.
|
|
func (b *Builder) Reset() {
|
|
b.addr = nil
|
|
b.buf = nil
|
|
}
|
|
|
|
// grow copies the buffer to a new, larger buffer so that there are at least n
|
|
// bytes of capacity beyond len(b.buf).
|
|
func (b *Builder) grow(n int) {
|
|
buf := bytealg.MakeNoZero(2*cap(b.buf) + n)[:len(b.buf)]
|
|
copy(buf, b.buf)
|
|
b.buf = buf
|
|
}
|
|
|
|
// Grow grows b's capacity, if necessary, to guarantee space for
|
|
// another n bytes. After Grow(n), at least n bytes can be written to b
|
|
// without another allocation. If n is negative, Grow panics.
|
|
func (b *Builder) Grow(n int) {
|
|
b.copyCheck()
|
|
if n < 0 {
|
|
panic("strings.Builder.Grow: negative count")
|
|
}
|
|
if cap(b.buf)-len(b.buf) < n {
|
|
b.grow(n)
|
|
}
|
|
}
|
|
|
|
// Write appends the contents of p to b's buffer.
|
|
// Write always returns len(p), nil.
|
|
func (b *Builder) Write(p []byte) (int, error) {
|
|
b.copyCheck()
|
|
b.buf = append(b.buf, p...)
|
|
return len(p), nil
|
|
}
|
|
|
|
// WriteByte appends the byte c to b's buffer.
|
|
// The returned error is always nil.
|
|
func (b *Builder) WriteByte(c byte) error {
|
|
b.copyCheck()
|
|
b.buf = append(b.buf, c)
|
|
return nil
|
|
}
|
|
|
|
// WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
|
|
// It returns the length of r and a nil error.
|
|
func (b *Builder) WriteRune(r rune) (int, error) {
|
|
b.copyCheck()
|
|
n := len(b.buf)
|
|
b.buf = utf8.AppendRune(b.buf, r)
|
|
return len(b.buf) - n, nil
|
|
}
|
|
|
|
// WriteString appends the contents of s to b's buffer.
|
|
// It returns the length of s and a nil error.
|
|
func (b *Builder) WriteString(s string) (int, error) {
|
|
b.copyCheck()
|
|
b.buf = append(b.buf, s...)
|
|
return len(s), nil
|
|
}
|