ConvertDouble.DoubleConverter

java.lang.Object
- org.jruby.util.ConvertDouble.DoubleConverter

Enclosing class:: ConvertDouble

public static class ConvertDouble.DoubleConverter
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`adjustExponent`
`private byte[]`	`bytes`
`private char[]`	`chars`
`private int`	`charsIndex`
`private int`	`endIndex`
`private static int`	`EXPONENT_DIGITS_LIMIT`
`private int`	`index`
`private boolean`	`is19`
`private boolean`	`isStrict`
`private static int`	`MAX_EXPONENT`
`private static int`	`MAX_LENGTH`
`private double`	`result`
`private static int`	`SIGNIFICANT_DIGITS_LIMIT`
`private int`	`significantDigitsProcessed`
`private boolean`	`wroteExponent`

Constructor Summary

Constructors
Constructor and Description

DoubleConverter()

Constructors
Constructor and Description
`DoubleConverter()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addExponentToResult(int exponent)`
`private void`	`addToResult(byte b)`
`private double`	`completeCalculation()`
`private boolean`	`eatUnderscores()`
`void`	`init(org.jruby.util.ByteList list, boolean isStrict, boolean is19)`
`private boolean`	`isDigit(byte b)`
`private boolean`	`isEOS()`
`private boolean`	`isExponent(byte b)`
`private boolean`	`isWhitespace(byte b)`
`private byte`	`next()`
`double`	`parse(org.jruby.util.ByteList list, boolean strict, boolean is19)`
`private boolean`	`parseDecimalDigits()`
`private boolean`	`parseDigits()`
`private boolean`	`parseExponent()`
`private boolean`	`parseOptionalSign()`
`private boolean`	`previous()` Shift back to previous character in the incoming bytes
`private boolean`	`skipWhitespace()` Consume initial whitespace and underscores so that next character examined is not whitespace.
`private boolean`	`stopParsing()`
`private boolean`	`strictError()`
`private boolean`	`tooLargeExponent(boolean negativeFloat, boolean negativeExponent)`
`private void`	`verifyNumberAfterUnderscore()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

bytes
```
private byte[] bytes
```

index
```
private int index
```

endIndex
```
private int endIndex
```

isStrict
```
private boolean isStrict
```

is19
```
private boolean is19
```

chars
```
private char[] chars
```

charsIndex
```
private int charsIndex
```

significantDigitsProcessed
```
private int significantDigitsProcessed
```

adjustExponent
```
private int adjustExponent
```

wroteExponent
```
private boolean wroteExponent
```

result
```
private double result
```

SIGNIFICANT_DIGITS_LIMIT
```
private static final int SIGNIFICANT_DIGITS_LIMIT
```
See Also:

Constant Field Values

EXPONENT_DIGITS_LIMIT
```
private static final int EXPONENT_DIGITS_LIMIT
```
See Also:

Constant Field Values

MAX_EXPONENT
```
private static final int MAX_EXPONENT
```

MAX_LENGTH
```
private static final int MAX_LENGTH
```
See Also:

Constant Field Values

Constructor Detail
- DoubleConverter
```
public DoubleConverter()
```

Method Detail

init

public void init(org.jruby.util.ByteList list,
                 boolean isStrict,
                 boolean is19)

next
```
private byte next()
```

previous
```
private boolean previous()
```
Shift back to previous character in the incoming bytes

Returns:

false to indicate we are not in an EOS condition

isEOS
```
private boolean isEOS()
```

stopParsing
```
private boolean stopParsing()
```

isDigit
```
private boolean isDigit(byte b)
```

isExponent
```
private boolean isExponent(byte b)
```

isWhitespace
```
private boolean isWhitespace(byte b)
```

addToResult
```
private void addToResult(byte b)
```

addExponentToResult

private void addExponentToResult(int exponent)

eatUnderscores
```
private boolean eatUnderscores()
```

completeCalculation
```
private double completeCalculation()
```

strictError
```
private boolean strictError()
```

parse

public double parse(org.jruby.util.ByteList list,
                    boolean strict,
                    boolean is19)

skipWhitespace
```
private boolean skipWhitespace()
```
Consume initial whitespace and underscores so that next character examined is not whitespace. 1.9 and strict do not allow leading underscores. Returns whether next position is at the end of the string or not. Trivia: " _ _ _ _ 1".to_f == 1.0 in Ruby 1.8

parseOptionalSign
```
private boolean parseOptionalSign()
```

parseDigits
```
private boolean parseDigits()
```

parseDecimalDigits
```
private boolean parseDecimalDigits()
```

parseExponent
```
private boolean parseExponent()
```

tooLargeExponent

private boolean tooLargeExponent(boolean negativeFloat,
                                 boolean negativeExponent)

verifyNumberAfterUnderscore

private void verifyNumberAfterUnderscore()

Class ConvertDouble.DoubleConverter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

bytes

index

endIndex

isStrict

is19

chars

charsIndex

significantDigitsProcessed

adjustExponent

wroteExponent

result

SIGNIFICANT_DIGITS_LIMIT

EXPONENT_DIGITS_LIMIT

MAX_EXPONENT

MAX_LENGTH

Constructor Detail

DoubleConverter

Method Detail

init

next

previous

isEOS

stopParsing

isDigit

isExponent

isWhitespace

addToResult

addExponentToResult

eatUnderscores

completeCalculation

strictError

parse

skipWhitespace

parseOptionalSign

parseDigits

parseDecimalDigits

parseExponent

tooLargeExponent

verifyNumberAfterUnderscore