1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright 2019 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package fspath
import (
"fmt"
"gvisor.dev/gvisor/pkg/gohacks"
)
// Builder is similar to strings.Builder, but is used to produce pathnames
// given path components in reverse order (from leaf to root). This is useful
// in the common case where a filesystem is represented by a tree of named
// nodes, and the path to a given node must be produced by walking upward from
// that node to a given root.
type Builder struct {
buf []byte
start int
needSep bool
}
// Reset resets the Builder to be empty.
func (b *Builder) Reset() {
b.start = len(b.buf)
b.needSep = false
}
// Len returns the number of accumulated bytes.
func (b *Builder) Len() int {
return len(b.buf) - b.start
}
func (b *Builder) needToGrow(n int) bool {
return b.start < n
}
func (b *Builder) grow(n int) {
newLen := b.Len() + n
var newCap int
if len(b.buf) == 0 {
newCap = 64 // arbitrary
} else {
newCap = 2 * len(b.buf)
}
for newCap < newLen {
newCap *= 2
if newCap == 0 {
panic(fmt.Sprintf("required length (%d) causes buffer size to overflow", newLen))
}
}
newBuf := make([]byte, newCap)
copy(newBuf[newCap-b.Len():], b.buf[b.start:])
b.start += newCap - len(b.buf)
b.buf = newBuf
}
// PrependComponent prepends the given path component to b's buffer. A path
// separator is automatically inserted if appropriate.
func (b *Builder) PrependComponent(pc string) {
if b.needSep {
b.PrependByte('/')
}
b.PrependString(pc)
b.needSep = true
}
// PrependString prepends the given string to b's buffer.
func (b *Builder) PrependString(str string) {
if b.needToGrow(len(str)) {
b.grow(len(str))
}
b.start -= len(str)
copy(b.buf[b.start:], str)
}
// PrependByte prepends the given byte to b's buffer.
func (b *Builder) PrependByte(c byte) {
if b.needToGrow(1) {
b.grow(1)
}
b.start--
b.buf[b.start] = c
}
// AppendString appends the given string to b's buffer.
func (b *Builder) AppendString(str string) {
if b.needToGrow(len(str)) {
b.grow(len(str))
}
oldStart := b.start
b.start -= len(str)
copy(b.buf[b.start:], b.buf[oldStart:])
copy(b.buf[len(b.buf)-len(str):], str)
}
// String returns the accumulated string. No other methods should be called
// after String.
func (b *Builder) String() string {
return gohacks.StringFromImmutableBytes(b.buf[b.start:])
}
|
