mirror of https://github.com/gobwas/glob.git
98 lines
1.4 KiB
Go
98 lines
1.4 KiB
Go
package match
|
|
|
|
import "sync"
|
|
|
|
// Pool holds Clients.
|
|
type PoolSequenced struct {
|
|
size int
|
|
pool chan []int
|
|
}
|
|
|
|
// NewPool creates a new pool of Clients.
|
|
func NewPoolSequenced(max, size int) *PoolSequenced {
|
|
return &PoolSequenced{
|
|
size: size,
|
|
pool: make(chan []int, max),
|
|
}
|
|
}
|
|
|
|
// Borrow a Client from the pool.
|
|
func (p *PoolSequenced) Get() []int {
|
|
var s []int
|
|
select {
|
|
case s = <-p.pool:
|
|
default:
|
|
s = make([]int, 0, p.size)
|
|
}
|
|
|
|
return s[:0]
|
|
}
|
|
|
|
// Return returns a Client to the pool.
|
|
func (p *PoolSequenced) Put(s []int) {
|
|
select {
|
|
case p.pool <- s:
|
|
default:
|
|
// let it go, let it go...
|
|
}
|
|
}
|
|
|
|
type PoolSynced struct {
|
|
size int
|
|
mu sync.Mutex
|
|
list [][]int
|
|
}
|
|
|
|
func NewPoolSynced(size int) *PoolSynced {
|
|
return &PoolSynced{
|
|
size: size,
|
|
}
|
|
}
|
|
|
|
func (p *PoolSynced) Get() []int {
|
|
var s []int
|
|
|
|
p.mu.Lock()
|
|
ll := len(p.list)
|
|
if ll > 0 {
|
|
s, p.list = p.list[ll-1], p.list[:ll-1]
|
|
}
|
|
p.mu.Unlock()
|
|
|
|
if s == nil {
|
|
return make([]int, 0, p.size)
|
|
}
|
|
|
|
return s[:0]
|
|
}
|
|
|
|
func (p *PoolSynced) Put(s []int) {
|
|
p.mu.Lock()
|
|
defer p.mu.Unlock()
|
|
p.list = append(p.list, s)
|
|
}
|
|
|
|
type PoolNative struct {
|
|
size int
|
|
pool sync.Pool
|
|
}
|
|
|
|
func NewPoolNative(size int) *PoolNative {
|
|
return &PoolNative{
|
|
size: size,
|
|
}
|
|
}
|
|
|
|
func (p *PoolNative) Get() []int {
|
|
s := p.pool.Get()
|
|
if s == nil {
|
|
return make([]int, 0, p.size)
|
|
}
|
|
|
|
return s.([]int)
|
|
}
|
|
|
|
func (p *PoolNative) Put(s []int) {
|
|
p.pool.Put(s)
|
|
}
|