Move tag handling out into graph.Tagger

graph/iterator/all_iterator.go

@@ -32,6 +32,7 @@ import (
 // An All iterator across a range of int64 values, from `max` to `min`.
 type Int64 struct {
 	Base
+	tags     graph.Tagger
 	max, min int64
 	at       int64
 }
@@ -55,13 +56,28 @@ func (it *Int64) Close() {}
 
 func (it *Int64) Clone() graph.Iterator {
 	out := NewInt64(it.min, it.max)
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
+func (it *Int64) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Fill the map based on the tags assigned to this iterator.
+func (it *Int64) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
 // Prints the All iterator as just an "all".
 func (it *Int64) DebugString(indent int) string {
-	return fmt.Sprintf("%s(%s tags: %v)", strings.Repeat(" ", indent), it.Type(), it.Tags())
+	return fmt.Sprintf("%s(%s tags: %v)", strings.Repeat(" ", indent), it.Type(), it.tags.Tags())
 }
 
 // Next() on an Int64 all iterator is a simple incrementing counter.

graph/iterator/and_iterator.go

@@ -26,6 +26,7 @@ import (
 // be Next()ed if next is called.
 type And struct {
 	Base
+	tags              graph.Tagger
 	internalIterators []graph.Iterator
 	itCount           int
 	primaryIt         graph.Iterator
@@ -50,10 +51,33 @@ func (it *And) Reset() {
 	it.checkList = nil
 }
 
+func (it *And) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Overrides Base TagResults, as it needs to add it's own results and
+// recurse down it's subiterators.
+func (it *And) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	if it.primaryIt != nil {
+		it.primaryIt.TagResults(dst)
+	}
+	for _, sub := range it.internalIterators {
+		sub.TagResults(dst)
+	}
+}
+
 func (it *And) Clone() graph.Iterator {
 	and := NewAnd()
 	and.AddSubIterator(it.primaryIt.Clone())
-	and.CopyTagsFrom(it)
+	and.tags.CopyFrom(it)
 	for _, sub := range it.internalIterators {
 		and.AddSubIterator(sub.Clone())
 	}
@@ -71,18 +95,6 @@ func (it *And) SubIterators() []graph.Iterator {
 	return iters
 }
 
-// Overrides Base TagResults, as it needs to add it's own results and
-// recurse down it's subiterators.
-func (it *And) TagResults(dst map[string]graph.Value) {
-	it.Base.TagResults(dst)
-	if it.primaryIt != nil {
-		it.primaryIt.TagResults(dst)
-	}
-	for _, sub := range it.internalIterators {
-		sub.TagResults(dst)
-	}
-}
-
 // DEPRECATED Returns the ResultTree for this iterator, recurses to it's subiterators.
 func (it *And) ResultTree() *graph.ResultTree {
 	tree := graph.NewResultTree(it.Result())
@@ -101,7 +113,7 @@ func (it *And) DebugString(indent int) string {
 		total += fmt.Sprintf("%d:\n%s\n", i, sub.DebugString(indent+4))
 	}
 	var tags string
-	for _, k := range it.Tags() {
+	for _, k := range it.tags.Tags() {
 		tags += fmt.Sprintf("%s;", k)
 	}
 	spaces := strings.Repeat(" ", indent+2)

graph/iterator/and_iterator_optimize.go

@@ -82,7 +82,7 @@ func (it *And) Optimize() (graph.Iterator, bool) {
 	}
 
 	// Move the tags hanging on us (like any good replacement).
-	newAnd.CopyTagsFrom(it)
+	newAnd.tags.CopyFrom(it)
 
 	newAnd.optimizeCheck()
 
@@ -213,11 +213,11 @@ func (it *And) optimizeCheck() {
 func (it *And) getSubTags() map[string]struct{} {
 	tags := make(map[string]struct{})
 	for _, sub := range it.SubIterators() {
-		for _, tag := range sub.Tags() {
+		for _, tag := range sub.Tagger().Tags() {
 			tags[tag] = struct{}{}
 		}
 	}
-	for _, tag := range it.Tags() {
+	for _, tag := range it.tags.Tags() {
 		tags[tag] = struct{}{}
 	}
 	return tags
@@ -227,13 +227,14 @@ func (it *And) getSubTags() map[string]struct{} {
 // src itself, and moves them to dst.
 func moveTagsTo(dst graph.Iterator, src *And) {
 	tags := src.getSubTags()
-	for _, tag := range dst.Tags() {
+	for _, tag := range dst.Tagger().Tags() {
 		if _, ok := tags[tag]; ok {
 			delete(tags, tag)
 		}
 	}
+	dt := dst.Tagger()
 	for k := range tags {
-		dst.AddTag(k)
+		dt.Add(k)
 	}
 }
 

graph/iterator/and_iterator_optimize_test.go

@@ -32,9 +32,9 @@ func TestIteratorPromotion(t *testing.T) {
 	a := NewAnd()
 	a.AddSubIterator(all)
 	a.AddSubIterator(fixed)
-	all.AddTag("a")
-	fixed.AddTag("b")
-	a.AddTag("c")
+	all.Tagger().Add("a")
+	fixed.Tagger().Add("b")
+	a.Tagger().Add("c")
 	newIt, changed := a.Optimize()
 	if !changed {
 		t.Error("Iterator didn't optimize")
@@ -43,7 +43,7 @@ func TestIteratorPromotion(t *testing.T) {
 		t.Error("Expected fixed iterator")
 	}
 	tagsExpected := []string{"a", "b", "c"}
-	tags := newIt.Tags()
+	tags := newIt.Tagger().Tags()
 	sort.Strings(tags)
 	if !reflect.DeepEqual(tags, tagsExpected) {
 		t.Fatal("Tags don't match")
@@ -67,9 +67,9 @@ func TestNullIteratorAnd(t *testing.T) {
 
 func TestReorderWithTag(t *testing.T) {
 	all := NewInt64(100, 300)
-	all.AddTag("good")
+	all.Tagger().Add("good")
 	all2 := NewInt64(1, 30000)
-	all2.AddTag("slow")
+	all2.Tagger().Add("slow")
 	a := NewAnd()
 	// Make all2 the default iterator
 	a.AddSubIterator(all2)
@@ -82,7 +82,7 @@ func TestReorderWithTag(t *testing.T) {
 	expectedTags := []string{"good", "slow"}
 	tagsOut := make([]string, 0)
 	for _, sub := range newIt.SubIterators() {
-		for _, x := range sub.Tags() {
+		for _, x := range sub.Tagger().Tags() {
 			tagsOut = append(tagsOut, x)
 		}
 	}
@@ -93,9 +93,9 @@ func TestReorderWithTag(t *testing.T) {
 
 func TestAndStatistics(t *testing.T) {
 	all := NewInt64(100, 300)
-	all.AddTag("good")
+	all.Tagger().Add("good")
 	all2 := NewInt64(1, 30000)
-	all2.AddTag("slow")
+	all2.Tagger().Add("slow")
 	a := NewAnd()
 	// Make all2 the default iterator
 	a.AddSubIterator(all2)

graph/iterator/and_iterator_test.go

@@ -24,11 +24,11 @@ import (
 func TestTag(t *testing.T) {
 	fix1 := newFixed()
 	fix1.Add(234)
-	fix1.AddTag("foo")
+	fix1.Tagger().Add("foo")
 	and := NewAnd()
 	and.AddSubIterator(fix1)
-	and.AddTag("bar")
-	out := fix1.Tags()
+	and.Tagger().Add("bar")
+	out := fix1.Tagger().Tags()
 	if len(out) != 1 {
 		t.Errorf("Expected length 1, got %d", len(out))
 	}

graph/iterator/fixed_iterator.go

@@ -31,6 +31,7 @@ import (
 // an equality function.
 type Fixed struct {
 	Base
+	tags      graph.Tagger
 	values    []graph.Value
 	lastIndex int
 	cmp       Equality
@@ -68,12 +69,26 @@ func (it *Fixed) Reset() {
 
 func (it *Fixed) Close() {}
 
+func (it *Fixed) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Fixed) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
 func (it *Fixed) Clone() graph.Iterator {
 	out := NewFixedIteratorWithCompare(it.cmp)
 	for _, val := range it.values {
 		out.Add(val)
 	}
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
@@ -92,7 +107,7 @@ func (it *Fixed) DebugString(indent int) string {
 	return fmt.Sprintf("%s(%s tags: %s Size: %d id0: %d)",
 		strings.Repeat(" ", indent),
 		it.Type(),
-		it.FixedTags(),
+		it.tags.Fixed(),
 		len(it.values),
 		value,
 	)

graph/iterator/hasa_iterator.go

@@ -47,6 +47,7 @@ import (
 // and a temporary holder for the iterator generated on Check().
 type HasA struct {
 	Base
+	tags      graph.Tagger
 	ts        graph.TripleStore
 	primaryIt graph.Iterator
 	dir       graph.Direction
@@ -76,9 +77,13 @@ func (it *HasA) Reset() {
 	}
 }
 
+func (it *HasA) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
 func (it *HasA) Clone() graph.Iterator {
 	out := NewHasA(it.ts, it.primaryIt.Clone(), it.dir)
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
@@ -100,7 +105,14 @@ func (it *HasA) Optimize() (graph.Iterator, bool) {
 
 // Pass the TagResults down the chain.
 func (it *HasA) TagResults(dst map[string]graph.Value) {
-	it.Base.TagResults(dst)
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
 	it.primaryIt.TagResults(dst)
 }
 
@@ -114,7 +126,7 @@ func (it *HasA) ResultTree() *graph.ResultTree {
 // Print some information about this iterator.
 func (it *HasA) DebugString(indent int) string {
 	var tags string
-	for _, k := range it.Tags() {
+	for _, k := range it.tags.Tags() {
 		tags += fmt.Sprintf("%s;", k)
 	}
 	return fmt.Sprintf("%s(%s %d tags:%s direction:%s\n%s)", strings.Repeat(" ", indent), it.Type(), it.UID(), tags, it.dir, it.primaryIt.DebugString(indent+4))

graph/iterator/iterator.go

@@ -36,11 +36,9 @@ func NextUID() uint64 {
 // The Base iterator is the iterator other iterators inherit from to get some
 // default functionality.
 type Base struct {
-	Last      graph.Value
-	tags      []string
-	fixedTags map[string]graph.Value
-	canNext   bool
-	uid       uint64
+	Last    graph.Value
+	canNext bool
+	uid     uint64
 }
 
 // Called by subclases.
@@ -56,41 +54,6 @@ func (it *Base) UID() uint64 {
 	return it.uid
 }
 
-// Adds a tag to the iterator. Most iterators don't need to override.
-func (it *Base) AddTag(tag string) {
-	if it.tags == nil {
-		it.tags = make([]string, 0)
-	}
-	it.tags = append(it.tags, tag)
-}
-
-func (it *Base) AddFixedTag(tag string, value graph.Value) {
-	if it.fixedTags == nil {
-		it.fixedTags = make(map[string]graph.Value)
-	}
-	it.fixedTags[tag] = value
-}
-
-// Returns the tags.
-func (it *Base) Tags() []string {
-	return it.tags
-}
-
-func (it *Base) FixedTags() map[string]graph.Value {
-	return it.fixedTags
-}
-
-func (it *Base) CopyTagsFrom(other_it graph.Iterator) {
-	for _, tag := range other_it.Tags() {
-		it.AddTag(tag)
-	}
-
-	for k, v := range other_it.FixedTags() {
-		it.AddFixedTag(k, v)
-	}
-
-}
-
 // Prints a silly debug string. Most classes override.
 func (it *Base) DebugString(indent int) string {
 	return fmt.Sprintf("%s(base)", strings.Repeat(" ", indent))
@@ -140,18 +103,6 @@ func (it *Base) SubIterators() []graph.Iterator {
 // Accessor
 func (it *Base) CanNext() bool { return it.canNext }
 
-// Fill the map based on the tags assigned to this iterator. Default
-// functionality works well for most iterators.
-func (it *Base) TagResults(dst map[string]graph.Value) {
-	for _, tag := range it.Tags() {
-		dst[tag] = it.Result()
-	}
-
-	for tag, value := range it.FixedTags() {
-		dst[tag] = value
-	}
-}
-
 // Nothing to clean up.
 // func (it *Base) Close() {}
 
@@ -164,6 +115,7 @@ func (it *Base) Reset() {}
 // so it's important to give it a special iterator.
 type Null struct {
 	Base
+	tags graph.Tagger
 }
 
 // Fairly useless New function.
@@ -171,6 +123,21 @@ func NewNull() *Null {
 	return &Null{}
 }
 
+func (it *Null) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Fill the map based on the tags assigned to this iterator.
+func (it *Null) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
 func (it *Null) Clone() graph.Iterator { return NewNull() }
 
 // Name the null iterator.

graph/iterator/linksto_iterator.go

@@ -41,6 +41,7 @@ import (
 // `next_it` is the tempoarary iterator held per result in `primary_it`.
 type LinksTo struct {
 	Base
+	tags      graph.Tagger
 	ts        graph.TripleStore
 	primaryIt graph.Iterator
 	dir       graph.Direction
@@ -67,9 +68,13 @@ func (it *LinksTo) Reset() {
 	it.nextIt = &Null{}
 }
 
+func (it *LinksTo) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
 func (it *LinksTo) Clone() graph.Iterator {
 	out := NewLinksTo(it.ts, it.primaryIt.Clone(), it.dir)
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
@@ -78,7 +83,14 @@ func (it *LinksTo) Direction() graph.Direction { return it.dir }
 
 // Tag these results, and our subiterator's results.
 func (it *LinksTo) TagResults(dst map[string]graph.Value) {
-	it.Base.TagResults(dst)
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
 	it.primaryIt.TagResults(dst)
 }
 

graph/iterator/optional_iterator.go

@@ -39,6 +39,7 @@ import (
 // and whether the last check we received was true or false.
 type Optional struct {
 	Base
+	tags      graph.Tagger
 	subIt     graph.Iterator
 	lastCheck bool
 }
@@ -61,9 +62,13 @@ func (it *Optional) Close() {
 	it.subIt.Close()
 }
 
+func (it *Optional) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
 func (it *Optional) Clone() graph.Iterator {
 	out := NewOptional(it.subIt.Clone())
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
@@ -111,7 +116,7 @@ func (it *Optional) DebugString(indent int) string {
 	return fmt.Sprintf("%s(%s tags:%s\n%s)",
 		strings.Repeat(" ", indent),
 		it.Type(),
-		it.Tags(),
+		it.tags.Tags(),
 		it.subIt.DebugString(indent+4))
 }
 

graph/iterator/or_iterator.go

@@ -30,6 +30,7 @@ import (
 
 type Or struct {
 	Base
+	tags              graph.Tagger
 	isShortCircuiting bool
 	internalIterators []graph.Iterator
 	itCount           int
@@ -62,6 +63,10 @@ func (it *Or) Reset() {
 	it.currentIterator = -1
 }
 
+func (it *Or) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
 func (it *Or) Clone() graph.Iterator {
 	var or *Or
 	if it.isShortCircuiting {
@@ -72,7 +77,7 @@ func (it *Or) Clone() graph.Iterator {
 	for _, sub := range it.internalIterators {
 		or.AddSubIterator(sub.Clone())
 	}
-	or.CopyTagsFrom(it)
+	or.tags.CopyFrom(it)
 	return or
 }
 
@@ -84,7 +89,14 @@ func (it *Or) SubIterators() []graph.Iterator {
 // Overrides BaseIterator TagResults, as it needs to add it's own results and
 // recurse down it's subiterators.
 func (it *Or) TagResults(dst map[string]graph.Value) {
-	it.Base.TagResults(dst)
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
 	it.internalIterators[it.currentIterator].TagResults(dst)
 }
 
@@ -105,7 +117,7 @@ func (it *Or) DebugString(indent int) string {
 		total += fmt.Sprintf("%d:\n%s\n", i, sub.DebugString(indent+4))
 	}
 	var tags string
-	for _, k := range it.Tags() {
+	for _, k := range it.tags.Tags() {
 		tags += fmt.Sprintf("%s;", k)
 	}
 	spaces := strings.Repeat(" ", indent+2)
@@ -247,7 +259,7 @@ func (it *Or) Optimize() (graph.Iterator, bool) {
 	}
 
 	// Move the tags hanging on us (like any good replacement).
-	newOr.CopyTagsFrom(it)
+	newOr.tags.CopyFrom(it)
 
 	// And close ourselves but not our subiterators -- some may still be alive in
 	// the new And (they were unchanged upon calling Optimize() on them, at the

graph/iterator/query_shape.go

@@ -107,10 +107,10 @@ func (qs *queryShape) StealNode(left *Node, right *Node) {
 
 func (qs *queryShape) MakeNode(it graph.Iterator) *Node {
 	n := Node{Id: qs.nodeId}
-	for _, tag := range it.Tags() {
+	for _, tag := range it.Tagger().Tags() {
 		n.Tags = append(n.Tags, tag)
 	}
-	for k, _ := range it.FixedTags() {
+	for k, _ := range it.Tagger().Fixed() {
 		n.Tags = append(n.Tags, k)
 	}
 

graph/iterator/query_shape_test.go

@@ -26,7 +26,7 @@ func hasaWithTag(ts graph.TripleStore, tag string, target string) *HasA {
 
 	obj := ts.FixedIterator()
 	obj.Add(ts.ValueOf(target))
-	obj.AddTag(tag)
+	obj.Tagger().Add(tag)
 	and.AddSubIterator(NewLinksTo(ts, obj, graph.Object))
 
 	pred := ts.FixedIterator()
@@ -48,7 +48,7 @@ func TestQueryShape(t *testing.T) {
 
 	// Given a single linkage iterator's shape.
 	hasa := hasaWithTag(ts, "tag", "cool")
-	hasa.AddTag("top")
+	hasa.Tagger().Add("top")
 
 	shape := make(map[string]interface{})
 	OutputQueryShapeForIterator(hasa, ts, shape)
@@ -93,11 +93,11 @@ func TestQueryShape(t *testing.T) {
 	andInternal := NewAnd()
 
 	hasa1 := hasaWithTag(ts, "tag1", "cool")
-	hasa1.AddTag("hasa1")
+	hasa1.Tagger().Add("hasa1")
 	andInternal.AddSubIterator(hasa1)
 
 	hasa2 := hasaWithTag(ts, "tag2", "fun")
-	hasa2.AddTag("hasa2")
+	hasa2.Tagger().Add("hasa2")
 	andInternal.AddSubIterator(hasa2)
 
 	pred := ts.FixedIterator()

graph/iterator/value_comparison_iterator.go

@@ -47,6 +47,7 @@ const (
 
 type Comparison struct {
 	Base
+	tags  graph.Tagger
 	subIt graph.Iterator
 	op    Operator
 	val   interface{}
@@ -111,9 +112,13 @@ func (it *Comparison) Reset() {
 	it.subIt.Reset()
 }
 
+func (it *Comparison) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
 func (it *Comparison) Clone() graph.Iterator {
 	out := NewComparison(it.subIt.Clone(), it.op, it.val, it.ts)
-	out.CopyTagsFrom(it)
+	out.tags.CopyFrom(it)
 	return out
 }
 
@@ -157,7 +162,14 @@ func (it *Comparison) Check(val graph.Value) bool {
 // If we failed the check, then the subiterator should not contribute to the result
 // set. Otherwise, go ahead and tag it.
 func (it *Comparison) TagResults(dst map[string]graph.Value) {
-	it.Base.TagResults(dst)
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
 	it.subIt.TagResults(dst)
 }