redef fun next do _iter.next

	redef fun next do real.next

	redef fun next do
		# If needed, fill the cache (an consume the current element)
		current_item
		# Empty the cache (so the next element will be read)
		cache = null
	end

	redef fun next do is_ok = false

	redef fun next do self.original_iterator.next

	redef fun next do self.original_iterator.next

	redef fun next do _item = _item.successor(1)

	redef fun next do _item = _item.predecessor(1)

	redef fun next
	do
		assert is_ok
		_node = _node._next_item
	end

	redef fun next do tgt = null

	redef fun next do
		# Next item in the second iterator
		icf.next
		if not icf.is_ok then
			# If it is over, then reset it and advance the first iterator
			icf = collection.cf.iterator
			ice.next
		end
		# Reset the cache
		item_cache = null
	end

	redef fun next
	do
		var rank = iterators.length - 1

		# Odometer-like increment starting from the last iterator
		loop
			var it = iterators[rank]
			it.next
			if it.is_ok then return

			# The iterator if over
			if rank == 0 then
				# It it is the first, then the whole thing is over
				is_ok = false
				return
			end

			# If not, restart the iterator and increment the previous one
			# (like a carry)
			iterators[rank] = collection.collections[rank].iterator
			rank -= 1
		end
	end

	redef fun next
	do
		var rank = product.repeat - 1

		loop
			var it = iterators[rank]

			if are_unique and not are_sorted then
				var idx = indices[rank] + 1
				it.next
				var adv = next_free(rank, idx)
				for i in [idx..adv[ do it.next
				indices[rank] = adv
			else
				it.next
				indices[rank] += 1
			end

			if it.is_ok then break
			if rank == 0 then
				is_ok = false
				return
			end
			rank -= 1
		end

		for r in [rank+1..product.repeat[ do
			reset_iterator(r)
		end
	end

	redef fun next do _pos = _pos + 1 end

	redef fun next
	do
		# end of service is to close the file
		# there is only one iteration
		is_ok = false
		item.close
	end

	redef fun next
	do
		# Process the last query
		if item.res > 0 then
			var tmp = array[i]
			array[i] = array[j]
			array[j] = tmp
		end
		# Get the next iteration
		j += 1
		if j >= array.length then
			# End of small loop
			i += 1
			j = i + 1
		end
		if not is_ok then return
		# Prepare the next query
		item.a = array[i]
		item.b = array[j]
		item.res = 0
	end

        redef fun next
        do
                my_iter.next
        end

	redef fun next
	do
		var i = current_iterator
		assert i != null
		i.next
	end

	redef fun next do
		inner.next
		skip_nulls
	end

	redef fun next
	do
		self.seen.add(self.item.as(Object))
		source.next
		while source.is_ok and self.seen.has(source.item.as(Object)) do
			source.next
		end
	end

	redef fun next
	do
		var seen = self.item
		source.next
		while source.is_ok and seen == source.item do
			source.next
		end
	end

	redef fun next
	do
		if source1.is_ok then source1.next else source2.next
	end

	redef fun next
	do
		if odd then
			source.next
		end
		odd = not odd
	end

	redef fun next
	do
		source.next
		do_skip
	end

	redef fun next
	do
		length -= 1
		source.next
	end

	redef fun next
	do
		lasts.shift
		lasts.push(source.item)
		source.next
	end

	redef fun next
	do
		source.next
		do_skip
	end

	redef fun next do
		source.next
		item_cached = false
	end

	redef fun next
	do
		targets_iterator.next
		update_iterators
	end

	# require: `self.statement.is_open`
	redef fun next
	do
		assert statement_closed: statement.is_open

		var err = statement.native_statement.step
		if err.is_row then
			is_ok = true
		else if err.is_done then
			# Clean complete
			is_ok = false
		else
			# error
			# FIXME do something with the error?
			is_ok = false
		end
	end

	redef fun next
	do
		var i = stack.last
		stack.push i.item.children.iterator
		i.next
		while is_ok do
			if not stack.last.is_ok then
				stack.pop
				continue
			end
			if stack.last.item == null then
				stack.last.next
				continue
			end
			return
		end
	end

	redef fun next do
		assert is_ok
		if tree.sub.has_key(item) then
			iterators.add tree.sub[item].iterator
		else
			iterators.last.next
			while is_ok and not iterators.last.is_ok do
				iterators.pop
				if is_ok and iterators.last.is_ok then
					iterators.last.next
				end
			end
		end
	end

	redef fun next do _index += 1

	redef fun next do real.next_by(step)

	redef fun next do _item = _item.predecessor(1)

	redef fun next
	do
		_node = _node.as(not null).next
		_index += 1
	end

	redef fun next do index += 1

	redef fun next do
		pns -= 1
		pos -= 1
		if pns >= 0 then return
		if not subs.is_ok then return
		subs.next
		if not subs.is_ok then return
		var s = subs.item
		ns = s._items
		pns = s.last_byte
	end

	redef fun next do
		pns += 1
		pos += 1
		if pns < subs.item._byte_length then return
		if not subs.is_ok then return
		subs.next
		if not subs.is_ok then return
		ns = subs.item._items
		pns = 0
	end

	redef fun next do
		pns -= 1
		pos -= 1
		if pns >= 0 then return
		if not subs.is_ok then return
		subs.next
		if not subs.is_ok then return
		ns = subs.item
		pns = ns.length - 1
	end

	redef fun next do
		pns += 1
		pos += 1
		if pns < subs.item.length then return
		if not subs.is_ok then return
		subs.next
		if not subs.is_ok then return
		str = subs.item
		pns = 0
	end

	redef fun next do
		if pos < 0 then return
		var curr = iter.prev
		var currit = curr.as(not null).node
		while curr != null do
			currit = curr.node
			if not currit isa Concat then
				str = currit.as(FlatString)
				pos -= str.length
				iter = curr
				return
			end
			if not curr.rdone then
				curr.rdone = true
				curr = new RopeCharIteratorPiece(currit._right, false, false, curr)
				continue
			end
			if not curr.ldone then
				curr.ldone = true
				curr = new RopeCharIteratorPiece(currit._left, false, false, curr)
				continue
			end
			curr = curr.prev
		end
		pos = -1
	end

	redef fun next do
		pos += str.length
		if pos > max then return
		var it = iter.prev.as(not null)
		var rnod = it.node
		loop
			if not rnod isa Concat then
				it.ldone = true
				it.rdone = true
				str = rnod.as(FlatString)
				iter = it
				break
			end
			if not it.ldone then
				rnod = rnod._left
				it.ldone = true
				it = new RopeCharIteratorPiece(rnod, false, false, it)
			else if not it.rdone then
				it.rdone = true
				rnod = rnod._right
				it = new RopeCharIteratorPiece(rnod, false, false, it)
			else
				it = it.prev.as(not null)
				rnod = it.node
				continue
			end
		end
	end

	redef fun next do curr_pos -= 1

	redef fun next do curr_pos += 1

	redef fun next do curr_pos -= 1

	redef fun next do curr_pos += 1

	redef fun next do curr_pos -= 1

	redef fun next do curr_pos += 1

	redef fun next do curr_pos -= 1

	redef fun next do curr_pos += 1

	redef fun next do index += 1

	redef fun next do index += 1

	redef fun next do index -= 1

	redef fun next do curr_pos += 1

	redef fun next do curr_pos -= 1

        redef fun next
        do
                loop
                        my_iter.next
                        if not is_ok then
                                break
                        end
                        var x = my_iter.item
                        if pred.call(x) then
                                break
                        end
                end
        end

        redef fun next
        do
                inner.next
                if not inner.is_ok then
                        super
                        try_compute_inner
                end
        end

        redef fun next
        do
                sorted_iter.next
        end

	redef fun next do index += 1

	redef fun next do _index -= 1

	redef fun next
	do
		_node = _node.as(not null).prev
		_index -= 1
	end

	redef fun next
	do
		index += 1
		index_in_node += 1

		if index_in_node >= node.tail_index then
			node = node.next
			if node != null then index_in_node = node.head_index
		end
	end

	redef fun next do is_ok = native.next