temporary/temporary_buffer.go at master · linfangrong/temporary · GitHub

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package temporary

import (
	"fmt"
	"io"
)

/**
 * 结合bytes.Buffer和bytes.Reader
 * bytes.Buffer数据只读一次性
 * bytes.Reader数据没有写入接口
 **/

const (
	smallBufferSize int = 64
	maxInt          int = int(^uint(0) >> 1)
)

var (
	ErrBufferTooLarge             error = fmt.Errorf("buffer too large")
	ErrBufferSeekInvalidWhence    error = fmt.Errorf("buffer seek invalid whence")
	ErrBufferSeekNegativePosition error = fmt.Errorf("buffer seek negative position")
)

type temporaryBuffer struct {
	buffer       []byte
	seekPosition int64
}

func newTemporaryBuffer() (tb *temporaryBuffer) {
	return &temporaryBuffer{}
}

func makeSlice(n int) (_ []byte, err error) {
	defer func() {
		if recover() != nil {
			err = ErrBufferTooLarge
			return
		}
	}()
	if n <= smallBufferSize {
		return make([]byte, n, smallBufferSize), nil
	}
	return make([]byte, n), nil
}

func (tb *temporaryBuffer) Size() int64 {
	return int64(len(tb.buffer))
}

func (tb *temporaryBuffer) Type() string {
	return TemporaryBuffer
}

func (tb *temporaryBuffer) Name() string {
	return ""
}

func (tb *temporaryBuffer) Bytes() []byte {
	return tb.buffer
}

func (tb *temporaryBuffer) Sync() (err error) {
	return
}

func (tb *temporaryBuffer) tryGrowByReslice(n int) (int, bool) {
	var l int = len(tb.buffer)
	if l+n <= cap(tb.buffer) {
		tb.buffer = tb.buffer[:l+n]
		return l, true
	}
	return 0, false
}

func (tb *temporaryBuffer) grow(n int) (_ int, err error) {
	var (
		tryGrow int
		tryOK   bool
	)
	if tryGrow, tryOK = tb.tryGrowByReslice(n); tryOK {
		return tryGrow, nil
	}
	if tb.buffer == nil && n <= smallBufferSize {
		if tb.buffer, err = makeSlice(n); err != nil {
			return
		}
		return 0, nil
	}
	var m, c int = len(tb.buffer), cap(tb.buffer)
	if n <= c/2-m { // 需要的长度比开辟的容量一半还少
	} else if c > maxInt-c-n {
		err = ErrBufferTooLarge
		return
	} else { // 新开容量
		var buffer []byte
		if buffer, err = makeSlice(2*c + n); err != nil {
			return
		}
		copy(buffer, tb.buffer)
		tb.buffer = buffer
	}
	tb.buffer = tb.buffer[:m+n]
	return m, nil
}

func (tb *temporaryBuffer) Write(p []byte) (n int, err error) {
	var (
		tryGrow int
		tryOK   bool
	)
	if tryGrow, tryOK = tb.tryGrowByReslice(len(p)); !tryOK {
		if tryGrow, err = tb.grow(len(p)); err != nil {
			return
		}
	}
	return copy(tb.buffer[tryGrow:], p), nil
}

func (tb *temporaryBuffer) Read(p []byte) (n int, err error) {
	if tb.seekPosition >= int64(len(tb.buffer)) {
		err = io.EOF
		return
	}
	n = copy(p, tb.buffer[tb.seekPosition:])
	tb.seekPosition += int64(n)
	return
}

func (tb *temporaryBuffer) Seek(offset int64, whence int) (abs int64, err error) {
	switch whence {
	case io.SeekStart:
		abs = offset
	case io.SeekCurrent:
		abs = tb.seekPosition + offset
	case io.SeekEnd:
		abs = int64(len(tb.buffer)) + offset
	default:
		err = ErrBufferSeekInvalidWhence
		return
	}
	if abs < 0 {
		err = ErrBufferSeekNegativePosition
		return
	}
	tb.seekPosition = abs
	return
}

func (tb *temporaryBuffer) Close() (err error) {
	return
}