Skip until one of input tokens.

@param tokenTypes to be skipped untiled token types
544778
public void skipUntil(final TokenType... tokenTypes) {
        Set<TokenType> tokenTypeSet = Sets.newHashSet(tokenTypes);
        tokenTypeSet.add(Assist.END);
        while (!tokenTypeSet.contains(lexer.getCurrentToken().getType())) {
            lexer.nextToken();
        }
    }
877692
public JsonTokenType skip() throws IOException {
      try {
         JsonTokenType element = jsonTokenToStructuredElement(reader.peek());
         JsonToken token = currentValue.getKey();
         if (token == NAME &&
                (element == JsonTokenType.BEGIN_OBJECT || element == JsonTokenType.BEGIN_ARRAY)) {
            reader.skipValue();
         }
         consume();
         return element;
      } catch (IOException e) {
         throw new IOException(e);
      }
   }
1362214
private static boolean areTokensValid(Token... tokens)
    {
        for (Token token : tokens)
        {
            if (!isTokenValid(token))
                return false;
        }
        return true;
    }
1084467
private final void nextToken()
  {

    if (m_queueMark < m_ops.getTokenQueueSize())
    {
      m_token = (String) m_ops.m_tokenQueue.elementAt(m_queueMark++);
      m_tokenChar = m_token.charAt(0);
    }
    else
    {
      m_token = null;
      m_tokenChar = 0;
    }
  }
1255203
private static String nextToken(String[] tokens, int x, String context)
            throws ParseException {
        if (x < tokens.length) {
            return tokens[x];
        }
        throw new ParseException("missing token at end of '" + context + "'", -1);
    }
258630
public boolean skip(ParserToken token) {
      if (token == null) {
         return false;
      }
      if (isPrefix(token)) {
         if (prefixHandlers.containsKey(token.getType())) {
            return prefixHandlers.get(token.getType()) instanceof PrefixSkipHandler;
         } else {
            return prefixSkipHandler != null;
         }
      }
      return false;
   }
437414
def process_tokens(self, tokens):
        
        """
        for (tok_type, token, (start_row, _), _, _) in tokens:
            if tok_type == tokenize.STRING:
                self._check_string(token, start_row)
421733
@Override
	public TokenType next() {
		if (position >= sql.length()) {
			token = null;
			tokenType = TokenType.EOF;
			nextTokenType = TokenType.EOF;
			return tokenType;
		}
		switch (nextTokenType) {
		case SQL:
			parseSql();
			break;
		case COMMENT:
			parseComment();
			break;
		case ELSE:
			parseElse();
			break;
		case BIND_VARIABLE:
			parseBindVariable();
			break;
		default:
			parseEof();
			break;
		}
		return tokenType;
	}
1175970
protected final void skipIndex(final int skippedCharIndex) {
        _bufferedString.addChar();
        if (_skipped.length == 0 || _skipped[_skipped.length - 1] != -1) {
            _skipped = Arrays.copyOf(_skipped, Math.max(_skipped.length + 1, 1));
        }

        _skipped[_skippedWriteIndex] = skippedCharIndex;
        _skippedWriteIndex++;
    }
428545
public void setSpeechMarkTypes(java.util.Collection<String> speechMarkTypes) {
        if (speechMarkTypes == null) {
            this.speechMarkTypes = null;
            return;
        }

        this.speechMarkTypes = new java.util.ArrayList<String>(speechMarkTypes);
    }
438235
@Override
    public void skipElement() throws XMLStreamException
    {
        if (mCurrToken != START_ELEMENT) {
            throw new IllegalStateException(ErrorConsts.ERR_STATE_NOT_STELEM);
        }
        int nesting = 1; // need one more end elements than start elements

        while (true) {
            int type = next();
            if (type == START_ELEMENT) {
                ++nesting;
            } else if (type == END_ELEMENT) {
                if (--nesting == 0) {
                    break;
                }
            }
        }
    }
767200
private boolean advance(int tokens) {
	while (buffer.size() < tokens && tokenizer.hasNext())
	    buffer.add(tokenizer.next());
	return buffer.size() >= tokens;
    }
886440
public void unsubscribe(ArrayList<Long> tokens){
        if(ws != null) {
            if (ws.isOpen()) {
                ws.sendText(createTickerJsonObject(tokens, mUnSubscribe).toString());
                subscribedTokens.removeAll(tokens);
                for(int i = 0; i < tokens.size(); i++){
                    modeMap.remove(tokens.get(i));
                }
            }
        }
    }
644382
public List<ParserToken> consumeUntil(ParserTokenType... types) {
      List<ParserToken> tokens = new ArrayList<>();
      while (lookAheadType(0) != null && !isOfType(lookAheadType(0), types)) {
         tokens.add(consume());
      }
      return tokens;
   }
1043421
@Override
    public boolean apply(List<E> tokens) {
        if (this.find(tokens) != null) {
            return true;
        } else {
            return false;
        }
    }
933335
function (startToken, endToken, types) {
            var is = true;
            var token = startToken;
            while (token.next && token.next !== endToken) {
                token = token.next;
                if (types.indexOf(token.type) === -1) {
                    is = false;
                    break;
                }
            }
            return is;
        }
565675
def _skip_newlines(self):
        """"""
        while self._cur_token['type'] is TT.lbreak and not self._finished:
            self._increment()