gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/container/queue.go

package container

import _ "unsafe"

//go:linkname goPanicIndex runtime.goPanicIndex
func goPanicIndex(x int, y int)

//go:linkname goPanicSliceAcap runtime.goPanicSliceAcap
func goPanicSliceAcap(x int, y int)

//go:linkname goPanicSliceB runtime.goPanicSliceB
func goPanicSliceB(x int, y int)

type Queue[E any] struct {
	raw  []E
	head int
	tail int
	len  int
	cap  int
}

func NewQueue[E any](cap int) *Queue[E] {
	return &Queue[E]{
		raw: make([]E, cap, cap),
		cap: cap,
	}
}

func (q *Queue[E]) Init(cap int) {
	*q = Queue[E]{
		raw: make([]E, cap, cap),
		cap: cap,
	}
}

func (q *Queue[E]) IsNil() bool {
	return q.raw == nil
}

// Len 返回队列的长度
func (q *Queue[E]) Len() int {
	return q.len
}

// Cap 返回队列的容量
func (q *Queue[E]) Cap() int {
	return q.cap
}

// Empty 判断队列是否为空
func (q *Queue[E]) Empty() bool {
	return q.len == 0
}

// Full 判断队列是否为满
func (q *Queue[E]) Full() bool {
	return q.len == q.cap
}

func (q *Queue[E]) checkIndex(i int) {
	if i >= q.len || i < 0 {
		goPanicIndex(i, q.len)
	}
}

func (q *Queue[E]) tailIndex() int {
	tail := q.tail - 1
	if tail < 0 {
		tail = q.cap - 1
	}
	return tail
}

func (q *Queue[E]) rawIndex(i int) int {
	if i += q.head; i >= q.cap {
		return i - q.cap
	}
	return i
}

// Get 获取队列指定索引位置的元素
func (q *Queue[E]) Get(i int) E {
	q.checkIndex(i)
	return q.raw[q.rawIndex(i)]
}

// Use 获取队列指定索引位置的元素指针
func (q *Queue[E]) Use(i int) *E {
	q.checkIndex(i)
	return &q.raw[q.rawIndex(i)]
}

// Head 获取队列头部的元素，返回值 exist 为 false 表示队列为空
func (q *Queue[E]) Head() (e E, exist bool) {
	if q.len > 0 {
		return q.raw[q.head], true
	}
	return
}

// UseHead 获取队列头部的元素指针，返回 nil 表示队列为空
func (q *Queue[E]) UseHead() *E {
	if q.len > 0 {
		return &q.raw[q.head]
	}
	return nil
}

// Tail 获取队列尾部的元素，返回值 exist 为 false 表示队列为空
func (q *Queue[E]) Tail() (e E, exist bool) {
	if q.len > 0 {
		return q.raw[q.tailIndex()], true
	}
	return
}

// UseTail 获取队列尾部的元素指针，返回 nil 表示队列为空
func (q *Queue[E]) UseTail() *E {
	if q.len > 0 {
		return &q.raw[q.tailIndex()]
	}
	return nil
}

// Slice 获取队列空间指定范围内对应的切片，返回值 prefix, suffix 代表队列空间的前半部分(在范
// 围内头部指针后的空间)和后半部分(在范围内头部指针前的空间)
func (q *Queue[E]) Slice(start, end int) (prefix, suffix []E) {
	if end < 0 {
		end = q.len
	} else if end > q.cap {
		goPanicSliceAcap(end, q.cap)
	}
	if start < 0 {
		start = 0
	} else if start > end {
		goPanicSliceB(start, end)
	}
	if start += q.head; start >= q.cap {
		start -= q.cap
		end += q.head - q.cap
		return nil, q.raw[start:end]
	} else if end += q.head; end > q.cap {
		end -= q.cap
		return q.raw[start:], q.raw[:end]
	} else {
		return q.raw[start:end], nil
	}
}

// Copy 拷贝队列指定位置后的元素到指定切片，返回拷贝元素的个数
func (q *Queue[E]) Copy(dst []E, start int) (n int) {
	if start < 0 {
		start = 0
	} else if start > q.len {
		goPanicSliceB(start, q.len)
	}
	end := start + len(dst)
	if end > q.len {
		end = q.len
	}
	if start += q.head; start >= q.cap {
		start -= q.cap
		end += q.head - q.cap
		return copy(dst, q.raw[start:end])
	} else if end += q.head; end > q.cap {
		end -= q.cap
		n = copy(dst, q.raw[start:])
		n += copy(dst[n:], q.raw[:end])
		return
	} else {
		return copy(dst, q.raw[start:end])
	}
}

// Range 遍历队列中的所有元素，fn 为遍历函数，遍历函数返回 false 则终止遍历，并使得此函数返回
// false。若遍历过程中没有因遍历函数终止遍历(即遍历完所有元素)，则此函数返回 true
func (q *Queue[E]) Range(fn func(i int, e E) bool) bool {
	head := q.head
	for i := 0; i < q.len; i++ {
		if !fn(i, q.raw[head]) {
			return false
		}
		if head++; head == q.cap {
			head = 0
		}
	}
	return true
}

