public void update(BucketId superbucket, BucketId progress) {
        // Delegate to bucket source, as it knows how to deal with buckets
        // that are in an inconsistent state wrt distribution bit count
        bucketSource.update(superbucket, progress, progressToken);
    }
<p>Tell the iterator that we've finished processing up to <i>and
including</i> <code>progress</code>. <code>progress</code> may be a sub-bucket <i>or</i>
the invalid 0-bucket (in case the caller fails to process the bucket and
must return it to the set of pending) <em>or</em> the special case <code>BucketId(Integer.MAX_VALUE)</code>,
the latter indicating to the iterator that traversal is complete for
<code>superbucket</code>'s tree. The null bucket should only be used if no
non-null updates have yet been given for the superbucket.</p>

<p>It is a requirement that each superbucket returned by {@link #getNext()} must
eventually result in 1-n update operations, where the last update operation
has the special progress==super case.</p>

<p>If the document selection used to create the iterator is unknown and there
were active buckets at the time of a distribution bit state change, such
a bucket passed to <code>update()</code> will be in an inconsistent state
with regards to the number of bits it uses. For unfinished buckets, this
is handled by splitting or merging it until it's consistent, depending on
whether or not it had a lower or higher distribution bit count than that of
the current system state. For finished buckets of a lower dist bit count,
the amount of finished buckets in the ProgressToken is adjusted upwards
to compensate for the fact that a bucket using fewer distribution bits
actually covers more of the bucket space than the ones that are currently
in use. For finished buckets of a higher dist bit count, the number of
finished buckets is <em>not</em> increased at that point in time, since
such a bucket doesn't actually cover an entire bucket with the current state.</p>

<p>All this is done automatically and transparently to the caller once all
active buckets have been updated.</p>

@param superbucket A valid bucket ID that has been retrieved earlier through
{@link #getNext()}
@param progress A bucket logically contained within <code>super</code>. Subsequent
updates for the same superbucket must have <code>progress</code> be in an increasing
order, where order is defined as the in-order traversal of the bucket split
tree. May also be the null bucket if the superbucket has not seen any "proper"
progress updates yet or the special case Integer.MAX_VALUE. Note that inconsistent
splitting might actually see <code>progress</code> as containing <code>super</code>
rather than vice versa, so this is explicitly allowed to pass by the code.
documentapi/src/main/java/com/yahoo/documentapi/VisitorIterator.java