// 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) } it.err = curIt.Err() if it.err != nil { return graph.NextLogOut(it, nil, false) } if it.isShortCircuiting && !first { break } it.currentIterator++ if it.currentIterator == it.itCount { break } } return graph.NextLogOut(it, nil, false) }
// Next()ing a LinksTo operates as described above. func (it *LinksTo) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 if it.nextIt.Next() { it.runstats.ContainsNext += 1 it.result = it.nextIt.Result() return graph.NextLogOut(it, 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 !it.primaryIt.Next() { // 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, 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() }
// 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) }
// Next advances the Skip iterator. It will skip all initial values // before returning actual result. func (it *Skip) Next() bool { graph.NextLogIn(it) for ; it.skipped < it.skip; it.skipped++ { if !it.primaryIt.Next() { return graph.NextLogOut(it, false) } } if it.primaryIt.Next() { return graph.NextLogOut(it, true) } return graph.NextLogOut(it, false) }
// Next advances the Limit iterator. It will stop iteration if limit was reached. func (it *Limit) Next() bool { graph.NextLogIn(it) if it.limit > 0 && it.count >= it.limit { return graph.NextLogOut(it, nil, false) } if graph.Next(it.primaryIt) { curr := it.primaryIt.Result() it.count++ return graph.NextLogOut(it, curr, true) } return graph.NextLogOut(it, nil, false) }
// Next advances the Skip iterator. It will skip all initial values // before returning actual result. func (it *Skip) Next() bool { graph.NextLogIn(it) for ; it.skipped < it.skip; it.skipped++ { if !graph.Next(it.primaryIt) { return graph.NextLogOut(it, nil, false) } } if graph.Next(it.primaryIt) { curr := it.primaryIt.Result() return graph.NextLogOut(it, curr, true) } return graph.NextLogOut(it, nil, false) }
// 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 it.primaryIt.Next() { curr := it.primaryIt.Result() if it.subItsContain(curr, nil) { it.result = curr return graph.NextLogOut(it, true) } } it.err = it.primaryIt.Err() return graph.NextLogOut(it, 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) it.runstats.Next += 1 if it.at == -1 { return graph.NextLogOut(it, false) } val := it.at it.at = it.at + 1 if it.at > it.max { it.at = -1 } it.result = val return graph.NextLogOut(it, 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) }
// 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 !it.primaryIt.Next() { it.err = it.primaryIt.Err() return graph.NextLogOut(it, false) } tID := it.primaryIt.Result() val := it.qs.QuadDirection(tID, it.dir) it.result = val return graph.NextLogOut(it, 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 { if err != io.EOF { it.err = err } 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 *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, 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 !it.primaryIt.Next() { // 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, 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. } }
// Next advances the subiterator, continuing until it returns a value which it // has not previously seen. func (it *Unique) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 for it.subIt.Next() { curr := it.subIt.Result() var key interface{} = curr if v, ok := curr.(graph.Keyer); ok { key = v.Key() } if ok := it.seen[key]; !ok { it.result = curr it.seen[key] = true return graph.NextLogOut(it, true) } } it.err = it.subIt.Err() return graph.NextLogOut(it, false) }
// Next advances the subiterator, continuing until it returns a value which it // has not previously seen. func (it *Unique) Next() bool { graph.NextLogIn(it) it.runstats.Next += 1 for graph.Next(it.subIt) { curr := it.subIt.Result() key := curr if v, ok := curr.(interface { Key() interface{} }); ok { key = graph.Value(v.Key()) } if ok := it.seen[key]; !ok { it.result = curr it.seen[key] = true return graph.NextLogOut(it, it.result, true) } } it.err = it.subIt.Err() return graph.NextLogOut(it, nil, false) }
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() { if clog.V(4) { clog.Infof("sql: No next") } err := it.cursor.Err() if err != nil { clog.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 { clog.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 { clog.Errorf("Error scanning sql iterator: %v", err) it.err = err return false } it.result = q return graph.NextLogOut(it, 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() { clog.Infof("sql: No next") err := it.cursor.Err() if err != nil { clog.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 { clog.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 { clog.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 { clog.Errorf("Couldn't make query: %v", err) it.err = err return false } it.cols, err = it.cursor.Columns() if err != nil { clog.Errorf("Couldn't get columns") it.err = err it.cursor.Close() return false } // iterate the first one if !it.cursor.Next() { if clog.V(4) { clog.Infof("sql: No next") } err := it.cursor.Err() if err != nil { clog.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() { if clog.V(4) { clog.Infof("sql: No next") } err := it.cursor.Err() if err != nil { clog.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) }