Remove uses of container/list

graph/linksto_iterator.go

@@ -30,7 +30,6 @@ package graph
 // Can be seen as the dual of the HasA iterator.
 
 import (
-	"container/list"
 	"fmt"
 	"strings"
 )
@@ -58,120 +57,118 @@ func NewLinksToIterator(ts TripleStore, it Iterator, dir string) *LinksToIterato
 	return &lto
 }
 
-func (l *LinksToIterator) Reset() {
-	l.primaryIt.Reset()
-	if l.nextIt != nil {
-		l.nextIt.Close()
+func (it *LinksToIterator) Reset() {
+	it.primaryIt.Reset()
+	if it.nextIt != nil {
+		it.nextIt.Close()
 	}
-	l.nextIt = &NullIterator{}
+	it.nextIt = &NullIterator{}
 }
 
-func (l *LinksToIterator) Clone() Iterator {
-	out := NewLinksToIterator(l.ts, l.primaryIt.Clone(), l.direction)
-	out.CopyTagsFrom(l)
+func (it *LinksToIterator) Clone() Iterator {
+	out := NewLinksToIterator(it.ts, it.primaryIt.Clone(), it.direction)
+	out.CopyTagsFrom(it)
 	return out
 }
 
 // Return the direction under consideration.
-func (l *LinksToIterator) Direction() string { return l.direction }
+func (it *LinksToIterator) Direction() string { return it.direction }
 
 // Tag these results, and our subiterator's results.
-func (l *LinksToIterator) TagResults(out *map[string]TSVal) {
-	l.BaseIterator.TagResults(out)
-	l.primaryIt.TagResults(out)
+func (it *LinksToIterator) TagResults(out *map[string]TSVal) {
+	it.BaseIterator.TagResults(out)
+	it.primaryIt.TagResults(out)
 }
 
 // DEPRECATED
-func (l *LinksToIterator) GetResultTree() *ResultTree {
-	tree := NewResultTree(l.LastResult())
-	tree.AddSubtree(l.primaryIt.GetResultTree())
+func (it *LinksToIterator) GetResultTree() *ResultTree {
+	tree := NewResultTree(it.LastResult())
+	tree.AddSubtree(it.primaryIt.GetResultTree())
 	return tree
 }
 
 // Print the iterator.
-func (l *LinksToIterator) DebugString(indent int) string {
+func (it *LinksToIterator) DebugString(indent int) string {
 	return fmt.Sprintf("%s(%s %d direction:%s\n%s)",
 		strings.Repeat(" ", indent),
-		l.Type(), l.GetUid(), l.direction, l.primaryIt.DebugString(indent+4))
+		it.Type(), it.GetUid(), it.direction, it.primaryIt.DebugString(indent+4))
 }
 
 // If it checks in the right direction for the subiterator, it is a valid link
 // for the LinksTo.
-func (l *LinksToIterator) Check(val TSVal) bool {
-	CheckLogIn(l, val)
-	node := l.ts.GetTripleDirection(val, l.direction)
-	if l.primaryIt.Check(node) {
-		l.Last = val
-		return CheckLogOut(l, val, true)
+func (it *LinksToIterator) Check(val TSVal) bool {
+	CheckLogIn(it, val)
+	node := it.ts.GetTripleDirection(val, it.direction)
+	if it.primaryIt.Check(node) {
+		it.Last = val
+		return CheckLogOut(it, val, true)
 	}
-	return CheckLogOut(l, val, false)
+	return CheckLogOut(it, val, false)
 }
 
 // Return a list containing only our subiterator.
-func (lto *LinksToIterator) GetSubIterators() *list.List {
-	l := list.New()
-	l.PushBack(lto.primaryIt)
-	return l
+func (it *LinksToIterator) GetSubIterators() []Iterator {
+	return []Iterator{it.primaryIt}
 }
 
 // Optimize the LinksTo, by replacing it if it can be.
-func (lto *LinksToIterator) Optimize() (Iterator, bool) {
-	newPrimary, changed := lto.primaryIt.Optimize()
+func (it *LinksToIterator) Optimize() (Iterator, bool) {
+	newPrimary, changed := it.primaryIt.Optimize()
 	if changed {
-		lto.primaryIt = newPrimary
-		if lto.primaryIt.Type() == "null" {
-			lto.nextIt.Close()
-			return lto.primaryIt, true
+		it.primaryIt = newPrimary
+		if it.primaryIt.Type() == "null" {
+			it.nextIt.Close()
+			return it.primaryIt, true
 		}
 	}
 	// Ask the TripleStore if we can be replaced. Often times, this is a great
 	// optimization opportunity (there's a fixed iterator underneath us, for
 	// example).
-	newReplacement, hasOne := lto.ts.OptimizeIterator(lto)
+	newReplacement, hasOne := it.ts.OptimizeIterator(it)
 	if hasOne {
-		lto.Close()
+		it.Close()
 		return newReplacement, true
 	}
-	return lto, false
+	return it, false
 }
 
 // Next()ing a LinksTo operates as described above.
-func (l *LinksToIterator) Next() (TSVal, bool) {
-	NextLogIn(l)
-	val, ok := l.nextIt.Next()
+func (it *LinksToIterator) Next() (TSVal, bool) {
+	NextLogIn(it)
+	val, ok := it.nextIt.Next()
 	if !ok {
 		// Subiterator is empty, get another one
-		candidate, ok := l.primaryIt.Next()
+		candidate, ok := it.primaryIt.Next()
 		if !ok {
 			// We're out of nodes in our subiterator, so we're done as well.
-			return NextLogOut(l, 0, false)
+			return NextLogOut(it, 0, false)
 		}
-		l.nextIt.Close()
-		l.nextIt = l.ts.GetTripleIterator(l.direction, candidate)
+		it.nextIt.Close()
+		it.nextIt = it.ts.GetTripleIterator(it.direction, candidate)
 		// Recurse -- return the first in the next set.
-		return l.Next()
+		return it.Next()
 	}
-	l.Last = val
-	return NextLogOut(l, val, ok)
+	it.Last = val
+	return NextLogOut(it, val, ok)
 }
 
 // Close our subiterators.
-func (l *LinksToIterator) Close() {
-	l.nextIt.Close()
-	l.primaryIt.Close()
+func (it *LinksToIterator) Close() {
+	it.nextIt.Close()
+	it.primaryIt.Close()
 }
 
 // We won't ever have a new result, but our subiterators might.
-func (l *LinksToIterator) NextResult() bool {
-	return l.primaryIt.NextResult()
+func (it *LinksToIterator) NextResult() bool {
+	return it.primaryIt.NextResult()
 }
 
 // Register the LinksTo.
-func (l *LinksToIterator) Type() string { return "linksto" }
+func (it *LinksToIterator) Type() string { return "linksto" }
 
 // Return a guess as to how big or costly it is to next the iterator.
-func (l *LinksToIterator) GetStats() *IteratorStats {
-	subitStats := l.primaryIt.GetStats()
+func (it *LinksToIterator) GetStats() *IteratorStats {
+	subitStats := it.primaryIt.GetStats()
 	// TODO(barakmich): These should really come from the triplestore itself
 	fanoutFactor := int64(20)
 	checkConstant := int64(1)