| Methods Summary |
|---|
| private java.lang.StringBuilder | addNegativeSign(java.lang.StringBuilder unSignNumeral)
String negativePrefix = ""; //$NON-NLS-1$
String negativeSuffix = ""; //$NON-NLS-1$
if (!decimalFormat.getNegativePrefix().equals("")) { //$NON-NLS-1$
negativePrefix = "\\Q" + decimalFormat.getNegativePrefix()+"\\E"; //$NON-NLS-1$//$NON-NLS-2$
}
if (!decimalFormat.getNegativeSuffix().equals("")) { //$NON-NLS-1$
negativeSuffix = "\\Q" + decimalFormat.getNegativeSuffix()+"\\E"; //$NON-NLS-1$//$NON-NLS-2$
}
StringBuilder signedNumeral = new StringBuilder()
.append(negativePrefix).append(unSignNumeral).append(
negativeSuffix);
return signedNumeral;
|
| private java.lang.StringBuilder | addPositiveSign(java.lang.StringBuilder unSignNumeral)
String positivePrefix = ""; //$NON-NLS-1$
String positiveSuffix = ""; //$NON-NLS-1$
if (!decimalFormat.getPositivePrefix().equals("")) { //$NON-NLS-1$
positivePrefix = "\\Q" + decimalFormat.getPositivePrefix()+"\\E"; //$NON-NLS-1$ //$NON-NLS-2$
}
if (!decimalFormat.getPositiveSuffix().equals("")) { //$NON-NLS-1$
positiveSuffix = "\\Q" + decimalFormat.getPositiveSuffix()+"\\E"; //$NON-NLS-1$ //$NON-NLS-2$
}
StringBuilder signedNumeral = new StringBuilder()
.append(positivePrefix).append(unSignNumeral).append(
positiveSuffix);
return signedNumeral;
|
| private void | checkClosed()
if (closed) {
throw new IllegalStateException();
}
|
| private void | checkNull(java.util.regex.Pattern pattern)
if (null == pattern) {
throw new NullPointerException();
}
|
| public void | close()Closes this {@code Scanner} and the underlying input if the input implements
{@code Closeable}. If the {@code Scanner} has been closed, this method will have
no effect. Any scanning operation called after calling this method will throw
an {@code IllegalStateException}.
if (closed) {
return;
}
if (input instanceof Closeable) {
try {
((Closeable) input).close();
} catch (IOException e) {
lastIOException = e;
}
}
closed = true;
|
| public java.util.regex.Pattern | delimiter()Returns the delimiter {@code Pattern} in use by this {@code Scanner}.
return delimiter;
|
| private void | expandBuffer()
int oldPosition = buffer.position();
int oldCapacity = buffer.capacity();
int oldLimit = buffer.limit();
int newCapacity = oldCapacity * DIPLOID;
char[] newBuffer = new char[newCapacity];
System.arraycopy(buffer.array(), 0, newBuffer, 0, oldLimit);
buffer = CharBuffer.wrap(newBuffer, 0, newCapacity);
buffer.position(oldPosition);
buffer.limit(oldLimit);
|
| public java.lang.String | findInLine(java.util.regex.Pattern pattern)Tries to find the pattern in the input. Delimiters are ignored. If the
pattern is found before line terminator, the matched string will be
returned, and the {@code Scanner} will advance to the end of the matched string.
Otherwise, {@code null} will be returned and the {@code Scanner} will not advance.
When waiting for input, the {@code Scanner} may be blocked. All the
input may be cached if no line terminator exists in the buffer.
checkClosed();
checkNull(pattern);
int horizonLineSeparator = 0;
matcher.usePattern(MULTI_LINE_TERMINATOR);
matcher.region(findStartIndex, bufferLength);
boolean findComplete = false;
int terminatorLength = 0;
while (!findComplete) {
if (matcher.find()) {
horizonLineSeparator = matcher.start();
terminatorLength = matcher.end() - matcher.start();
findComplete = true;
} else {
if (!inputExhausted) {
readMore();
resetMatcher();
} else {
horizonLineSeparator = bufferLength;
findComplete = true;
}
}
}
matcher.usePattern(pattern);
/*
* TODO The following 2 statements are used to deal with regex's bug.
* java.util.regex.Matcher.region(int start, int end) implementation
* does not have any effects when called. They will be removed once the
* bug is fixed.
*/
int oldLimit = buffer.limit();
buffer.limit(horizonLineSeparator);
// ========== To deal with regex bug ====================
matcher.region(findStartIndex, horizonLineSeparator);
if (matcher.find()) {
// The scanner advances past the input that matched
findStartIndex = matcher.end();
// If the matched pattern is immediately followed by line terminator.
if(horizonLineSeparator == matcher.end()) {
findStartIndex += terminatorLength;
}
matchSuccessful = true;
// ========== To deal with regex bug ====================
buffer.limit(oldLimit);
// ========== To deal with regex bug ====================
return matcher.group();
}
// ========== To deal with regex bug ====================
buffer.limit(oldLimit);
// ========== To deal with regex bug ====================
matchSuccessful = false;
return null;
|
| public java.lang.String | findInLine(java.lang.String pattern)Compiles the pattern string and tries to find a substing matching it in the input data. The
delimiter will be ignored. This is the same as invoking
{@code findInLine(Pattern.compile(pattern))}.
return findInLine(Pattern.compile(pattern));
|
| private int | findPostDelimiter()
int tokenEndIndex = 0;
boolean findComplete = false;
while (!findComplete) {
if (matcher.find()) {
findComplete = true;
if (matcher.start() == findStartIndex
&& matcher.start() == matcher.end()) {
findComplete = false;
}
} else {
if (!inputExhausted) {
readMore();
resetMatcher();
} else {
return -1;
}
}
}
tokenEndIndex = matcher.start();
findStartIndex = matcher.start();
return tokenEndIndex;
|
| private int | findPreDelimiter()
int tokenStartIndex;
boolean findComplete = false;
while (!findComplete) {
if (matcher.find()) {
findComplete = true;
// If just delimiter remains
if (matcher.start() == findStartIndex
&& matcher.end() == bufferLength) {
// If more input resource exists
if (!inputExhausted) {
readMore();
resetMatcher();
findComplete = false;
}
}
} else {
if (!inputExhausted) {
readMore();
resetMatcher();
} else {
return -1;
}
}
}
tokenStartIndex = matcher.end();
findStartIndex = matcher.end();
return tokenStartIndex;
|
| public java.lang.String | findWithinHorizon(java.util.regex.Pattern pattern, int horizon)Tries to find the pattern in the input between the current position and the specified
horizon. Delimiters are ignored. If the pattern is found, the matched
string will be returned, and the {@code Scanner} will advance to the end of the
matched string. Otherwise, null will be returned and {@code Scanner} will not
advance. When waiting for input, the {@code Scanner} may be blocked.
The {@code Scanner}'s search will never go more than {@code horizon} code points from current
position. The position of {@code horizon} does have an effect on the result of the
match. For example, when the input is "123" and current position is at zero,
{@code findWithinHorizon(Pattern.compile("\\p{Digit}{3}"), 2)}
will return {@code null}. While
{@code findWithinHorizon(Pattern.compile("\\p{Digit}{3}"), 3)}
will return {@code "123"}. {@code horizon} is treated as a transparent,
non-anchoring bound. (refer to
{@link Matcher#useTransparentBounds(boolean)} and
{@link Matcher#useAnchoringBounds(boolean)})
A {@code horizon} whose value is zero will be ignored and the whole input will be
used for search. In this situation, all the input may be cached.
checkClosed();
checkNull(pattern);
if (horizon < 0) {
throw new IllegalArgumentException(org.apache.harmony.luni.util.Msg
.getString("KA00e")); //$NON-NLS-1$
}
matcher.usePattern(pattern);
String result = null;
int findEndIndex = 0;
int horizonEndIndex = 0;
if (horizon == 0) {
horizonEndIndex = Integer.MAX_VALUE;
} else {
horizonEndIndex = findStartIndex + horizon;
}
while (true) {
findEndIndex = bufferLength;
// If horizon > 0, then search up to
// min( bufferLength, findStartIndex + horizon).
// Otherwise search until readable is exhausted.
findEndIndex = Math.min(horizonEndIndex, bufferLength);
// If horizon == 0, consider horizon as always outside buffer.
boolean isHorizonInBuffer = (horizonEndIndex <= bufferLength);
// First, try to find pattern within buffer. If pattern can not be
// found in buffer, then expand the buffer and try again,
// util horizonEndIndex is exceeded or no more input left.
matcher.region(findStartIndex, findEndIndex);
if (matcher.find()) {
if (isHorizonInBuffer || inputExhausted) {
result = matcher.group();
break;
}
} else {
// Pattern is not found in buffer while horizonEndIndex is
// within buffer, or input is exhausted. Under this situation,
// it can be judged that find fails.
if (isHorizonInBuffer || inputExhausted) {
break;
}
}
// Expand buffer and reset matcher if needed.
if (!inputExhausted) {
readMore();
resetMatcher();
}
}
if (null != result) {
findStartIndex = matcher.end();
matchSuccessful = true;
} else {
matchSuccessful = false;
}
return result;
|
| public java.lang.String | findWithinHorizon(java.lang.String pattern, int horizon)Tries to find the pattern in the input between the current position and the specified
{@code horizon}. Delimiters are ignored. This call is the same as invoking
{@code findWithinHorizon(Pattern.compile(pattern))}.
return findWithinHorizon(Pattern.compile(pattern), horizon);
|
| private java.util.regex.Pattern | getFloatPattern()
decimalFormat = (DecimalFormat) NumberFormat.getInstance(locale);
StringBuilder digit = new StringBuilder("([0-9]|(\\p{javaDigit}))"); //$NON-NLS-1$
StringBuilder nonZeroDigit = new StringBuilder("[\\p{javaDigit}&&[^0]]"); //$NON-NLS-1$
StringBuilder numeral = getNumeral(digit, nonZeroDigit);
String decimalSeparator = "\\" + decimalFormat.getDecimalFormatSymbols()//$NON-NLS-1$
.getDecimalSeparator();
StringBuilder decimalNumeral = new StringBuilder("(").append(numeral) //$NON-NLS-1$
.append("|").append(numeral) //$NON-NLS-1$
.append(decimalSeparator).append(digit).append("*+|").append( //$NON-NLS-1$
decimalSeparator).append(digit).append("++)"); //$NON-NLS-1$
StringBuilder exponent = new StringBuilder("([eE][+-]?").append(digit) //$NON-NLS-1$
.append("+)?"); //$NON-NLS-1$
StringBuilder decimal = new StringBuilder("(([-+]?").append( //$NON-NLS-1$
decimalNumeral).append("(").append(exponent).append("?)") //$NON-NLS-1$ //$NON-NLS-2$
.append(")|(").append(addPositiveSign(decimalNumeral)).append( //$NON-NLS-1$
"(").append(exponent).append("?)").append(")|(") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
.append(addNegativeSign(decimalNumeral)).append("(").append( //$NON-NLS-1$
exponent).append("?)").append("))"); //$NON-NLS-1$ //$NON-NLS-2$
StringBuilder hexFloat = new StringBuilder("([-+]?0[xX][0-9a-fA-F]*") //$NON-NLS-1$
.append("\\.").append(//$NON-NLS-1$
"[0-9a-fA-F]+([pP][-+]?[0-9]+)?)"); //$NON-NLS-1$
String localNaN = decimalFormat.getDecimalFormatSymbols().getNaN();
String localeInfinity = decimalFormat.getDecimalFormatSymbols()
.getInfinity();
StringBuilder nonNumber = new StringBuilder("(NaN|\\Q").append(localNaN) //$NON-NLS-1$
.append("\\E|Infinity|\\Q").append(localeInfinity).append("\\E)"); //$NON-NLS-1$ //$NON-NLS-2$
StringBuilder singedNonNumber = new StringBuilder("((([-+]?(").append( //$NON-NLS-1$
nonNumber).append(")))|(").append(addPositiveSign(nonNumber)) //$NON-NLS-1$
.append(")|(").append(addNegativeSign(nonNumber)).append("))"); //$NON-NLS-1$ //$NON-NLS-2$
StringBuilder floatString = new StringBuilder().append(decimal).append(
"|").append(hexFloat).append("|").append(singedNonNumber); //$NON-NLS-1$ //$NON-NLS-2$
Pattern floatPattern = Pattern.compile(floatString.toString());
return floatPattern;
|
| private java.util.regex.Pattern | getIntegerPattern(int radix)
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
throw new IllegalArgumentException(org.apache.harmony.luni.util.Msg
.getString("KA00e", radix)); //$NON-NLS-1$
}
decimalFormat = (DecimalFormat) NumberFormat.getInstance(locale);
String allAvailableDigits="0123456789abcdefghijklmnopqrstuvwxyz"; //$NON-NLS-1$
String ASCIIDigit=allAvailableDigits.substring(0, radix);
String nonZeroASCIIDigit=allAvailableDigits.substring(1, radix);
StringBuilder digit = new StringBuilder("((?i)[").append(ASCIIDigit) //$NON-NLS-1$
.append("]|\\p{javaDigit})"); //$NON-NLS-1$
StringBuilder nonZeroDigit = new StringBuilder("((?i)[").append( //$NON-NLS-1$
nonZeroASCIIDigit).append("]|([\\p{javaDigit}&&[^0]]))"); //$NON-NLS-1$
StringBuilder numeral = getNumeral(digit, nonZeroDigit);
StringBuilder integer = new StringBuilder("(([-+]?(").append(numeral) //$NON-NLS-1$
.append(")))|(").append(addPositiveSign(numeral)).append(")|(") //$NON-NLS-1$ //$NON-NLS-2$
.append(addNegativeSign(numeral)).append(")"); //$NON-NLS-1$
Pattern integerPattern = Pattern.compile(integer.toString());
return integerPattern;
|
| private java.lang.StringBuilder | getNumeral(java.lang.StringBuilder digit, java.lang.StringBuilder nonZeroDigit)
String groupSeparator = "\\"//$NON-NLS-1$
+ decimalFormat.getDecimalFormatSymbols()
.getGroupingSeparator();
StringBuilder groupedNumeral = new StringBuilder("(").append( //$NON-NLS-1$
nonZeroDigit).append(digit).append("?").append(digit).append( //$NON-NLS-1$
"?(").append(groupSeparator).append(digit).append(digit) //$NON-NLS-1$
.append(digit).append(")+)"); //$NON-NLS-1$
StringBuilder numeral = new StringBuilder("((").append(digit).append( //$NON-NLS-1$
"++)|").append(groupedNumeral).append(")"); //$NON-NLS-1$ //$NON-NLS-2$
return numeral;
|
| public boolean | hasNext()Returns whether this {@code Scanner} has one or more tokens remaining to parse.
This method will block if the data is still being read.
return hasNext(ANY_PATTERN);
|
| public boolean | hasNext(java.util.regex.Pattern pattern)Returns whether this {@code Scanner} has one or more tokens remaining to parse
and the next token matches the given pattern. This method will block if the data is
still being read.
checkClosed();
checkNull(pattern);
matchSuccessful = false;
saveCurrentStatus();
//if the next token exists, set the match region, otherwise return false
if (!setTokenRegion()) {
recoverPreviousStatus();
return false;
}
matcher.usePattern(pattern);
boolean hasNext = false;
//check whether next token matches the specified pattern
if (matcher.matches()) {
cachehasNextIndex = findStartIndex;
matchSuccessful = true;
hasNext = true;
}
recoverPreviousStatus();
return hasNext;
|
| public boolean | hasNext(java.lang.String pattern)Returns {@code true} if this {@code Scanner} has one or more tokens remaining to parse
and the next token matches a pattern compiled from the given string. This method will
block if the data is still being read. This call is equivalent to
{@code hasNext(Pattern.compile(pattern))}.
return hasNext(Pattern.compile(pattern));
|
| public boolean | hasNextBigDecimal()Returns whether the next token can be translated into a valid
{@code BigDecimal}.
Pattern floatPattern = getFloatPattern();
boolean isBigDecimalValue = false;
if (hasNext(floatPattern)) {
String floatString = matcher.group();
floatString = removeLocaleInfoFromFloat(floatString);
try {
cacheHasNextValue = new BigDecimal(floatString);
isBigDecimalValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isBigDecimalValue;
|
| public boolean | hasNextBigInteger()Returns whether the next token can be translated into a valid
{@code BigInteger} in the default radix.
return hasNextBigInteger(integerRadix);
|
| public boolean | hasNextBigInteger(int radix)Returns whether the next token can be translated into a valid
{@code BigInteger} in the specified radix.
Pattern integerPattern = getIntegerPattern(radix);
boolean isBigIntegerValue = false;
if (hasNext(integerPattern)) {
String intString = matcher.group();
intString = removeLocaleInfo(intString, DataType.INT);
try {
cacheHasNextValue = new BigInteger(intString, radix);
isBigIntegerValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isBigIntegerValue;
|
| public boolean | hasNextBoolean()Returns whether the next token can be translated into a valid
{@code boolean} value.
return hasNext(BOOLEAN_PATTERN);
|
| public boolean | hasNextByte()Returns whether the next token can be translated into a valid
{@code byte} value in the default radix.
return hasNextByte(integerRadix);
|
| public boolean | hasNextByte(int radix)Returns whether the next token can be translated into a valid
{@code byte} value in the specified radix.
Pattern integerPattern = getIntegerPattern(radix);
boolean isByteValue = false;
if (hasNext(integerPattern)) {
String intString = matcher.group();
intString = removeLocaleInfo(intString, DataType.INT);
try {
cacheHasNextValue = Byte.valueOf(intString, radix);
isByteValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isByteValue;
|
| public boolean | hasNextDouble()Returns whether the next token translated into a valid {@code double}
value.
Pattern floatPattern = getFloatPattern();
boolean isDoubleValue = false;
if (hasNext(floatPattern)) {
String floatString = matcher.group();
floatString = removeLocaleInfoFromFloat(floatString);
try {
cacheHasNextValue = Double.valueOf(floatString);
isDoubleValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isDoubleValue;
|
| public boolean | hasNextFloat()Returns whether the next token can be translated into a valid
{@code float} value.
Pattern floatPattern = getFloatPattern();
boolean isFloatValue = false;
if (hasNext(floatPattern)) {
String floatString = matcher.group();
floatString = removeLocaleInfoFromFloat(floatString);
try {
cacheHasNextValue = Float.valueOf(floatString);
isFloatValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isFloatValue;
|
| public boolean | hasNextInt()Returns whether the next token can be translated into a valid {@code int}
value in the default radix.
return hasNextInt(integerRadix);
|
| public boolean | hasNextInt(int radix)Returns whether the next token can be translated into a valid {@code int}
value in the specified radix.
Pattern integerPattern = getIntegerPattern(radix);
boolean isIntValue = false;
if (hasNext(integerPattern)) {
String intString = matcher.group();
intString = removeLocaleInfo(intString, DataType.INT);
try {
cacheHasNextValue = Integer.valueOf(intString, radix);
isIntValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isIntValue;
|
| public boolean | hasNextLine()Returns whether there is a line terminator in the input.
This method may block.
checkClosed();
matcher.usePattern(LINE_PATTERN);
matcher.region(findStartIndex, bufferLength);
boolean hasNextLine = false;
while (true) {
if (matcher.find()) {
if (inputExhausted || matcher.end() != bufferLength) {
matchSuccessful = true;
hasNextLine = true;
break;
}
} else {
if (inputExhausted) {
matchSuccessful = false;
break;
}
}
if (!inputExhausted) {
readMore();
resetMatcher();
}
}
return hasNextLine;
|
| public boolean | hasNextLong()Returns whether the next token can be translated into a valid
{@code long} value in the default radix.
return hasNextLong(integerRadix);
|
| public boolean | hasNextLong(int radix)Returns whether the next token can be translated into a valid
{@code long} value in the specified radix.
Pattern integerPattern = getIntegerPattern(radix);
boolean isLongValue = false;
if (hasNext(integerPattern)) {
String intString = matcher.group();
intString = removeLocaleInfo(intString, DataType.INT);
try {
cacheHasNextValue = Long.valueOf(intString, radix);
isLongValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isLongValue;
|
| public boolean | hasNextShort()Returns whether the next token can be translated into a valid
{@code short} value in the default radix.
return hasNextShort(integerRadix);
|
| public boolean | hasNextShort(int radix)Returns whether the next token can be translated into a valid
{@code short} value in the specified radix.
Pattern integerPattern = getIntegerPattern(radix);
boolean isShortValue = false;
if (hasNext(integerPattern)) {
String intString = matcher.group();
intString = removeLocaleInfo(intString, DataType.INT);
try {
cacheHasNextValue = Short.valueOf(intString, radix);
isShortValue = true;
} catch (NumberFormatException e) {
matchSuccessful = false;
}
}
return isShortValue;
|
| private void | initialization()
buffer = CharBuffer.allocate(DEFAULT_TRUNK_SIZE);
buffer.limit(0);
matcher = delimiter.matcher(buffer);
|
| public java.io.IOException | ioException()Returns the last {@code IOException} that was raised while reading from the underlying
input.
return lastIOException;
|
| public java.util.Locale | locale()Return the {@code Locale} of this {@code Scanner}.
return locale;
|
| public java.util.regex.MatchResult | match()Returns the result of the last matching operation.
The next* and find* methods return the match result in the case of a
successful match.
if (!matchSuccessful) {
throw new IllegalStateException();
}
return matcher.toMatchResult();
|
| public java.lang.String | next()Returns the next token. The token will be both prefixed and postfixed by
the delimiter that is currently being used (or a string that matches the
delimiter pattern). This method will block if input is being read.
return next(ANY_PATTERN);
|
| public java.lang.String | next(java.util.regex.Pattern pattern)Returns the next token if it matches the specified pattern. The token
will be both prefixed and postfixed by the delimiter that is currently
being used (or a string that matches the delimiter pattern). This method will block
if input is being read.
checkClosed();
checkNull(pattern);
matchSuccessful = false;
saveCurrentStatus();
if (!setTokenRegion()) {
recoverPreviousStatus();
// if setting match region fails
throw new NoSuchElementException();
}
matcher.usePattern(pattern);
if (!matcher.matches()) {
recoverPreviousStatus();
throw new InputMismatchException();
}
matchSuccessful = true;
return matcher.group();
|
| public java.lang.String | next(java.lang.String pattern)Returns the next token if it matches the specified pattern. The token
will be both prefixed and postfixed by the delimiter that is currently
being used (or a string that matches the delimiter pattern). This method will block
if input is being read. Calling this methos is equivalent to
{@code next(Pattern.compile(pattern))}.
return next(Pattern.compile(pattern));
|
| public java.math.BigDecimal | nextBigDecimal()Returns the next token as a {@code BigDecimal}. This method will block if input is
being read. If the next token can be translated into a {@code BigDecimal}
the following is done: All {@code Locale}-specific prefixes, group separators,
and {@code Locale}-specific suffixes are removed. Then non-ASCII digits are
mapped into ASCII digits via {@link Character#digit(char, int)}, and a
negative sign (-) is added if the {@code Locale}-specific negative prefix or
suffix was present. Finally the resulting string is passed to
{@code BigDecimal(String) }.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof BigDecimal) {
findStartIndex = cachehasNextIndex;
return (BigDecimal) obj;
}
Pattern floatPattern = getFloatPattern();
String floatString = next(floatPattern);
floatString = removeLocaleInfoFromFloat(floatString);
BigDecimal bigDecimalValue;
try {
bigDecimalValue = new BigDecimal(floatString);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return bigDecimalValue;
|
| public java.math.BigInteger | nextBigInteger()Returns the next token as a {@code BigInteger}. This method will block if input is
being read. Equivalent to {@code nextBigInteger(DEFAULT_RADIX)}.
return nextBigInteger(integerRadix);
|
| public java.math.BigInteger | nextBigInteger(int radix)Returns the next token as a {@code BigInteger} with the specified radix.
This method will block if input is being read. If the next token can be translated
into a {@code BigInteger} the following is done: All {@code Locale}-specific
prefixes, group separators, and {@code Locale}-specific suffixes are removed.
Then non-ASCII digits are mapped into ASCII digits via
{@link Character#digit(char, int)}, and a negative sign (-) is added if the
{@code Locale}-specific negative prefix or suffix was present. Finally the
resulting String is passed to {@link BigInteger#BigInteger(String, int)}}
with the specified radix.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof BigInteger) {
findStartIndex = cachehasNextIndex;
return (BigInteger) obj;
}
Pattern integerPattern = getIntegerPattern(radix);
String intString = next(integerPattern);
intString = removeLocaleInfo(intString, DataType.INT);
BigInteger bigIntegerValue;
try {
bigIntegerValue = new BigInteger(intString, radix);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return bigIntegerValue;
|
| public boolean | nextBoolean()Returns the next token as a {@code boolean}. This method will block if input is
being read.
return Boolean.parseBoolean(next(BOOLEAN_PATTERN));
|
| public byte | nextByte()Returns the next token as a {@code byte}. This method will block if input is being
read. Equivalent to {@code nextByte(DEFAULT_RADIX)}.
return nextByte(integerRadix);
|
| public byte | nextByte(int radix)Returns the next token as a {@code byte} with the specified radix. Will
block if input is being read. If the next token can be translated into a
{@code byte} the following is done: All {@code Locale}-specific prefixes, group
separators, and {@code Locale}-specific suffixes are removed. Then non-ASCII
digits are mapped into ASCII digits via
{@link Character#digit(char, int)}, and a negative sign (-) is added if the
{@code Locale}-specific negative prefix or suffix was present. Finally the
resulting String is passed to {@link Byte#parseByte(String, int)}} with
the specified radix.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Byte) {
findStartIndex = cachehasNextIndex;
return (Byte) obj;
}
Pattern integerPattern = getIntegerPattern(radix);
String intString = next(integerPattern);
intString = removeLocaleInfo(intString, DataType.INT);
byte byteValue = 0;
try {
byteValue = Byte.parseByte(intString, radix);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return byteValue;
|
| public double | nextDouble()Returns the next token as a {@code double}. This method will block if input is being
read. If the next token can be translated into a {@code double} the
following is done: All {@code Locale}-specific prefixes, group separators, and
{@code Locale}-specific suffixes are removed. Then non-ASCII digits are mapped
into ASCII digits via {@link Character#digit(char, int)}, and a negative
sign (-) is added if the {@code Locale}-specific negative prefix or suffix was
present. Finally the resulting String is passed to
{@link Double#parseDouble(String)}}. If the token matches the localized
NaN or infinity strings, it is also passed to
{@link Double#parseDouble(String)}}.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Double) {
findStartIndex = cachehasNextIndex;
return (Double) obj;
}
Pattern floatPattern = getFloatPattern();
String floatString = next(floatPattern);
floatString = removeLocaleInfoFromFloat(floatString);
double doubleValue = 0;
try {
doubleValue = Double.parseDouble(floatString);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return doubleValue;
|
| public float | nextFloat()Returns the next token as a {@code float}. This method will block if input is being
read. If the next token can be translated into a {@code float} the
following is done: All {@code Locale}-specific prefixes, group separators, and
{@code Locale}-specific suffixes are removed. Then non-ASCII digits are mapped
into ASCII digits via {@link Character#digit(char, int)}, and a negative
sign (-) is added if the {@code Locale}-specific negative prefix or suffix was
present. Finally the resulting String is passed to
{@link Float#parseFloat(String)}}.If the token matches the localized NaN
or infinity strings, it is also passed to
{@link Float#parseFloat(String)}}.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Float) {
findStartIndex = cachehasNextIndex;
return (Float) obj;
}
Pattern floatPattern = getFloatPattern();
String floatString = next(floatPattern);
floatString = removeLocaleInfoFromFloat(floatString);
float floatValue = 0;
try {
floatValue = Float.parseFloat(floatString);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return floatValue;
|
| public int | nextInt()Returns the next token as an {@code int}. This method will block if input is being
read. Equivalent to {@code nextInt(DEFAULT_RADIX)}.
return nextInt(integerRadix);
|
| public int | nextInt(int radix)Returns the next token as an {@code int} with the specified radix. This method will
block if input is being read. If the next token can be translated into an
{@code int} the following is done: All {@code Locale}-specific prefixes, group
separators, and {@code Locale}-specific suffixes are removed. Then non-ASCII
digits are mapped into ASCII digits via
{@link Character#digit(char, int)}, and a negative sign (-) is added if the
{@code Locale}-specific negative prefix or suffix was present. Finally the
resulting String is passed to {@link Integer#parseInt(String, int)} with
the specified radix.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Integer) {
findStartIndex = cachehasNextIndex;
return (Integer) obj;
}
Pattern integerPattern = getIntegerPattern(radix);
String intString=next(integerPattern);
intString = removeLocaleInfo(intString, DataType.INT);
int intValue = 0;
try {
intValue = Integer.parseInt(intString, radix);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return intValue;
|
| public java.lang.String | nextLine()Returns the skipped input and advances the {@code Scanner} to the beginning of
the next line. The returned result will exclude any line terminator. When
searching, if no line terminator is found, then a large amount of input
will be cached. If no line at all can be found, a {@code NoSuchElementException}
will be thrown.
checkClosed();
matcher.usePattern(LINE_PATTERN);
matcher.region(findStartIndex, bufferLength);
String result = null;
while (true) {
if (matcher.find()) {
if (inputExhausted || matcher.end() != bufferLength) {
matchSuccessful = true;
findStartIndex = matcher.end();
result = matcher.group();
break;
}
} else {
if (inputExhausted) {
matchSuccessful = false;
throw new NoSuchElementException();
}
}
if (!inputExhausted) {
readMore();
resetMatcher();
}
}
// Find text without line terminator here.
if (null != result) {
Matcher terminatorMatcher = LINE_TERMINATOR.matcher(result);
if (terminatorMatcher.find()) {
result = result.substring(0, terminatorMatcher.start());
}
}
return result;
|
| public long | nextLong()Returns the next token as a {@code long}. This method will block if input is being
read. Equivalent to {@code nextLong(DEFAULT_RADIX)}.
return nextLong(integerRadix);
|
| public long | nextLong(int radix)Returns the next token as a {@code long} with the specified radix. This method will
block if input is being read. If the next token can be translated into a
{@code long} the following is done: All {@code Locale}-specific prefixes, group
separators, and {@code Locale}-specific suffixes are removed. Then non-ASCII
digits are mapped into ASCII digits via
{@link Character#digit(char, int)}, and a negative sign (-) is added if the
{@code Locale}-specific negative prefix or suffix was present. Finally the
resulting String is passed to {@link Long#parseLong(String, int)}} with
the specified radix.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Long) {
findStartIndex = cachehasNextIndex;
return (Long) obj;
}
Pattern integerPattern = getIntegerPattern(radix);
String intString = next(integerPattern);
intString = removeLocaleInfo(intString, DataType.INT);
long longValue = 0;
try {
longValue = Long.parseLong(intString, radix);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return longValue;
|
| public short | nextShort()Returns the next token as a {@code short}. This method will block if input is being
read. Equivalent to {@code nextShort(DEFAULT_RADIX)}.
return nextShort(integerRadix);
|
| public short | nextShort(int radix)Returns the next token as a {@code short} with the specified radix. This method will
block if input is being read. If the next token can be translated into a
{@code short} the following is done: All {@code Locale}-specific prefixes, group
separators, and {@code Locale}-specific suffixes are removed. Then non-ASCII
digits are mapped into ASCII digits via
{@link Character#digit(char, int)}, and a negative sign (-) is added if the
{@code Locale}-specific negative prefix or suffix was present. Finally the
resulting String is passed to {@link Short#parseShort(String, int)}}
with the specified radix.
checkClosed();
Object obj = cacheHasNextValue;
cacheHasNextValue = null;
if (obj instanceof Short) {
findStartIndex = cachehasNextIndex;
return (Short) obj;
}
Pattern integerPattern = getIntegerPattern(radix);
String intString = next(integerPattern);
intString = removeLocaleInfo(intString, DataType.INT);
short shortValue = 0;
try {
shortValue = Short.parseShort(intString, radix);
} catch (NumberFormatException e) {
matchSuccessful = false;
recoverPreviousStatus();
throw new InputMismatchException();
}
return shortValue;
|
| public int | radix()Return the radix of this {@code Scanner}.
return integerRadix;
|
| private void | readMore()
int oldPosition = buffer.position();
int oldBufferLength = bufferLength;
// Increase capacity if empty space is not enough
if (bufferLength >= buffer.capacity()) {
expandBuffer();
}
// Read input resource
int readCount = 0;
try {
buffer.limit(buffer.capacity());
buffer.position(oldBufferLength);
while ((readCount = input.read(buffer)) == 0) {
// nothing to do here
}
} catch (IOException e) {
// Consider the scenario: readable puts 4 chars into
// buffer and then an IOException is thrown out. In this case, buffer is
// actually grown, but readable.read() will never return.
bufferLength = buffer.position();
/*
* Uses -1 to record IOException occurring, and no more input can be
* read.
*/
readCount = -1;
lastIOException = e;
}
buffer.flip();
buffer.position(oldPosition);
if (-1 == readCount) {
inputExhausted = true;
} else {
bufferLength = readCount + bufferLength;
}
|
| private void | recoverPreviousStatus()
findStartIndex = preStartIndex;
|
| public void | remove()Remove is not a supported operation on {@code Scanner}.
throw new UnsupportedOperationException();
|
| private java.lang.String | removeLocaleInfo(java.lang.String token, java.util.Scanner$DataType type)
StringBuilder tokenBuilder = new StringBuilder(token);
boolean negative = removeLocaleSign(tokenBuilder);
// Remove group separator
String groupSeparator = String.valueOf(decimalFormat
.getDecimalFormatSymbols().getGroupingSeparator());
int separatorIndex = -1;
while (-1 != (separatorIndex = tokenBuilder.indexOf(groupSeparator))) {
tokenBuilder.delete(separatorIndex, separatorIndex + 1);
}
// Remove decimal separator
String decimalSeparator = String.valueOf(decimalFormat
.getDecimalFormatSymbols().getDecimalSeparator());
separatorIndex = tokenBuilder.indexOf(decimalSeparator);
StringBuilder result = new StringBuilder(""); //$NON-NLS-1$
if (DataType.INT == type) {
for (int i = 0; i < tokenBuilder.length(); i++) {
if (-1 != Character.digit(tokenBuilder.charAt(i),
Character.MAX_RADIX)) {
result.append(tokenBuilder.charAt(i));
}
}
}
if (DataType.FLOAT == type) {
if (tokenBuilder.toString().equals(decimalFormat.getDecimalFormatSymbols()
.getNaN())) {
result.append("NaN");//$NON-NLS-1$
} else if (tokenBuilder.toString().equals(decimalFormat
.getDecimalFormatSymbols().getInfinity())) {
result.append("Infinity");//$NON-NLS-1$
} else {
for (int i = 0; i < tokenBuilder.length(); i++) {
if (-1 != Character.digit(tokenBuilder.charAt(i), 10)) {
result.append(Character.digit(tokenBuilder.charAt(i),
10));
}
}
}
}
// Token is NaN or Infinity
if (0 == result.length()) {
result = tokenBuilder;
}
if (-1 != separatorIndex) {
result.insert(separatorIndex, "."); //$NON-NLS-1$
}
// If input is negative
if (negative) {
result.insert(0, '-");
}
return result.toString();
|
| private java.lang.String | removeLocaleInfoFromFloat(java.lang.String floatString)
// If the token is HexFloat
if (-1 != floatString.indexOf('x")
|| -1 != floatString.indexOf('X")) {
return floatString;
}
int exponentIndex;
String decimalNumeralString;
String exponentString;
// If the token is scientific notation
if (-1 != (exponentIndex = floatString.indexOf('e"))
|| -1 != (exponentIndex = floatString.indexOf('E"))) {
decimalNumeralString = floatString.substring(0, exponentIndex);
exponentString = floatString.substring(exponentIndex + 1,
floatString.length());
decimalNumeralString = removeLocaleInfo(decimalNumeralString,
DataType.FLOAT);
return decimalNumeralString + "e" + exponentString; //$NON-NLS-1$
}
return removeLocaleInfo(floatString, DataType.FLOAT);
|
| private boolean | removeLocaleSign(java.lang.StringBuilder tokenBuilder)
String positivePrefix = decimalFormat.getPositivePrefix();
String positiveSuffix = decimalFormat.getPositiveSuffix();
String negativePrefix = decimalFormat.getNegativePrefix();
String negativeSuffix = decimalFormat.getNegativeSuffix();
if (0 == tokenBuilder.indexOf("+")) { //$NON-NLS-1$
tokenBuilder.delete(0, 1);
}
if (!positivePrefix.equals("") //$NON-NLS-1$
&& 0 == tokenBuilder.indexOf(positivePrefix)) {
tokenBuilder.delete(0, positivePrefix.length());
}
if (!positiveSuffix.equals("") //$NON-NLS-1$
&& -1 != tokenBuilder.indexOf(positiveSuffix)) {
tokenBuilder.delete(
tokenBuilder.length() - positiveSuffix.length(),
tokenBuilder.length());
}
boolean negative = false;
if (0 == tokenBuilder.indexOf("-")) { //$NON-NLS-1$
tokenBuilder.delete(0, 1);
negative = true;
}
if (!negativePrefix.equals("") //$NON-NLS-1$
&& 0 == tokenBuilder.indexOf(negativePrefix)) {
tokenBuilder.delete(0, negativePrefix.length());
negative = true;
}
if (!negativeSuffix.equals("") //$NON-NLS-1$
&& -1 != tokenBuilder.indexOf(negativeSuffix)) {
tokenBuilder.delete(
tokenBuilder.length() - negativeSuffix.length(),
tokenBuilder.length());
negative = true;
}
return negative;
|
| private void | resetMatcher()
if (null == matcher) {
matcher = delimiter.matcher(buffer);
} else {
matcher.reset(buffer);
}
matcher.region(findStartIndex, bufferLength);
|
| private void | saveCurrentStatus()
preStartIndex = findStartIndex;
|
| private boolean | setHeadTokenRegion(int findIndex)
int tokenStartIndex;
int tokenEndIndex;
boolean setSuccess = false;
// If no delimiter exists, but something exites in this scanner
if (-1 == findIndex && preStartIndex != bufferLength) {
tokenStartIndex = preStartIndex;
tokenEndIndex = bufferLength;
findStartIndex = bufferLength;
matcher.region(tokenStartIndex, tokenEndIndex);
setSuccess = true;
}
// If the first delimiter of scanner is not at the find start position
if (-1 != findIndex && preStartIndex != matcher.start()) {
tokenStartIndex = preStartIndex;
tokenEndIndex = matcher.start();
findStartIndex = matcher.start();
// set match region and return
matcher.region(tokenStartIndex, tokenEndIndex);
setSuccess = true;
}
return setSuccess;
|
| private boolean | setTokenRegion()
// The position where token begins
int tokenStartIndex = 0;
// The position where token ends
int tokenEndIndex = 0;
// Use delimiter pattern
matcher.usePattern(delimiter);
matcher.region(findStartIndex, bufferLength);
tokenStartIndex = findPreDelimiter();
if (setHeadTokenRegion(tokenStartIndex)) {
return true;
}
tokenEndIndex = findPostDelimiter();
// If the second delimiter is not found
if (-1 == tokenEndIndex) {
// Just first Delimiter Exists
if (findStartIndex == bufferLength) {
return false;
}
tokenEndIndex = bufferLength;
findStartIndex = bufferLength;
}
matcher.region(tokenStartIndex, tokenEndIndex);
return true;
|
| public java.util.Scanner | skip(java.util.regex.Pattern pattern)Tries to use specified pattern to match input starting from the current position.
The delimiter will be ignored. If a match is found, the matched input will be
skipped. If an anchored match of the specified pattern succeeds, the corresponding input
will also be skipped. Otherwise, a {@code NoSuchElementException} will be thrown.
Patterns that can match a lot of input may cause the {@code Scanner} to read
in a large amount of input.
checkClosed();
checkNull(pattern);
matcher.usePattern(pattern);
matcher.region(findStartIndex, bufferLength);
while (true) {
if (matcher.lookingAt()) {
boolean matchInBuffer = matcher.end() < bufferLength
|| (matcher.end() == bufferLength && inputExhausted);
if (matchInBuffer) {
matchSuccessful = true;
findStartIndex = matcher.end();
break;
}
} else {
if (inputExhausted) {
matchSuccessful = false;
throw new NoSuchElementException();
}
}
if (!inputExhausted) {
readMore();
resetMatcher();
}
}
return this;
|
| public java.util.Scanner | skip(java.lang.String pattern)Tries to use the specified string to construct a pattern and then uses
the constructed pattern to match input starting from the current position. The
delimiter will be ignored. This call is the same as invoke
{@code skip(Pattern.compile(pattern))}.
return skip(Pattern.compile(pattern));
|
| public java.lang.String | toString()Returns a string representation of this {@code Scanner}. The information
returned may be helpful for debugging. The format of the string is unspecified.
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(this.getClass()).append(": ") //$NON-NLS-1$
.append("{(delimiter:") //$NON-NLS-1$
.append(delimiter).append(")(findStartIndex=") //$NON-NLS-1$
.append(findStartIndex).append(")(match succeed=") //$NON-NLS-1$
.append(matchSuccessful).append(")(closed=") //$NON-NLS-1$
.append(closed).append(")}"); //$NON-NLS-1$
return stringBuilder.toString();
|
| public java.util.Scanner | useDelimiter(java.util.regex.Pattern pattern)Sets the delimiting pattern of this {@code Scanner}.
delimiter = pattern;
return this;
|
| public java.util.Scanner | useDelimiter(java.lang.String pattern)Sets the delimiting pattern of this {@code Scanner} with a pattern compiled from
the supplied string value.
return useDelimiter(Pattern.compile(pattern));
|
| public java.util.Scanner | useLocale(java.util.Locale l)Sets the {@code Locale} of this {@code Scanner} to a specified {@code Locale}.
if (null == l) {
throw new NullPointerException();
}
this.locale = l;
return this;
|
| public java.util.Scanner | useRadix(int radix)Sets the radix of this {@code Scanner} to the specified radix.
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
throw new IllegalArgumentException(org.apache.harmony.luni.util.Msg
.getString("KA008", radix)); //$NON-NLS-1$
}
this.integerRadix = radix;
return this;
|
