Big refactor

pkg/chunk/stack.go

@@ -0,0 +1,75 @@
+package chunk
+
+import (
+	"container/list"
+	"sync"
+)
+
+// Stack is a thread safe list/stack implementation
+type Stack struct {
+	items   *list.List
+	lock    sync.Mutex
+	maxSize int
+}
+
+// NewStack creates a new stack
+func NewStack(maxChunks int) *Stack {
+	return &Stack{
+		items:   list.New(),
+		maxSize: maxChunks,
+	}
+}
+
+// Len gets the number of items on the stack
+func (s *Stack) Len() int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return s.items.Len()
+}
+
+// Pop pops the first item from the stack
+func (s *Stack) Pop() int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	if s.items.Len() < s.maxSize {
+		return -1
+	}
+	item := s.items.Front()
+	if nil == item {
+		return -1
+	}
+	s.items.Remove(item)
+	return item.Value.(int)
+}
+
+// Touch moves the specified item to the last position of the stack
+func (s *Stack) Touch(item *list.Element) {
+	s.lock.Lock()
+	if item != s.items.Back() {
+		s.items.MoveToBack(item)
+	}
+	s.lock.Unlock()
+}
+
+// Push adds a new item to the last position of the stack
+func (s *Stack) Push(id int) *list.Element {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return s.items.PushBack(id)
+}
+
+// Prepend adds a list to the front of the stack
+func (s *Stack) Prepend(items *list.List) {
+	s.lock.Lock()
+	s.items.PushFrontList(items)
+	s.lock.Unlock()
+}
+
+// Purge an item from the stack
+func (s *Stack) Purge(item *list.Element) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	if item != s.items.Front() {
+		s.items.MoveToFront(item)
+	}
+}