prevara/pooltypes.go

// generated by go run github.com/p9c/p9/pkg/gel/poolgen/poolgen.go; DO NOT EDIT
//
//go:generate go run ./poolgen/.

package gel

func (p *Pool) GetBool() (out *Bool) {
	if p.boolsInUse >= len(p.bools) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.bools) + 16
		newSlice := make([]*Bool, len(p.bools), newCap)
		copy(newSlice, p.bools)
		for i := len(p.bools); i < newCap; i++ {
			newSlice = append(newSlice, p.Bool(false))
		}
		p.bools = newSlice
	}
	out = p.bools[p.boolsInUse]
	p.boolsInUse++
	return
}

func (p *Pool) FreeBool(b *Bool) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.boolsInUse; i++ {
		if p.bools[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.boolsInUse--
			if i != p.boolsInUse {
				p.bools[i], p.bools[p.boolsInUse] = p.bools[p.boolsInUse], p.bools[i]
			}
			return
		}
	}
}


func (p *Pool) GetList() (out *List) {
	if p.listsInUse >= len(p.lists) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.lists) + 16
		newSlice := make([]*List, len(p.lists), newCap)
		copy(newSlice, p.lists)
		for i := len(p.lists); i < newCap; i++ {
			newSlice = append(newSlice, p.List())
		}
		p.lists = newSlice
	}
	out = p.lists[p.listsInUse]
	p.listsInUse++
	return
}

func (p *Pool) FreeList(b *List) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.listsInUse; i++ {
		if p.lists[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.listsInUse--
			if i != p.listsInUse {
				p.lists[i], p.lists[p.listsInUse] = p.lists[p.listsInUse], p.lists[i]
			}
			return
		}
	}
}


func (p *Pool) GetCheckable() (out *Checkable) {
	if p.checkablesInUse >= len(p.checkables) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.checkables) + 16
		newSlice := make([]*Checkable, len(p.checkables), newCap)
		copy(newSlice, p.checkables)
		for i := len(p.checkables); i < newCap; i++ {
			newSlice = append(newSlice, p.Checkable())
		}
		p.checkables = newSlice
	}
	out = p.checkables[p.checkablesInUse]
	p.checkablesInUse++
	return
}

func (p *Pool) FreeCheckable(b *Checkable) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.checkablesInUse; i++ {
		if p.checkables[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.checkablesInUse--
			if i != p.checkablesInUse {
				p.checkables[i], p.checkables[p.checkablesInUse] = p.checkables[p.checkablesInUse], p.checkables[i]
			}
			return
		}
	}
}


func (p *Pool) GetClickable() (out *Clickable) {
	if p.clickablesInUse >= len(p.clickables) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.clickables) + 16
		newSlice := make([]*Clickable, len(p.clickables), newCap)
		copy(newSlice, p.clickables)
		for i := len(p.clickables); i < newCap; i++ {
			newSlice = append(newSlice, p.Clickable())
		}
		p.clickables = newSlice
	}
	out = p.clickables[p.clickablesInUse]
	p.clickablesInUse++
	return
}

func (p *Pool) FreeClickable(b *Clickable) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.clickablesInUse; i++ {
		if p.clickables[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.clickablesInUse--
			if i != p.clickablesInUse {
				p.clickables[i], p.clickables[p.clickablesInUse] = p.clickables[p.clickablesInUse], p.clickables[i]
			}
			return
		}
	}
}


func (p *Pool) GetEditor() (out *Editor) {
	if p.editorsInUse >= len(p.editors) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.editors) + 16
		newSlice := make([]*Editor, len(p.editors), newCap)
		copy(newSlice, p.editors)
		for i := len(p.editors); i < newCap; i++ {
			newSlice = append(newSlice, p.Editor())
		}
		p.editors = newSlice
	}
	out = p.editors[p.editorsInUse]
	p.editorsInUse++
	return
}

func (p *Pool) FreeEditor(b *Editor) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.editorsInUse; i++ {
		if p.editors[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.editorsInUse--
			if i != p.editorsInUse {
				p.editors[i], p.editors[p.editorsInUse] = p.editors[p.editorsInUse], p.editors[i]
			}
			return
		}
	}
}


func (p *Pool) GetIncDec() (out *IncDec) {
	if p.incDecsInUse >= len(p.incDecs) {
		// Pre-allocate capacity to avoid repeated growth
		newCap := len(p.incDecs) + 16
		newSlice := make([]*IncDec, len(p.incDecs), newCap)
		copy(newSlice, p.incDecs)
		for i := len(p.incDecs); i < newCap; i++ {
			newSlice = append(newSlice, p.IncDec())
		}
		p.incDecs = newSlice
	}
	out = p.incDecs[p.incDecsInUse]
	p.incDecsInUse++
	return
}

func (p *Pool) FreeIncDec(b *IncDec) {
	// O(n) search is unavoidable without additional bookkeeping,
	// but we use O(1) swap instead of O(n) slice operations
	for i := 0; i < p.incDecsInUse; i++ {
		if p.incDecs[i] == b {
			// Swap with the last in-use element (O(1) operation)
			p.incDecsInUse--
			if i != p.incDecsInUse {
				p.incDecs[i], p.incDecs[p.incDecsInUse] = p.incDecs[p.incDecsInUse], p.incDecs[i]
			}
			return
		}
	}
}