105  * pattern, and then attempt to return the next token. Both <tt>hasNext</tt>
117  * will not pass the token that caused the exception, so that it may be
425     // A pattern for any token
912     // Returns true if a complete token or partial token is in the buffer.
913     // It is not necessary to find a complete token since a partial token
914     // means that there will be another token with or without more input.
932      * Returns a "complete token" that matches the specified pattern
934      * A token is complete if surrounded by delims; a partial token
937      * The position is advanced to the end of that complete token
939      * Pattern == null means accept any token at all
977         // match a partial token instead of the whole thing.
1000             // There is a complete token.
1012             } else { // Complete token but it does not match
1018         // then we can treat the remainder as a whole token
1024             // Last token; Match the pattern here or throw
1036         // There is a partial token in the buffer; must read more
1370      * Returns true if this scanner has another token in its input.
1374      * @return true if and only if this scanner has another token
1391      * Finds and returns the next complete token from this scanner.
1392      * A complete token is preceded and followed by input that matches
1397      * @return the next token
1407             String token = getCompleteTokenInBuffer(null);
1408             if (token != null) {
1411                 return token;
1432      * Returns true if the next token matches the pattern constructed from the
1440      * @return true if and only if this scanner has another token matching
1449      * Returns the next token if it matches the pattern constructed from the
1458      * @return the next token
1467      * Returns true if the next complete token matches the specified pattern.
1468      * A complete token is prefixed and postfixed by input that matches
1473      * @return true if and only if this scanner has another token matching
1498      * Returns the next token if it matches the specified pattern. This
1505      * @return the next token
1521             String token = getCompleteTokenInBuffer(pattern);
1522             if (token != null) {
1525                 return token;
1626      * the desired token if no line separators are present.
1641             String token = findPatternInBuffer(separatorPattern(), 0);
1642             if (token != null) {
1722             String token = findPatternInBuffer(pattern, horizon);
1723             if (token != null) {
1725                 return token;
1766             String token = matchPatternInBuffer(pattern);
1767             if (token != null) {
1798      * Returns true if the next token in this scanner's input can be
1803      * @return true if and only if this scanner's next token is a valid
1812      * Scans the next token of the input into a boolean value and returns
1814      * if the next token cannot be translated into a valid boolean value.
1819      * @throws InputMismatchException if the next token is not a valid boolean
1829      * Returns true if the next token in this scanner's input can be
1833      * @return true if and only if this scanner's next token is a valid
1842      * Returns true if the next token in this scanner's input can be
1846      * @param radix the radix used to interpret the token as a byte value
1847      * @return true if and only if this scanner's next token is a valid
1868      * Scans the next token of the input as a <tt>byte</tt>.
1877      *         if the next token does not match the <i>Integer</i>
1887      * Scans the next token of the input as a <tt>byte</tt>.
1889      * if the next token cannot be translated into a valid byte value as
1893      * <p> If the next token matches the <a
1895      * above then the token is converted into a <tt>byte</tt> value as if by
1904      * @param radix the radix used to interpret the token as a byte value
1907      *         if the next token does not match the <i>Integer</i>
1929             position = matcher.start(); // don't skip bad token
1935      * Returns true if the next token in this scanner's input can be
1939      * @return true if and only if this scanner's next token is a valid
1948      * Returns true if the next token in this scanner's input can be
1952      * @param radix the radix used to interpret the token as a short value
1953      * @return true if and only if this scanner's next token is a valid
1974      * Scans the next token of the input as a <tt>short</tt>.
1983      *         if the next token does not match the <i>Integer</i>
1993      * Scans the next token of the input as a <tt>short</tt>.
1995      * if the next token cannot be translated into a valid short value as
1999      * <p> If the next token matches the <a
2001      * above then the token is converted into a <tt>short</tt> value as if by
2010      * @param radix the radix used to interpret the token as a short value
2013      *         if the next token does not match the <i>Integer</i>
2035             position = matcher.start(); // don't skip bad token
2041      * Returns true if the next token in this scanner's input can be
2045      * @return true if and only if this scanner's next token is a valid
2054      * Returns true if the next token in this scanner's input can be
2058      * @param radix the radix used to interpret the token as an int value
2059      * @return true if and only if this scanner's next token is a valid
2080      * The integer token must be stripped of prefixes, group separators,
2084     private String processIntegerToken(String token) {
2085         String result = token.replaceAll(""+groupSeparator, "");
2104      * Scans the next token of the input as an <tt>int</tt>.
2113      *         if the next token does not match the <i>Integer</i>
2123      * Scans the next token of the input as an <tt>int</tt>.
2125      * if the next token cannot be translated into a valid int value as
2129      * <p> If the next token matches the <a
2131      * above then the token is converted into an <tt>int</tt> value as if by
2140      * @param radix the radix used to interpret the token as an int value
2143      *         if the next token does not match the <i>Integer</i>
2165             position = matcher.start(); // don't skip bad token
2171      * Returns true if the next token in this scanner's input can be
2175      * @return true if and only if this scanner's next token is a valid
2184      * Returns true if the next token in this scanner's input can be
2188      * @param radix the radix used to interpret the token as a long value
2189      * @return true if and only if this scanner's next token is a valid
2210      * Scans the next token of the input as a <tt>long</tt>.
2219      *         if the next token does not match the <i>Integer</i>
2229      * Scans the next token of the input as a <tt>long</tt>.
2231      * if the next token cannot be translated into a valid long value as
2235      * <p> If the next token matches the <a
2237      * above then the token is converted into a <tt>long</tt> value as if by
2246      * @param radix the radix used to interpret the token as an int value
2249      *         if the next token does not match the <i>Integer</i>
2270             position = matcher.start(); // don't skip bad token
2276      * The float token must be stripped of prefixes, group separators,
2280      * If there are non-ascii digits in the token these digits must
2281      * be processed before the token is passed to parseFloat.
2283     private String processFloatToken(String token) {
2284         String result = token.replaceAll(groupSeparator, "");
2329      * Returns true if the next token in this scanner's input can be
2333      * @return true if and only if this scanner's next token is a valid
2352      * Scans the next token of the input as a <tt>float</tt>.
2354      * if the next token cannot be translated into a valid float value as
2358      * <p> If the next token matches the <a
2360      * then the token is converted into a <tt>float</tt> value as if by
2366      * {@link Float#parseFloat Float.parseFloat}. If the token matches
2373      *         if the next token does not match the <i>Float</i>
2390             position = matcher.start(); // don't skip bad token
2396      * Returns true if the next token in this scanner's input can be
2400      * @return true if and only if this scanner's next token is a valid
2419      * Scans the next token of the input as a <tt>double</tt>.
2421      * if the next token cannot be translated into a valid double value.
2425      * <p> If the next token matches the <a
2427      * then the token is converted into a <tt>double</tt> value as if by
2433      * {@link Double#parseDouble Double.parseDouble}. If the token matches
2440      *         if the next token does not match the <i>Float</i>
2458             position = matcher.start(); // don't skip bad token
2466      * Returns true if the next token in this scanner's input can be
2471      * @return true if and only if this scanner's next token is a valid
2480      * Returns true if the next token in this scanner's input can be
2485      * @param radix the radix used to interpret the token as an integer
2486      * @return true if and only if this scanner's next token is a valid
2507      * Scans the next token of the input as a {@link java.math.BigInteger
2517      *         if the next token does not match the <i>Integer</i>
2527      * Scans the next token of the input as a {@link java.math.BigInteger
2530      * <p> If the next token matches the <a
2532      * above then the token is converted into a <tt>BigInteger</tt> value as if
2539      * @param radix the radix used to interpret the token
2542      *         if the next token does not match the <i>Integer</i>
2564             position = matcher.start(); // don't skip bad token
2570      * Returns true if the next token in this scanner's input can be
2575      * @return true if and only if this scanner's next token is a valid
2594      * Scans the next token of the input as a {@link java.math.BigDecimal
2597      * <p> If the next token matches the <a
2599      * above then the token is converted into a <tt>BigDecimal</tt> value as if
2608      *         if the next token does not match the <i>Decimal</i>
2627             position = matcher.start(); // don't skip bad token

Indexes created Tue Jul 24 14:28:13 CEST 2018