// Next advances the Or graph.iterator. Because the Or is the union of its // subiterators, it must produce from all subiterators -- unless it it // shortcircuiting, in which case, it is the first one that returns anything. func (it *Or) Next() bool { graph.NextLogIn(it) var first bool for { if it.currentIterator == -1 { it.currentIterator = 0 first = true } curIt := it.internalIterators[it.currentIterator] if graph.Next(curIt) { it.result = curIt.Result() return graph.NextLogOut(it, it.result, true) } if it.isShortCircuiting && !first { break } it.currentIterator++ if it.currentIterator == it.itCount { break } } return graph.NextLogOut(it, nil, false) }
// Returns the Next value from the Or graph.iterator. Because the Or is the // union of its subiterators, it must produce from all subiterators -- unless // it's shortcircuiting, in which case, it's the first one that returns anything. func (it *Or) Next() (graph.Value, bool) { graph.NextLogIn(it) var curr graph.Value var exists bool firstTime := false for { if it.currentIterator == -1 { it.currentIterator = 0 firstTime = true } curIt := it.internalIterators[it.currentIterator] curr, exists = graph.Next(curIt) if !exists { if it.isShortCircuiting && !firstTime { return graph.NextLogOut(it, nil, false) } it.currentIterator++ if it.currentIterator == it.itCount { return graph.NextLogOut(it, nil, false) } } else { it.result = curr return graph.NextLogOut(it, curr, true) } } panic("unreachable") }
// Returns the Next value from the Or graph.iterator. Because the Or is the // union of its subiterators, it must produce from all subiterators -- unless // it's shortcircuiting, in which case, it's the first one that returns anything. func (it *Or) Next() (graph.TSVal, bool) { graph.NextLogIn(it) var curr graph.TSVal var exists bool firstTime := false for { if it.currentIterator == -1 { it.currentIterator = 0 firstTime = true } curIt := it.internalIterators[it.currentIterator] curr, exists = curIt.Next() if !exists { if it.isShortCircuiting && !firstTime { return graph.NextLogOut(it, nil, false) } it.currentIterator++ if it.currentIterator == it.itCount { return graph.NextLogOut(it, nil, false) } } else { it.Last = curr return graph.NextLogOut(it, curr, true) } } panic("Somehow broke out of Next() loop in Or") }
// Next()ing a LinksTo operates as described above. func (it *LinksTo) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 if graph.Next(it.nextIt) { it.runstats.ContainsNext += 1 it.result = it.nextIt.Result() return graph.NextLogOut(it, it.result, true) } // If there's an error in the 'next' iterator, we save it and we're done. it.err = it.nextIt.Err() if it.err != nil { return false } // Subiterator is empty, get another one if !graph.Next(it.primaryIt) { // Possibly save error it.err = it.primaryIt.Err() // We're out of nodes in our subiterator, so we're done as well. return graph.NextLogOut(it, nil, false) } it.nextIt.Close() it.nextIt = it.qs.QuadIterator(it.dir, it.primaryIt.Result()) // Recurse -- return the first in the next set. return it.Next() }
func (it *Iterator) Next() (graph.TSVal, bool) { graph.NextLogIn(it) if it.tree.Max() == nil || it.Last == int64(it.tree.Max().(Int64)) { return graph.NextLogOut(it, nil, false) } it.iterLast = IterateOne(it.tree, it.iterLast) it.Last = int64(it.iterLast) return graph.NextLogOut(it, it.Last, true) }
// Next advances the iterator. func (it *Fixed) Next() bool { graph.NextLogIn(it) if it.lastIndex == len(it.values) { return graph.NextLogOut(it, nil, false) } out := it.values[it.lastIndex] it.result = out it.lastIndex++ return graph.NextLogOut(it, out, true) }
// Returns advances the And iterator. Because the And is the intersection of its // subiterators, it must choose one subiterator to produce a candidate, and check // this value against the subiterators. A productive choice of primary iterator // is therefore very important. func (it *And) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 for graph.Next(it.primaryIt) { curr := it.primaryIt.Result() if it.subItsContain(curr, nil) { it.result = curr return graph.NextLogOut(it, curr, true) } } return graph.NextLogOut(it, nil, false) }
// Next() on an Int64 all iterator is a simple incrementing counter. // Return the next integer, and mark it as the result. func (it *Int64) Next() bool { graph.NextLogIn(it) if it.at == -1 { return graph.NextLogOut(it, nil, false) } val := it.at it.at = it.at + 1 if it.at > it.max { it.at = -1 } it.result = val return graph.NextLogOut(it, val, true) }
// Next() on an Int64 all iterator is a simple incrementing counter. // Return the next integer, and mark it as the result. func (it *Int64) Next() (graph.Value, bool) { graph.NextLogIn(it) if it.at == -1 { return graph.NextLogOut(it, nil, false) } val := it.at it.at = it.at + 1 if it.at > it.max { it.at = -1 } it.Last = val return graph.NextLogOut(it, val, true) }
// Next advances the Not iterator. It returns whether there is another valid // new value. It fetches the next value of the all iterator which is not // contained by the primary iterator. func (it *Not) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 for graph.Next(it.allIt) { if curr := it.allIt.Result(); !it.primaryIt.Contains(curr) { it.result = curr it.runstats.ContainsNext += 1 return graph.NextLogOut(it, curr, true) } } it.err = it.allIt.Err() return graph.NextLogOut(it, nil, false) }
// Returns the Next value from the And iterator. Because the And is the // intersection of its subiterators, it must choose one subiterator to produce a // candidate, and check this value against the subiterators. A productive choice // of primary iterator is therefore very important. func (it *And) Next() (graph.TSVal, bool) { graph.NextLogIn(it) var curr graph.TSVal var exists bool for { curr, exists = it.primaryIt.Next() if !exists { return graph.NextLogOut(it, nil, false) } if it.checkSubIts(curr) { it.Last = curr return graph.NextLogOut(it, curr, true) } } panic("Somehow broke out of Next() loop in And") }
// Next advances the iterator. This is simpler than Contains. We have a // subiterator we can get a value from, and we can take that resultant quad, // pull our direction out of it, and return that. func (it *HasA) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 if it.resultIt != nil { it.resultIt.Close() } it.resultIt = &Null{} if !graph.Next(it.primaryIt) { return graph.NextLogOut(it, 0, false) } tID := it.primaryIt.Result() val := it.qs.QuadDirection(tID, it.dir) it.result = val return graph.NextLogOut(it, val, true) }
func (it *Iterator) Next() bool { graph.NextLogIn(it) if it.iter == nil { return graph.NextLogOut(it, nil, false) } result, _, err := it.iter.Next() if err != nil { return graph.NextLogOut(it, nil, false) } if !it.checkValid(result) { return it.Next() } it.result = result return graph.NextLogOut(it, it.result, true) }
func (it *Materialize) Next() bool { graph.NextLogIn(it) if !it.hasRun { it.materializeSet() } if it.aborted { return graph.Next(it.subIt) } it.index++ it.subindex = 0 if it.index >= len(it.values) { return graph.NextLogOut(it, nil, false) } return graph.NextLogOut(it, it.Result(), true) }
// Returns the Next value from the And iterator. Because the And is the // intersection of its subiterators, it must choose one subiterator to produce a // candidate, and check this value against the subiterators. A productive choice // of primary iterator is therefore very important. func (it *And) Next() (graph.Value, bool) { graph.NextLogIn(it) var curr graph.Value var exists bool for { curr, exists = graph.Next(it.primaryIt) if !exists { return graph.NextLogOut(it, nil, false) } if it.subItsContain(curr) { it.result = curr return graph.NextLogOut(it, curr, true) } } panic("unreachable") }
// Get the next result from this iterator. This is simpler than Check. We have a // subiterator we can get a value from, and we can take that resultant triple, // pull our direction out of it, and return that. func (it *HasA) Next() (graph.TSVal, bool) { graph.NextLogIn(it) if it.resultIt != nil { it.resultIt.Close() } it.resultIt = &Null{} tID, ok := it.primaryIt.Next() if !ok { return graph.NextLogOut(it, 0, false) } name := it.ts.GetTriple(tID).Get(it.dir) val := it.ts.GetIdFor(name) it.Last = val return graph.NextLogOut(it, val, true) }
// Get the next result from this iterator. This is simpler than Contains. We have a // subiterator we can get a value from, and we can take that resultant triple, // pull our direction out of it, and return that. func (it *HasA) Next() (graph.Value, bool) { graph.NextLogIn(it) if it.resultIt != nil { it.resultIt.Close() } it.resultIt = &Null{} tID, ok := graph.Next(it.primaryIt) if !ok { return graph.NextLogOut(it, 0, false) } name := it.ts.Quad(tID).Get(it.dir) val := it.ts.ValueOf(name) it.result = val return graph.NextLogOut(it, val, true) }
// Next advances the iterator. This is simpler than Contains. We have a // subiterator we can get a value from, and we can take that resultant triple, // pull our direction out of it, and return that. func (it *HasA) Next() bool { graph.NextLogIn(it) if it.resultIt != nil { it.resultIt.Close() } it.resultIt = &Null{} if !graph.Next(it.primaryIt) { return graph.NextLogOut(it, 0, false) } tID := it.primaryIt.Result() name := it.ts.Quad(tID).Get(it.dir) val := it.ts.ValueOf(name) it.result = val return graph.NextLogOut(it, val, true) }
// Next()ing a LinksTo operates as described above. func (it *LinksTo) Next() bool { graph.NextLogIn(it) if graph.Next(it.nextIt) { it.result = it.nextIt.Result() return graph.NextLogOut(it, it.nextIt, true) } // Subiterator is empty, get another one if !graph.Next(it.primaryIt) { // We're out of nodes in our subiterator, so we're done as well. return graph.NextLogOut(it, 0, false) } it.nextIt.Close() it.nextIt = it.ts.TripleIterator(it.dir, it.primaryIt.Result()) // Recurse -- return the first in the next set. return it.Next() }
// Next()ing a LinksTo operates as described above. func (it *LinksTo) Next() (graph.Value, bool) { graph.NextLogIn(it) val, ok := graph.Next(it.nextIt) if !ok { // Subiterator is empty, get another one candidate, ok := graph.Next(it.primaryIt) if !ok { // We're out of nodes in our subiterator, so we're done as well. return graph.NextLogOut(it, 0, false) } it.nextIt.Close() it.nextIt = it.ts.TripleIterator(it.dir, candidate) // Recurse -- return the first in the next set. return it.Next() } it.result = val return graph.NextLogOut(it, val, ok) }
func (it *LinksTo) Next() bool { var result struct { ID string `bson:"_id"` Added []int64 `bson:"Added"` Deleted []int64 `bson:"Deleted"` } graph.NextLogIn(it) next: for { it.runstats.Next += 1 if it.nextIt != nil && it.nextIt.Next(&result) { it.runstats.ContainsNext += 1 if it.collection == "quads" && len(result.Added) <= len(result.Deleted) { continue next } it.result = QuadHash(result.ID) return graph.NextLogOut(it, it.result, true) } if it.nextIt != nil { // If there's an error in the 'next' iterator, we save it and we're done. it.err = it.nextIt.Err() if it.err != nil { return false } } // Subiterator is empty, get another one if !graph.Next(it.primaryIt) { // Possibly save error it.err = it.primaryIt.Err() // We're out of nodes in our subiterator, so we're done as well. return graph.NextLogOut(it, nil, false) } if it.nextIt != nil { it.nextIt.Close() } it.nextIt = it.buildIteratorFor(it.dir, it.primaryIt.Result()) // Recurse -- return the first in the next set. } }
func (it *Materialize) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 if !it.hasRun { it.materializeSet() } if it.err != nil { return false } if it.aborted { n := graph.Next(it.subIt) it.err = it.subIt.Err() return n } it.index++ it.subindex = 0 if it.index >= len(it.values) { return graph.NextLogOut(it, nil, false) } return graph.NextLogOut(it, it.Result(), true) }
func (it *AllIterator) Next() bool { graph.NextLogIn(it) if it.cursor == nil { it.makeCursor() if it.cursor == nil { return false } } if !it.cursor.Next() { glog.V(4).Infoln("sql: No next") err := it.cursor.Err() if err != nil { glog.Errorf("Cursor error in SQL: %v", err) it.err = err } it.cursor.Close() return false } if it.table == "nodes" { var node string err := it.cursor.Scan(&node) if err != nil { glog.Errorf("Error nexting node iterator: %v", err) it.err = err return false } it.result = node return true } var q quad.Quad err := it.cursor.Scan(&q.Subject, &q.Predicate, &q.Object, &q.Label) if err != nil { glog.Errorf("Error scanning sql iterator: %v", err) it.err = err return false } it.result = q return graph.NextLogOut(it, it.result, true) }
func (it *AllIterator) Next() bool { graph.NextLogIn(it) if it.cursor == nil { it.makeCursor() if it.cursor == nil { return false } } if !it.cursor.Next() { glog.V(4).Infoln("sql: No next") err := it.cursor.Err() if err != nil { glog.Errorf("Cursor error in SQL: %v", err) it.err = err } it.cursor.Close() return false } if it.table == "nodes" { var hash NodeHash err := it.cursor.Scan(&hash) if err != nil { glog.Errorf("Error nexting node iterator: %v", err) it.err = err return false } it.result = NodeHash(hash) return true } var q QuadHashes err := it.cursor.Scan(&q[0], &q[1], &q[2], &q[3]) if err != nil { glog.Errorf("Error scanning sql iterator: %v", err) it.err = err return false } it.result = q return graph.NextLogOut(it, it.result, true) }
func (it *SQLIterator) Next() bool { var err error graph.NextLogIn(it) if it.cursor == nil { err = it.makeCursor(true, nil) if err != nil { glog.Errorf("Couldn't make query: %v", err) it.err = err return false } it.cols, err = it.cursor.Columns() if err != nil { glog.Errorf("Couldn't get columns") it.err = err it.cursor.Close() return false } // iterate the first one if !it.cursor.Next() { glog.V(4).Infoln("sql: No next") err := it.cursor.Err() if err != nil { glog.Errorf("Cursor error in SQL: %v", err) it.err = err } it.cursor.Close() return false } s, err := scan(it.cursor, len(it.cols)) if err != nil { it.err = err it.cursor.Close() return false } it.resultNext = append(it.resultNext, s) } if it.resultList != nil && it.resultNext == nil { // We're on something and there's no next return false } it.resultList = it.resultNext it.resultNext = nil it.resultIndex = 0 for { if !it.cursor.Next() { glog.V(4).Infoln("sql: No next") err := it.cursor.Err() if err != nil { glog.Errorf("Cursor error in SQL: %v", err) it.err = err } it.cursor.Close() break } s, err := scan(it.cursor, len(it.cols)) if err != nil { it.err = err it.cursor.Close() return false } if it.sql.sameTopResult(it.resultList[0], s) { it.resultList = append(it.resultList, s) } else { it.resultNext = append(it.resultNext, s) break } } if len(it.resultList) == 0 { return graph.NextLogOut(it, nil, false) } it.buildResult(0) return graph.NextLogOut(it, it.Result(), true) }