115 lines
2.8 KiB
Go
115 lines
2.8 KiB
Go
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
package gotoolkit
|
|
|
|
import "errors"
|
|
|
|
// Queue defines an interface for implementing Queue data structures.
|
|
type Queue interface {
|
|
Enqueue(item interface{})
|
|
Dequeue() (interface{}, error)
|
|
Peek() (interface{}, error)
|
|
IsEmpty() bool
|
|
Size() uint64
|
|
}
|
|
|
|
// ListQueue implements a queue backed by a linked list, it may be faster than SliceQueue
|
|
// but consumes more memory and has worse cache locality than SliceQueue
|
|
type ListQueue struct {
|
|
first *node
|
|
last *node
|
|
size uint64
|
|
}
|
|
|
|
// Enqueue adds an element to the end of the queue.
|
|
func (q *ListQueue) Enqueue(item interface{}) {
|
|
last := new(node)
|
|
last.item = item
|
|
|
|
if q.IsEmpty() {
|
|
q.first = last
|
|
} else {
|
|
oldLast := q.last
|
|
oldLast.next = last
|
|
}
|
|
q.last = last
|
|
q.size++
|
|
}
|
|
|
|
// Dequeue removes the first element from the queue.
|
|
func (q *ListQueue) Dequeue() (interface{}, error) {
|
|
if q.IsEmpty() {
|
|
q.last = nil
|
|
return nil, errors.New("unable to dequeue element, queue is empty")
|
|
}
|
|
|
|
item := q.first.item
|
|
q.first = q.first.next
|
|
q.size--
|
|
return item, nil
|
|
}
|
|
|
|
// Peek returns the first element in the queue without removing it.
|
|
func (q *ListQueue) Peek() (interface{}, error) {
|
|
if q.IsEmpty() {
|
|
return nil, errors.New("unable to peek element, queue is empty")
|
|
}
|
|
return q.first.item, nil
|
|
}
|
|
|
|
// IsEmpty returns whether the queue is empty or not.
|
|
func (q *ListQueue) IsEmpty() bool {
|
|
return q.first == nil
|
|
}
|
|
|
|
// Size returns the number of elements in the queue.
|
|
func (q *ListQueue) Size() uint64 {
|
|
return q.size
|
|
}
|
|
|
|
// SliceQueue implements a queue backed by a growing slice. Useful for memory
|
|
// constrained environments. It also has better cache locality than ListQueue
|
|
type SliceQueue struct {
|
|
size uint64
|
|
backing []interface{}
|
|
}
|
|
|
|
// Enqueue adds an element to the end of the queue.
|
|
func (s *SliceQueue) Enqueue(item interface{}) {
|
|
s.size++
|
|
s.backing = append(s.backing, item)
|
|
}
|
|
|
|
// Peek returns the first element of the queue without removing it from the queue.
|
|
func (s *SliceQueue) Peek() (interface{}, error) {
|
|
if s.IsEmpty() {
|
|
return nil, errors.New("unable to peek element, queue is empty")
|
|
}
|
|
return s.backing[0], nil
|
|
}
|
|
|
|
// Dequeue removes and return the first element from the queue.
|
|
func (s *SliceQueue) Dequeue() (interface{}, error) {
|
|
if s.IsEmpty() {
|
|
return nil, errors.New("unable to dequeue element, queue is empty")
|
|
}
|
|
|
|
item := s.backing[0]
|
|
// https://github.com/golang/go/wiki/SliceTricks
|
|
s.backing = append(s.backing[:0], s.backing[1:]...)
|
|
s.size--
|
|
return item, nil
|
|
}
|
|
|
|
// IsEmpty returns whether or not the queue is empty.
|
|
func (s *SliceQueue) IsEmpty() bool {
|
|
return len(s.backing) == 0
|
|
}
|
|
|
|
// Size returns the number of elements in the queue.
|
|
func (s *SliceQueue) Size() uint64 {
|
|
return s.size
|
|
}
|