1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111

package buffer

import (
	"bytes"
	"encoding/binary"
	"encoding/gob"
	"io/ioutil"
	"os"
	"sync"
)

// PoolAt provides a way to Allocate and Release BufferAt objects
// PoolAt's mut be concurrent-safe for calls to Get() and Put().
type PoolAt interface {
	Get() (BufferAt, error) // Allocate a BufferAt
	Put(buf BufferAt) error // Release or Reuse a BufferAt
}

type poolAt struct {
	poolAt sync.Pool
}

// NewPoolAt returns a PoolAt(), it's backed by a sync.Pool so its safe for concurrent use.
// Get() and Put() errors will always be nil.
// It will not work with gob.
func NewPoolAt(New func() BufferAt) PoolAt {
	return &poolAt{
		poolAt: sync.Pool{
			New: func() interface{} {
				return New()
			},
		},
	}
}

func (p *poolAt) Get() (BufferAt, error) {
	return p.poolAt.Get().(BufferAt), nil
}

func (p *poolAt) Put(buf BufferAt) error {
	buf.Reset()
	p.poolAt.Put(buf)
	return nil
}

type memPoolAt struct {
	N int64
	PoolAt
}

// NewMemPoolAt returns a PoolAt, Get() returns an in memory buffer of max size N.
// Put() returns the buffer to the pool after resetting it.
// Get() and Put() errors will always be nil.
func NewMemPoolAt(N int64) PoolAt {
	return &memPoolAt{
		N: N,
		PoolAt: NewPoolAt(func() BufferAt {
			return New(N)
		}),
	}
}

func (m *memPoolAt) MarshalBinary() ([]byte, error) {
	buf := bytes.NewBuffer(nil)
	err := binary.Write(buf, binary.LittleEndian, m.N)
	return buf.Bytes(), err
}

func (m *memPoolAt) UnmarshalBinary(data []byte) error {
	buf := bytes.NewReader(data)
	err := binary.Read(buf, binary.LittleEndian, &m.N)
	m.PoolAt = NewPoolAt(func() BufferAt {
		return New(m.N)
	})
	return err
}

type filePoolAt struct {
	N         int64
	Directory string
}

// NewFilePoolAt returns a PoolAt, Get() returns a file-based buffer of max size N.
// Put() closes and deletes the underlying file for the buffer.
// Get() may return an error if it fails to create a file for the buffer.
// Put() may return an error if it fails to delete the file.
func NewFilePoolAt(N int64, dir string) PoolAt {
	return &filePoolAt{N: N, Directory: dir}
}

func (p *filePoolAt) Get() (BufferAt, error) {
	file, err := ioutil.TempFile(p.Directory, "buffer")
	if err != nil {
		return nil, err
	}
	return NewFile(p.N, file), nil
}

func (p *filePoolAt) Put(buf BufferAt) (err error) {
	buf.Reset()
	if fileBuf, ok := buf.(*fileBuffer); ok {
		fileBuf.file.Close()
		err = os.Remove(fileBuf.file.Name())
	}
	return err
}

func init() {
	gob.Register(&memPoolAt{})
	gob.Register(&filePoolAt{})
}