func (q *Queue[E]) tailGrow() {
	if q.tail++; q.tail == q.cap {
		q.tail = 0
	}
	q.len++
}

func (q *Queue[E]) headGrow() {
	if q.head--; q.head < 0 {
		q.head = q.cap - 1
	}
	q.len++
}

// Append 在队列尾部添加元素，队列满则不执行任何操作
func (q *Queue[E]) Append(e E) {
	if q.len == q.cap {
		return
	}
	q.raw[q.tail] = e
	q.tailGrow()
}

// Append 在队列尾部添加元素，队列满则抛出错误
func (q *Queue[E]) MustAppend(e E) {
	if q.len == q.cap {
		goPanicSliceAcap(q.len+1, q.cap)
	}
	q.raw[q.tail] = e
	q.tailGrow()
}

// Push 在队列尾部添加元素，添加成功返回 true，由于队列满添加失败返回 false
func (q *Queue[E]) Push(e E) bool {
	if q.len == q.cap {
		return false
	}
	q.raw[q.tail] = e
	q.tailGrow()
	return true
}

// Alloc 在队列尾部申请一个元素的空间，申请成功返回此元素空间的地址，由于队列满申请失败返回 nil
func (q *Queue[E]) Alloc() (p *E) {
	if q.len == q.cap {
		return nil
	}
	p = &q.raw[q.tail]
	q.tailGrow()
	return
}

// Unshift 在队列头部添加元素，添加成功返回 true，由于队列满添加失败返回 false
func (q *Queue[E]) Unshift(e E) bool {
	if q.len == q.cap {
		return false
	}
	q.headGrow()
	q.raw[q.head] = e
	return true
}

// UnshiftAlloc 在队列头部申请一个元素的空间，申请成功返回此元素空间的地址，由于队列满申请失败
// 返回 nil
func (q *Queue[E]) UnshiftAlloc() *E {
	if q.len == q.cap {
		return nil
	}
	q.headGrow()
	return &q.raw[q.head]
}

// Pop 移除队列尾部的一个元素，返回被移除的元素以及是否有元素被移除
func (q *Queue[E]) Pop() (e E, ok bool) {
	if q.len == 0 {
		return
	}
	if q.tail--; q.tail < 0 {
		q.tail = q.cap - 1
	}
	e, ok = q.raw[q.tail], true
	q.len--
	return
}

// Shift 移除队列头部的一个元素，返回被移除的元素以及是否有元素被移除
func (q *Queue[E]) Shift() (e E, ok bool) {
	if q.len == 0 {
		return
	}
	e, ok = q.raw[q.head], true
	if q.head++; q.head == q.cap {
		q.head = 0
	}
	q.len--
	return
}

// ShiftTo 将队列头部开始的多个元素移除到指定切片中，返回移除元素的个数
func (q *Queue[E]) ShiftTo(dst []E) (n int) {
	end := len(dst)
	if end > q.len {
		end = q.len
	}
	if end += q.head; end > q.cap {
		end -= q.cap
		n = copy(dst, q.raw[q.head:])
		n += copy(dst[n:], q.raw[:end])
	} else {
		n = copy(dst, q.raw[q.head:end])
	}
	q.len -= n
	q.head = end
	return
}

// ShiftAll 将所有元素移除到切片中，并返回此切片
func (q *Queue[E]) ShiftAll() []E {
	es := make([]E, q.len)
	q.ShiftTo(es)
	return es
}

// Set 设置指定索引位置的元素
func (q *Queue[E]) Set(i int, e E) {
	q.checkIndex(i)
	q.raw[q.rawIndex(i)] = e
}

// Swap 交换指定索引位置的元素
func (q *Queue[E]) Swap(i, j int) {
	q.checkIndex(i)
	q.checkIndex(j)
	i, j = q.rawIndex(i), q.rawIndex(j)
	q.raw[i], q.raw[j] = q.raw[j], q.raw[i]
}

func (q *Queue[E]) Removes(n int) int {
	if n > q.len {
		n = q.len
	}
	if q.tail -= n; q.tail < 0 {
		q.tail += q.cap
	}
	q.len -= n
	return n
}

func (q *Queue[E]) ShiftRemoves(n int) int {
	if n > q.len {
		n = q.len
	}
	if q.head += n; q.head >= q.cap {
		q.head -= q.cap
	}
	q.len -= n
	return n
}

// Clear 清空队列
func (q *Queue[E]) Clear() {
	q.head = q.tail
	q.len = 0
}

// Clear 重置队列。与清空队列类似，但会重置头部指针和尾部指针到队列空间的起始处
func (q *Queue[E]) Reset() {
	q.head, q.tail = 0, 0
	q.len = 0
}