// 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 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() 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 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)
}
// 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)
}
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.
}
}
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)
}
// 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 *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 *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 *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)
}