/*-------------------------------------------------[ Advancing ]---------------------------------------------------
511830
@Override
    protected E findNext(){
        while(true){
            E elem = delegate.next();
            if(elem==null || filter.select(elem))
                return elem;
        }
    }
896306
public boolean setCharAdvance(int c, int advance) {
        byte b[] = convertToBytes(c);
        if (b.length == 0)
            return false;
        widths[0xff & b[0]] = advance;
        return true;
    }
199955
private void advance() {
        while (nextSubgraphs.isEmpty() && vertexIter.hasNext()) {
            Integer nextVertex = vertexIter.next();
            // Determine the set of vertices that are greater than this vertex
            Set<Integer> extension = new HashSet<Integer>();
            for (Integer v : g.getNeighbors(nextVertex))
                if (v > nextVertex)
                    extension.add(v);
            Set<Integer> subgraph = new HashSet<Integer>();
            subgraph.add(nextVertex);
            extendSubgraph(subgraph, extension, nextVertex);
        }
    }
369600
public function advance($newValue = null) {
        if (!is_null($newValue)) {
            $this->_currentValue = $newValue;
            return;
        }

        $this->_currentValue++;
    }
718108
public static void advance(Progression model, int value) {
		if (model != null && value > 0) {
			final SubProgressionModel sub = (SubProgressionModel) model.getSubTask();
			final double base;
			if (sub == null) {
				base = model.getValue();
			} else {
				base = sub.getMinInParent();
				model.ensureNoSubTask();
			}
			model.setValue((int) base + value);
		}
	}
502668
public final void mTRAILING() throws RecognitionException {
		try {
			int _type = TRAILING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// hql.g:65:10: ( 'trailing' )
			// hql.g:65:12: 'trailing'
			{
			match("trailing"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
449518
public function next()
    {
        $this->current = $this->parser->inner($this->start, $this->end);
        if ($this->current->isEmpty()) {
            $this->valid = false;
            $this->position = -1;
        } else {
            $this->valid = true;
            ++$this->position;
        }
    }
1257466
boolean advance() {
        if (header.frameCount <= 0) {
            return false;
        }

        if(framePointer == getFrameCount() - 1) {
            loopIndex++;
        }

        if(header.loopCount != LOOP_FOREVER && loopIndex > header.loopCount) {
            return false;
        }

        framePointer = (framePointer + 1) % header.frameCount;
        return true;
    }
149999
private void advance() {
        try {
            if (tok == null)
                tok = source.token();
        } catch (LexerException e) {
            throw new IllegalStateException(e);
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }
1285693
@Override
  public int advance(int target) throws IOException {
    docId = NO_MORE_DOCS;
    currentStartPosition = NO_MORE_POSITIONS;
    currentEndPosition = NO_MORE_POSITIONS;
    return docId;
  }
846038
@Override
    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
        Log.d(TAG, "onProgressChanged " + progress);
    }
1315489
public function advance()
    {
        if (!$this->started) {
            throw new LogicException('Progress indicator has not yet been started.');
        }

        if (!$this->output->isDecorated()) {
            return;
        }

        $currentTime = $this->getCurrentTimeInMilliseconds();

        if ($currentTime < $this->indicatorUpdateTime) {
            return;
        }

        $this->indicatorUpdateTime = $currentTime + $this->indicatorChangeInterval;
        ++$this->indicatorCurrent;

        $this->display();
    }
976195
protected void advancePastWhitespace(XMLEventReader reader)
            throws XMLStreamException {
        XMLEvent next = reader.peek();
        while (next.isCharacters() && next.asCharacters().isWhiteSpace()) {
            reader.nextEvent();
            next = reader.peek();
        }
    }
844270
function _nextStep() {
    this._direction = 'forward';

    if (typeof this._currentStepNumber !== 'undefined') {
        for (var i = 0, len = this._introItems.length; i < len; i++) {
            var item = this._introItems[i];
            if (item.step === this._currentStepNumber) {
                this._currentStep = i - 1;
                this._currentStepNumber = undefined;
            }
        }
    }

    if (typeof this._currentStep === 'undefined') {
        this._currentStep = 0;
    } else {
        ++this._currentStep;
    }

    if (typeof this._introBeforeChangeCallback !== 'undefined') {
        var continueStep = this._introBeforeChangeCallback.call(this);
    }

    // if `onbeforechange` returned `false`, stop displaying the element
    if (continueStep === false) {
        --this._currentStep;
        return false;
    }

    if (this._introItems.length <= this._currentStep) {
        //end of the intro
        //check if any callback is defined
        if (typeof this._introCompleteCallback === 'function') {
            this._introCompleteCallback.call(this);
        }
        _exitIntro.call(this, this._targetElement);
        return;
    }

    var nextStep = this._introItems[this._currentStep];
    _showElement.call(this, nextStep);
}
846841
private void advance() {
	String s = null;
	while (tokenizer.hasNext()) {
	    String nextToken = tokenizer.next();
	    // stop if the word should be returned
	    if (filter.accept(nextToken)) {
		s = nextToken;
		break;
	    }
	}
	next = s;
    }
654025
function( containerNode, preceding, following )
    {
        var sel = window.getSelection();
        if( sel.modify )
        {
            for( var i=0; i < preceding; ++i )
                sel.modify('extend', 'backward', 'character');
            for( var i=0; i < following; ++i )
                sel.modify('extend', 'forward', 'character');
        }
        else
        {
            // not so easy if the steps would cover multiple nodes ...
            var range = sel.getRangeAt(0);
            range.setStart( range.startContainer, range.startOffset - preceding );
            range.setEnd( range.endContainer, range.endOffset + following );
            sel.removeAllRanges();
            sel.addRange(range);
        }
    }
859967
@Override
  public int advance(int target) throws IOException {
    resetQueue();
    Integer newTarget = target;
    do {
      newTarget = advanceToDoc(newTarget);
    } while (newTarget != null);
    return docId;
  }