objects/internal/history.go

93 lines
2.5 KiB
Go
Raw Normal View History

package internal
2024-09-05 18:11:40 -06:00
import "time"
// History stores a stack of items, always keeping the bottom-most one. It must
// be created using the NewHistory constructor, otherwise it will be invalid.
2024-09-05 22:12:05 -06:00
type History[T comparable] struct {
2024-09-05 18:11:40 -06:00
max int
stack []T
topIndex int
topTime time.Time
}
// NewHistory creates a new History. The initial item will be on the bottom, and
// it will remain there until the History overflows and chooses the item after
// it to be the initial item.
2024-09-05 22:12:05 -06:00
func NewHistory[T comparable] (initial T, max int) *History[T] {
2024-09-05 18:11:40 -06:00
return &History[T] {
max: max,
stack: []T { initial },
}
}
// Top returns the most recent item.
func (this *History[T]) Top () T {
return this.stack[this.topIndex]
}
// Swap replaces the most recent item with another.
func (this *History[T]) Swap (item T) {
this.topTime = time.Now()
2024-09-05 22:12:05 -06:00
this.SwapSilently(item)
}
// SwapSilently replaces the most recent item with another without updating the
// time.
func (this *History[T]) SwapSilently (item T) {
2024-09-05 18:11:40 -06:00
this.stack[this.topIndex] = item
}
2024-09-05 22:12:05 -06:00
// Push pushes a new item onto the stack. If the stack overflows (becomes bigger
// than the specified max value), the initial item is removed and the one on top
// of it takes its place.
2024-09-05 18:11:40 -06:00
func (this *History[T]) Push (item T) {
this.topTime = time.Now()
2024-09-05 22:12:05 -06:00
if this.Top() != item {
this.topIndex ++
this.stack = append(this.stack[:this.topIndex], item)
}
if len(this.stack) > this.max {
2024-09-12 00:56:56 -06:00
this.topIndex --
2024-09-05 22:12:05 -06:00
this.stack = this.stack[1:]
}
2024-09-05 18:11:40 -06:00
}
// PushWeak replaces the most recent item if it was added recently (sooner than
// specified by minAge), and will otherwise push the item normally. If the
// history was popped or cleared beforehand, the item will always be pushed
// normally. This is intended to be used for things such as keystrokes.
func (this *History[T]) PushWeak (item T, minAge time.Duration) {
if time.Since(this.topTime) > minAge {
this.Push(item)
} else {
this.Swap(item)
}
}
// Redo undoes an Undo operation and returns the resulting top of the stack.
func (this *History[T]) Redo () T {
if this.topIndex < len(this.stack) - 1 {
this.topIndex ++
}
return this.Top()
}
// Undo removes the most recent item and returns what was under it. If there is
// only one item (the initial item), it will kept and returned.
func (this *History[T]) Undo () T {
this.topTime = time.Time { }
if this.topIndex > 0 {
this.topIndex --
}
return this.Top()
}
// Clear removes all items except for the initial one.
func (this *History[T]) Clear () {
this.topTime = time.Time { }
this.stack = this.stack[:1]
this.topIndex = 0
}