func TestPush(t *testing.T) {
h := &uint64Heap{}
heap.Init(h)
e := elem{val: 5}
heap.Push(h, e)
e.val = 3
heap.Push(h, e)
e.val = 4
heap.Push(h, e)
require.Equal(t, h.Len(), 3)
require.EqualValues(t, (*h)[0].val, 3)
e.val = 10
(*h)[0] = e
heap.Fix(h, 0)
require.EqualValues(t, (*h)[0].val, 4)
e.val = 11
(*h)[0] = e
heap.Fix(h, 0)
require.EqualValues(t, (*h)[0].val, 5)
e = heap.Pop(h).(elem)
require.EqualValues(t, e.val, 5)
e = heap.Pop(h).(elem)
require.EqualValues(t, e.val, 10)
e = heap.Pop(h).(elem)
require.EqualValues(t, e.val, 11)
require.Equal(t, h.Len(), 0)
}
func main() {
in, _ := os.Open("10954.in")
defer in.Close()
out, _ := os.Create("10954.out")
defer out.Close()
var n, num int
for {
if fmt.Fscanf(in, "%d", &n); n == 0 {
break
}
pq := make(priorityQueue, n)
for i := range pq {
fmt.Fscanf(in, "%d", &num)
pq[i] = &item{num}
}
heap.Init(&pq)
total := 0
for pq.Len() > 1 {
n1 := heap.Pop(&pq).(*item)
n2 := heap.Pop(&pq).(*item)
total += n1.value + n2.value
heap.Push(&pq, &item{n1.value + n2.value})
}
fmt.Fprintln(out, total)
}
}
func TestQueue(t *testing.T) {
q := NewImageCache()
heap.Push(q, NewCacheItem("item1", nil))
time.Sleep(time.Duration(1) * time.Millisecond)
heap.Push(q, NewCacheItem("item2", nil))
time.Sleep(time.Duration(1) * time.Millisecond)
heap.Push(q, NewCacheItem("item3", nil))
time.Sleep(time.Duration(1) * time.Millisecond)
heap.Push(q, NewCacheItem("item4", nil))
time.Sleep(time.Duration(1) * time.Millisecond)
t.Log(q.GetPaths())
q.Update("item1")
t.Log(q.GetPaths())
t.Log(q.Top().path)
heap.Pop(q)
t.Log(q.GetPaths())
t.Log(q.Top().path)
heap.Pop(q)
t.Log(q.GetPaths())
t.Log(q.Top().path)
heap.Pop(q)
t.Log(q.GetPaths())
}
// Retorna a arvore
func Harvest(freqMap map[string]int) *tree.Node {
// Primeiro a gente cria a nossa priorityqueue a partir do dicionario de frequencias
hh := huffmanHeap.New(freqMap)
for {
// Caso a heap contenha um unico elemento retornamos ela
if hh.Len() == 1 {
return heap.Pop(&hh).(*huffmanHeap.Item).Node
}
// Caso contrario pegamos os dois elementos do topo
r, ok1 := heap.Pop(&hh).(*huffmanHeap.Item)
l, ok2 := heap.Pop(&hh).(*huffmanHeap.Item)
if !ok1 || !ok2 {
panic(errors.New("Element was not of type huffmanHeap.Item"))
}
//E criamos uma "arvore" intermediaria com eles
newItem := &huffmanHeap.Item{
Node: tree.New("", r.Node, l.Node),
Frequency: r.Frequency + l.Frequency,
}
// Adicionando em seguida ao
heap.Push(&hh, newItem)
}
}
// makeTreeFromNodeSlice makes a tree from a slice of huffNodes, with the
// lowest-count nodes going farthest from the root. Returns a non-nil error
// on failure, nil error otherwise. Returns the created tree. If nodes is empty,
// returns an error.
func makeTreeFromNodeSlice(nodes []*huffNode) (t *huffNode, err error) {
if len(nodes) == 0 {
return nil, errors.New("Too few elements!")
}
// We're going to put the nodes in a heap, with low-ness determined
// by the nodes' counts.
nh := &nodeHeap{}
heap.Init(nh)
for _, node := range nodes {
heap.Push(nh, node)
}
// Now, we're going to do the following:
//
// Until there's only one node in the heap:
// Remove the lowest-count two nodes
// Make a new node with those two as children, whose count is the
// sum of its childrens' counts
// Add that new node to the heap
//
// This will create an optimally-balanced tree, based on byte counts. For
// more information, see http://en.wikipedia.org/wiki/Huffman_coding.
for nh.Len() > 1 {
nodeOne := heap.Pop(nh).(*huffNode)
nodeTwo := heap.Pop(nh).(*huffNode)
newNode := &huffNode{char: 1,
count: nodeOne.count + nodeTwo.count,
left: nodeOne,
right: nodeTwo}
heap.Push(nh, newNode)
}
// Great, now there's only one node and it's the root of the tree!
return heap.Pop(nh).(*huffNode), nil
}
// This helper function finds the k nearest neighbours of target in items. It's
// slower than the VPTree, but its correctness is easy to verify, so we can
// test the VPTree against it.
func nearestNeighbours(target uint64, items []Item, k int) (coords []Item, distances []float64) {
pq := &priorityQueue{}
// Push all items onto a heap
for _, v := range items {
d := hamming(v.Sig, target)
heap.Push(pq, &heapItem{v, d})
}
// Pop all but the k smallest items
for pq.Len() > k {
heap.Pop(pq)
}
// Extract the k smallest items and distances
for pq.Len() > 0 {
hi := heap.Pop(pq)
coords = append(coords, hi.(*heapItem).Item)
distances = append(distances, hi.(*heapItem).Dist)
}
// Reverse coords and distances, because we popped them from the heap
// in large-to-small order
for i, j := 0, len(coords)-1; i < j; i, j = i+1, j-1 {
coords[i], coords[j] = coords[j], coords[i]
distances[i], distances[j] = distances[j], distances[i]
}
return
}
func (s *S) TestEvictOldest(c *C) {
q := make(utility.PriorityQueue, 0, 10)
heap.Init(&q)
var e EvictionPolicy = EvictOldest(5)
for i := 0; i < 10; i++ {
var item utility.Item = utility.Item{
Value: float64(i),
Priority: int64(i),
}
heap.Push(&q, &item)
}
c.Check(q, HasLen, 10)
e(&q)
c.Check(q, HasLen, 5)
c.Check(heap.Pop(&q), utility.ValueEquals, 4.0)
c.Check(heap.Pop(&q), utility.ValueEquals, 3.0)
c.Check(heap.Pop(&q), utility.ValueEquals, 2.0)
c.Check(heap.Pop(&q), utility.ValueEquals, 1.0)
c.Check(heap.Pop(&q), utility.ValueEquals, 0.0)
}
// DeleteDuplicates heap sorts a slice and returns a new slice with duplicate
// entries removed.
func DeleteDuplicates(theArray []int) []int {
// Need to get a mutable copy of the heap
heapHelper := make(HeapHelper, len(theArray))
i := 0
for _, value := range theArray {
heapHelper[i] = value
i++
}
heap.Init(&heapHelper)
// How to do this in-place?
result := make([]int, 0)
if len(theArray) > 0 {
prevElement := heap.Pop(&heapHelper).(int)
result = append(result, prevElement)
for heapHelper.Len() > 0 {
currentElement := heap.Pop(&heapHelper).(int)
if currentElement != prevElement {
result = append(result, currentElement)
prevElement = currentElement
}
}
}
return result
}
func createTreeFromFrequencies(frequencies []uint, sizes_ []byte, ranks []byte) error {
// Create Huffman tree of (present) symbols
queue := make(HuffmanPriorityQueue, 0)
for i := range ranks {
heap.Push(&queue, &HuffmanNode{symbol: ranks[i], weight: frequencies[ranks[i]]})
}
for queue.Len() > 1 {
// Extract 2 minimum nodes, merge them and enqueue result
lNode := heap.Pop(&queue).(*HuffmanNode)
rNode := heap.Pop(&queue).(*HuffmanNode)
// Setting the symbol is critical to resolve ties during node sorting !
heap.Push(&queue, &HuffmanNode{weight: lNode.weight + rNode.weight, left: lNode, right: rNode, symbol: lNode.symbol})
}
rootNode := heap.Pop(&queue).(*HuffmanNode)
var err error
if len(ranks) == 1 {
sizes_[rootNode.symbol] = byte(1)
} else {
err = fillSizes(rootNode, 0, sizes_)
}
return err
}
func findMin(n, k, a, b, c, r int) int {
m := []int{a}
for i := 1; i < k; i++ {
m = append(m, (b*m[i-1]+c)%r)
}
o := make([]int, k)
copy(o, m)
sort.Ints(o)
h := &intHeap{}
heap.Init(h)
var x, y int
for i := 0; i <= k; {
if y >= k || x < o[y] {
heap.Push(h, x)
x++
i++
} else {
if x == o[y] {
x++
}
y++
}
}
for len(m)+1 < n {
p := heap.Pop(h).(int)
if h.notyet(m[len(m)-k]) && notagain(m[len(m)-k+1:len(m)], m[len(m)-k]) {
heap.Push(h, m[len(m)-k])
}
m = append(m, p)
}
return heap.Pop(h).(int)
}
func TestPriorityQueue(t *testing.T) {
pq := New()
heap.Init(pq)
heap.Push(pq, &Item{Value: "hello3", Priority: 3})
heap.Push(pq, &Item{Value: "hello1", Priority: 1})
heap.Push(pq, &Item{Value: "hello8", Priority: 8})
assert.Equal(t, 3+1+8, pq.PrioritySum())
item := pq.Peek()
assert.Equal(t, "hello8", item.(*Item).Value.(string))
item = pq.Peek()
assert.Equal(t, "hello8", item.(*Item).Value.(string))
item = heap.Pop(pq)
assert.Equal(t, "hello8", item.(*Item).Value.(string))
assert.Equal(t, 3+1, pq.PrioritySum())
item = heap.Pop(pq)
assert.Equal(t, "hello3", item.(*Item).Value.(string))
item = heap.Pop(pq)
assert.Equal(t, "hello1", item.(*Item).Value.(string))
assert.Equal(t, 0, pq.Len())
}
func TestJobHeap(t *testing.T) {
jobs := &JobHeap{}
heap.Init(jobs)
job1 := Job{Description: "job 1", Created: time.Now()}
job2 := Job{Description: "job 2", Created: time.Now()} //, Ctrl: JobControl{JobPriority: 100}}
job3 := Job{Description: "job 3", Created: time.Now()} //, Ctrl: JobControl{JobPriority: 104}}
heap.Push(jobs, &job2)
heap.Push(jobs, &job3)
heap.Push(jobs, &job1)
for _, job := range *jobs {
fmt.Println(job)
}
fmt.Println("===")
fmt.Println(jobs.Peek())
fmt.Println("---")
ret1 := heap.Pop(jobs)
ret2 := heap.Pop(jobs)
ret3 := heap.Pop(jobs)
fmt.Println(ret1)
fmt.Println(ret2)
fmt.Println(ret3)
}
func TestEventQueue(t *testing.T) {
queue := make(EventQueue, 0, 4)
heap.Push(&queue, &Event{Y: 5})
heap.Push(&queue, &Event{Y: 3})
heap.Push(&queue, &Event{Y: 7})
heap.Push(&queue, &Event{Y: 1})
var e *Event
e = heap.Pop(&queue).(*Event)
if e.Y != 7 {
t.Fatalf("Wanted priority 7, got %v", e.Y)
}
e = heap.Pop(&queue).(*Event)
if e.Y != 5 {
t.Fatalf("Wanted priority 5, got %v", e.Y)
}
e = heap.Pop(&queue).(*Event)
if e.Y != 3 {
t.Fatalf("Wanted priority 3, got %v", e.Y)
}
e = heap.Pop(&queue).(*Event)
if e.Y != 1 {
t.Fatalf("Wanted priority 1, got %v", e.Y)
}
}
func addMinPathLeft(graph *m.Graph) {
dp := &m.DijkstraPrio{}
heap.Init(dp)
visited := make(map[*m.Node]bool)
endNode := graph.EndNode()
endNode.SetMinPathLeft(0)
visited[endNode] = true
for _, edge := range endNode.ToEdges() {
node := edge.From()
node.SetMinPathLeft(edge.FastestTime())
heap.Push(dp, node)
}
if dp.Len() > 0 {
for node := heap.Pop(dp).(*m.Node); dp.Len() > 0; node = heap.Pop(dp).(*m.Node) {
visited[node] = true
for _, edge := range node.ToEdges() {
innerNode := edge.From()
if !visited[innerNode] {
innerNode.SetMinPathLeft(edge.FastestTime() + node.MinPathLeft())
heap.Push(dp, innerNode)
}
}
}
}
}
// ConsiderWeighted lets the sample inspect a new value with a positive given
// weight. A weight of one corresponds to the unweighted reservoir sampling
// algorithm. A nonpositive weight will lead to the item being rejected without
// having been observed. To avoid numerical instabilities, it is advisable to
// stay away from zero and infinity, or more generally from regions in which
// computing x**1/weight may be ill-behaved.
func (rs *WeightedReservoirSample) ConsiderWeighted(value interface{}, weight float64) {
if weight <= 0 {
glog.Warningf("reservoir sample received non-positive weight %f", weight)
return
}
h := rs.Heap
wv := WeightedValue{
Value: value,
key: rs.makeKey(weight),
}
if h.Len() < rs.size {
heap.Push(h, wv)
if rs.threshold == 0 || wv.key < rs.threshold {
rs.threshold = wv.key
}
return
}
if wv.key > rs.threshold {
// Remove the element with threshold key.
heap.Pop(h)
// Add in the new element (which has a higher key).
heap.Push(h, wv)
// Update the threshold to reflect the new threshold.
twv := heap.Pop(h).(WeightedValue)
rs.threshold = twv.key
heap.Push(h, twv)
}
}
func DestructiveUnionSloppy(polygons *[]*Polygon, vertexMergeRadius s1.Angle) *Polygon {
// Create a priority queue of polygons in order of number of vertices.
// Repeatedly union the two smallest polygons and add the result to the
// queue until we have a single polygon to return.
pq := make(IntPolygonQueue, len(*polygons))
for i := 0; i < len(*polygons); i++ {
pq[i] = &IntPolygonPair{
size: (*polygons)[i].numVertices,
poly: (*polygons)[i],
}
}
heap.Init(&pq)
*polygons = []*Polygon{}
for pq.Len() > 1 {
// Pop two simplest polygons from queue.
a := heap.Pop(&pq).(*IntPolygonPair)
b := heap.Pop(&pq).(*IntPolygonPair)
// Union and add result back to queue.
var c Polygon
c.InitToUnionSloppy(a.poly, b.poly, vertexMergeRadius)
heap.Push(&pq, &IntPolygonPair{
size: a.size + b.size,
poly: &c,
})
}
if pq.Len() == 0 {
return &Polygon{}
}
return heap.Pop(&pq).(*IntPolygonPair).poly
}
// NewTree creates a huffman tree and gets the codes for the symbol
// frequencies given.
func NewTree(freqs rle2.Frequencies) *Tree {
tree := &Tree{Codes: make([]*Code, len(freqs))}
var queue NodeQueue
for i, f := range freqs {
queue = append(queue, &Node{Value: uint16(i), Frequency: f})
}
heap.Init(&queue)
// As long as we have multiple nodes, remove the two lowest frequency
// symbols and create a new node with them as children.
for queue.Len() > 1 {
left := heap.Pop(&queue).(*Node)
right := heap.Pop(&queue).(*Node)
heap.Push(&queue, &Node{
Left: left,
Right: right,
Frequency: left.Frequency + right.Frequency,
})
}
tree.root = heap.Pop(&queue).(*Node)
tree.getCodes(tree.root, 0, 0)
return tree
}
// notifyConfs examines the current confirmation heap, sending off any
// notifications which have been triggered by the connection of a new block at
// newBlockHeight.
func (b *BtcdNotifier) notifyConfs(newBlockHeight int32) {
// If the heap is empty, we have nothing to do.
if b.confHeap.Len() == 0 {
return
}
// Traverse our confirmation heap. The heap is a
// min-heap, so the confirmation notification which requires
// the smallest block-height will always be at the top
// of the heap. If a confirmation notification is eligible
// for triggering, then fire it off, and check if another
// is eligible until there are no more eligible entries.
nextConf := heap.Pop(b.confHeap).(*confEntry)
for nextConf.triggerHeight <= uint32(newBlockHeight) {
nextConf.finConf <- newBlockHeight
if b.confHeap.Len() == 0 {
return
}
nextConf = heap.Pop(b.confHeap).(*confEntry)
}
heap.Push(b.confHeap, nextConf)
}
func TestScanCursors(t *testing.T) {
s := ScanCursors{}
heap.Init(&s)
heap.Push(&s, &testScanCursor{
key: "b",
})
heap.Push(&s, &testScanCursor{
key: "a",
})
heap.Push(&s, &testScanCursor{
key: "c",
})
a := heap.Pop(&s).(*testScanCursor)
if a.key != "a" {
t.Errorf("expected a")
}
b := heap.Pop(&s).(*testScanCursor)
if b.key != "b" {
t.Errorf("expected b")
}
c := heap.Pop(&s).(*testScanCursor)
if c.key != "c" {
t.Errorf("expected c")
}
}
// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *Queue) Run() {
pq := &PriorityQueue{}
heap.Init(pq)
for {
select {
case <-b.quit:
// quit the block
return
case msg := <-b.inPush:
queueMessage := &PQMessage{
val: msg,
t: time.Now(),
}
heap.Push(pq, queueMessage)
case <-b.inPop:
if len(*pq) == 0 {
continue
}
msg := heap.Pop(pq).(*PQMessage).val
b.out <- msg
case MsgChan := <-b.queryPop:
var msg interface{}
if len(*pq) > 0 {
msg = heap.Pop(pq).(*PQMessage).val
}
MsgChan <- msg
case MsgChan := <-b.queryPeek:
var msg interface{}
if len(*pq) > 0 {
msg = pq.Peek().(*PQMessage).val
}
MsgChan <- msg
}
}
}
func Compress(fin, fout *os.File) {
var (
freq_table hfFreqTable = make(hfFreqTable, 255)
code_table hfCodeTable = make(hfCodeTable)
tree hfHeap
)
countFreq(&freq_table, fin)
// create heap and fill code table
for ch, freq := range freq_table {
tree.Push(&hfNode{char: ch, freq: freq})
}
heap.Init(&tree)
if len(tree) == 1 {
code_table[tree[0].char] = hfCode{Len: 1, Code: 0}
} else if len(tree) > 1 {
for len(tree) > 1 {
l := heap.Pop(&tree).(*hfNode)
r := heap.Pop(&tree).(*hfNode)
parent := &hfNode{freq: l.freq + r.freq, left: l, right: r}
heap.Push(&tree, parent)
}
fillCodeTable(&code_table, tree[0], 0, 0)
}
serializeMetaInfo(&code_table, fin, fout)
// encode
var (
outbyte, outlen byte = 0, 0
i uint = 0
)
reader := bufio.NewReader(fin)
writer := bufio.NewWriter(fout)
defer writer.Flush()
for {
curr, error := reader.ReadByte()
if error != nil {
break
}
entry := code_table[curr]
for i < entry.Len {
for ; i < entry.Len && outlen < BITS_IN_BYTE; i++ {
if (entry.Code & (1 << i)) != 0 {
outbyte |= 1 << outlen
}
outlen++
}
if outlen == BITS_IN_BYTE {
writer.WriteByte(outbyte)
outbyte, outlen = 0, 0
}
}
i = 0
}
if outlen != 0 {
writer.WriteByte(outbyte)
}
}
func TestRefHeap(t *testing.T) {
unique := 0
newRefWithHeight := func(height uint64) Ref {
r := NewRef(Number(unique))
unique++
r.height = height
return r
}
assert := assert.New(t)
h := RefHeap{}
heap.Init(&h)
r1 := newRefWithHeight(1)
r2 := newRefWithHeight(2)
r3 := newRefWithHeight(3)
r4 := newRefWithHeight(2)
heap.Push(&h, r1)
assert.Equal(r1, h[0])
assert.Equal(1, len(h))
heap.Push(&h, r3)
assert.Equal(r3, h[0])
assert.Equal(2, len(h))
heap.Push(&h, r2)
assert.Equal(r3, h[0])
assert.Equal(3, len(h))
heap.Push(&h, r4)
assert.Equal(r3, h[0])
assert.Equal(4, len(h))
expectedSecond, expectedThird := func() (Ref, Ref) {
if r2.TargetHash().Less(r4.TargetHash()) {
return r2, r4
}
return r4, r2
}()
assert.Equal(r3, heap.Pop(&h).(Ref))
assert.Equal(expectedSecond, h[0])
assert.Equal(3, len(h))
assert.Equal(expectedSecond, heap.Pop(&h).(Ref))
assert.Equal(expectedThird, h[0])
assert.Equal(2, len(h))
assert.Equal(expectedThird, heap.Pop(&h).(Ref))
assert.Equal(r1, h[0])
assert.Equal(1, len(h))
assert.Equal(r1, heap.Pop(&h).(Ref))
assert.Equal(0, len(h))
}
func docAtATime(q []*Term, k int) []*Result {
results := &ResultHeap{}
terms := &TermHeap{}
heap.Init(results)
heap.Init(terms)
for i := 0; i < k; i++ {
heap.Push(results, &Result{0, 0})
}
for i := 0; i < len(q); i++ {
nextDoc := nextDoc(q[i], 0)
if nextDoc != nil {
heap.Push(terms, &TermNextDoc{term: q[i], nextDoc: nextDoc})
}
}
var term *TermNextDoc
var d int
var score float64
var nDoc *Document
var res *Result
popped := false
for len(*terms) > 0 {
popped = false
term = heap.Pop(terms).(*TermNextDoc)
d = term.nextDoc.docId
score = 0.0
for d == term.nextDoc.docId {
score += BM25(term.term, term.nextDoc)
nDoc = nextDoc(term.term, d)
if nDoc != nil {
heap.Push(terms, &TermNextDoc{term: term.term, nextDoc: nDoc})
}
if len(*terms) > 0 {
term = heap.Pop(terms).(*TermNextDoc)
popped = true
} else {
break
}
}
if popped {
heap.Push(terms, term)
}
if score > 0.0 {
res = &Result{doc: d, score: score}
results.PushGreater(res)
}
}
sortedResults := make([]*Result, (*results).Len())
for i := len(sortedResults) - 1; i >= 0; i-- {
sortedResults[i] = heap.Pop(results).(*Result)
}
return sortedResults
}
// Next returns ErrIteratorDone if the iterator is done.
func (iter *iterator) Next() error {
if len(iter.cursors) <= 0 {
return ErrIteratorDone
}
lastK := iter.cursors[0].k
for len(iter.cursors) > 0 {
next := iter.cursors[0]
if next.ssIndex < 0 && next.pos < 0 {
err := iter.lowerLevelIter.Next()
if err == nil {
next.k, next.v, err = iter.lowerLevelIter.Current()
if err == nil && len(iter.cursors) > 1 {
heap.Fix(iter, 0)
}
}
if err != nil {
iter.lowerLevelIter.Close()
iter.lowerLevelIter = nil
heap.Pop(iter)
}
} else {
next.pos++
if next.pos >= next.posEnd {
heap.Pop(iter)
} else {
next.op, next.k, next.v =
iter.ss.a[next.ssIndex].GetOperationKeyVal(next.pos)
if next.op == 0 {
heap.Pop(iter)
} else if len(iter.cursors) > 1 {
heap.Fix(iter, 0)
}
}
}
if len(iter.cursors) <= 0 {
return ErrIteratorDone
}
if !iteratorBytesEqual(iter.cursors[0].k, lastK) {
if !iter.iteratorOptions.IncludeDeletions &&
iter.cursors[0].op == OperationDel {
return iter.Next()
}
return nil
}
}
return ErrIteratorDone
}
func Test() {
var dh DistHeap
heap.Init(&dh)
heap.Push(&dh, &Distance{dist: 0.9, path: "foo1"})
heap.Push(&dh, &Distance{dist: 0.2, path: "foo2"})
heap.Push(&dh, &Distance{dist: 0.3, path: "foo3"})
fmt.Println(heap.Pop(&dh))
fmt.Println(heap.Pop(&dh))
fmt.Println(heap.Pop(&dh))
}
// Median returns the median from all the lines - based on the slope.
// This sorts the underlying slice.
func (ln lines) Median() line {
if len(ln) == 0 {
return line{}
}
h := &ln
heap.Init(h)
for i := 0; i < len(ln)/2; i++ {
heap.Pop(h)
}
return heap.Pop(h).(line)
}
func (this *pq) add(item pqitem) {
if !this.full || this.lowest == nil || this.lowest.Less(item) {
heap.Push(this, item)
if this.full {
heap.Pop(this)
} else if this.Len() > this.n {
this.full = true
heap.Pop(this)
}
this.lowest = this.items[0]
}
}
func (s *MongoOpStream) handleOps() {
defer close(s.Ops)
for op := range s.unorderedOps {
heap.Push(s.opHeap, op)
if len(*s.opHeap) == cap(*s.opHeap) {
s.Ops <- heap.Pop(s.opHeap).(OpWithTime)
}
}
for len(*s.opHeap) > 0 {
s.Ops <- heap.Pop(s.opHeap).(OpWithTime)
}
}
func (t *Blag) archive(w *http.ResponseWriter, r *http.Request) {
var blogRendered bytes.Buffer
pdir, err := os.Open("posts")
var blogs []bytes.Buffer
var offset int64
if r.FormValue("o") != "" {
offset, err = strconv.ParseInt(r.FormValue("o"), 10, 0)
if err != nil {
offset = 0
}
}
if err == nil {
var fheap FileInfoHeap.MMost
heap.Init(&fheap)
newBlogs := make([]bytes.Buffer, 100)
for files, err := pdir.Readdir(len(newBlogs)); err == nil; files, err = pdir.Readdir(len(newBlogs)) {
if err != nil {
break
}
// Skip to archive page
if offset > 0 {
offset--
continue
}
for _, f := range files {
var dup os.FileInfo = f
heap.Push(&fheap, &dup)
}
}
current := 0
if fheap.Len() > 0 {
for f := heap.Pop(&fheap).(*os.FileInfo); ; f = heap.Pop(&fheap).(*os.FileInfo) {
blogEscaped, err := slurpMarkdown("posts/" + (*f).Name())
if err == nil {
t.blogTemplate.Execute(&newBlogs[current], Blog{Main: string(*blogEscaped), Date: (*f).ModTime().Format("1/2/2006"), Author: "kd", Name: (*f).Name()})
current++
} else {
fmt.Println("couldn't process", (*f).Name(), err)
}
if fheap.Len() == 0 {
break
}
}
}
blogs = append(blogs, newBlogs...)
}
// Clearly, there is a less obscene way to do this
for _, blog := range blogs {
blogRendered.Write(blog.Bytes())
}
t.pageTemplate.Execute(*w, Page{MainContent: blogRendered.String(), Name: ""})
}
func TestSnowflakeHeap(t *testing.T) {
h := new(SnowflakeHeap)
heap.Init(h)
if 0 != h.Len() {
t.Error("Unexpected length.")
}
s1 := new(Snowflake)
s2 := new(Snowflake)
s3 := new(Snowflake)
s4 := new(Snowflake)
s1.clients = 4
s2.clients = 5
s3.clients = 3
s4.clients = 1
heap.Push(h, s1)
heap.Push(h, s2)
heap.Push(h, s3)
heap.Push(h, s4)
if 4 != h.Len() {
t.Error("Unexpected length.")
}
heap.Remove(h, 0)
if 3 != h.Len() {
t.Error("Unexpected length.")
}
r := heap.Pop(h).(*Snowflake)
if r.clients != 3 {
t.Error("Unexpected clients: ", r.clients)
}
if r.index != -1 {
t.Error("Unexpected index: ", r.index)
}
r = heap.Pop(h).(*Snowflake)
if r.clients != 4 {
t.Error("Unexpected clients: ", r.clients)
}
r = heap.Pop(h).(*Snowflake)
if r.clients != 5 {
t.Error("Unexpected clients: ", r.clients)
}
if 0 != h.Len() {
t.Error("Unexpected length.")
}
}