Java NumberInput.parseInt方法代码示例

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
private final static int _parseIndex(String str) {
    final int len = str.length();
    // [core#133]: beware of super long indexes; assume we never
    // have arrays over 2 billion entries so ints are fine.
    if (len == 0 || len > 10) {
        return -1;
    }
    // [core#176]: no leading zeroes allowed
    char c = str.charAt(0);
    if (c <= '0') {
        return (len == 1 && c == '0') ? 0 : -1;
    }
    if (c > '9') {
        return -1;
    }
    for (int i = 1; i < len; ++i) {
        c = str.charAt(i);
        if (c > '9' || c < '0') {
            return -1;
        }
    }
    if (len == 10) {
        long l = NumberInput.parseLong(str);
        if (l > Integer.MAX_VALUE) {
            return -1;
        }
    }
    return NumberInput.parseInt(str);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
/**
 * Specialized convenience method that will decode a 32-bit int,
 * of at most 9 digits (and possible leading minus sign).
 *
 * @param neg Whether contents start with a minus sign
 *
 * @since 2.9
 */
public int contentsAsInt(boolean neg) {
    if ((_inputStart >= 0) && (_inputBuffer != null)) {
        if (neg) {
            return -NumberInput.parseInt(_inputBuffer, _inputStart+1, _inputLen-1);
        }
        return NumberInput.parseInt(_inputBuffer, _inputStart, _inputLen);
    }
    if (neg) {
        return -NumberInput.parseInt(_currentSegment, 1, _currentSize-1);
    }
    return NumberInput.parseInt(_currentSegment, 0, _currentSize);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
@Override
protected Byte _parseByte(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonToken t = jp.getCurrentToken();
    Integer value = null;
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        value = jp.getIntValue();
    }
    else if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = jp.getText().trim();
        try {
            int len = text.length();
            if (len == 0) {
                return getEmptyValue();
            }
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            throw ctxt.weirdStringException(_valueClass, "not a valid Byte value");//NOSONAR
        }
    }
    if (value != null) {
        // So far so good: but does it fit?
        if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
            throw ctxt.weirdStringException(_valueClass, "overflow, value can not be represented as 8-bit value");
        }
        return (byte) (int) value;
    }
    if (t == JsonToken.VALUE_NULL) {
        return getNullValue();
    }
    throw ctxt.mappingException(_valueClass, t);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
protected Byte _parseByte(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    JsonToken t = jp.getCurrentToken();
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        return jp.getByteValue();
    }
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = jp.getText().trim();
        int value;
        try {
            int len = text.length();
            if (len == 0) {
                return (Byte) getEmptyValue();
            }
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            throw ctxt.weirdStringException(text, _valueClass, "not a valid Byte value");
        }
        // So far so good: but does it fit?
        // as per [JACKSON-804], allow range up to 255, inclusive
        if (value < Byte.MIN_VALUE || value > 255) {
            throw ctxt.weirdStringException(text, _valueClass, "overflow, value can not be represented as 8-bit value");
        }
        return Byte.valueOf((byte) value);
    }
    if (t == JsonToken.VALUE_NULL) {
        return (Byte) getNullValue();
    }
    throw ctxt.mappingException(_valueClass, t);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
protected Short _parseShort(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    JsonToken t = jp.getCurrentToken();
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        return jp.getShortValue();
    }
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = jp.getText().trim();
        int value;
        try {
            int len = text.length();
            if (len == 0) {
                return (Short) getEmptyValue();
            }
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            throw ctxt.weirdStringException(text, _valueClass, "not a valid Short value");
        }
        // So far so good: but does it fit?
        if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
            throw ctxt.weirdStringException(text, _valueClass, "overflow, value can not be represented as 16-bit value");
        }
        return Short.valueOf((short) value);
    }
    if (t == JsonToken.VALUE_NULL) {
        return (Short) getNullValue();
    }
    throw ctxt.mappingException(_valueClass, t);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
protected final int _parseIntPrimitive(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    JsonToken t = jp.getCurrentToken();

    // Int works as is, coercing fine as well
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        return jp.getIntValue();
    }
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        /* 31-Dec-2009, tatus: Should improve handling of overflow
         *   values... but this'll have to do for now
         */
        String text = jp.getText().trim();
        try {
            int len = text.length();
            if (len > 9) {
                long l = Long.parseLong(text);
                if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
                    throw ctxt.weirdStringException(text, _valueClass,
                        "Overflow: numeric value ("+text+") out of range of int ("+Integer.MIN_VALUE+" - "+Integer.MAX_VALUE+")");
                }
                return (int) l;
            }
            if (len == 0) {
                return 0;
            }
            return NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            throw ctxt.weirdStringException(text, _valueClass, "not a valid int value");
        }
    }
    if (t == JsonToken.VALUE_NULL) {
        return 0;
    }
    // Otherwise, no can do:
    throw ctxt.mappingException(_valueClass, t);
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
/**
 * Method that will parse actual numeric value out of a syntactically
 * valid number value. Type it will parse into depends on whether
 * it is a floating point number, as well as its magnitude: smallest
 * legal type (of ones available) is used for efficiency.
 *
 * @param expType Numeric type that we will immediately need, if any;
 *   mostly necessary to optimize handling of floating point numbers
 */
protected void _parseNumericValue(int expType)
    throws IOException, JsonParseException
{
    // Int or float?
    if (_currToken == JsonToken.VALUE_NUMBER_INT) {
        char[] buf = _textBuffer.getTextBuffer();
        int offset = _textBuffer.getTextOffset();
        int len = _intLength;
        if (_numberNegative) {
            ++offset;
        }
        if (len <= 9) { // definitely fits in int
            int i = NumberInput.parseInt(buf, offset, len);
            _numberInt = _numberNegative ? -i : i;
            _numTypesValid = NR_INT;
            return;
        }
        if (len <= 18) { // definitely fits AND is easy to parse using 2 int parse calls
            long l = NumberInput.parseLong(buf, offset, len);
            if (_numberNegative) {
                l = -l;
            }
            // [JACKSON-230] Could still fit in int, need to check
            if (len == 10) {
                if (_numberNegative) {
                    if (l >= MIN_INT_L) {
                        _numberInt = (int) l;
                        _numTypesValid = NR_INT;
                        return;
                    }
                } else {
                    if (l <= MAX_INT_L) {
                        _numberInt = (int) l;
                        _numTypesValid = NR_INT;
                        return;
                    }
                }
            }
            _numberLong = l;
            _numTypesValid = NR_LONG;
            return;
        }
        _parseSlowInt(expType, buf, offset, len);
        return;
    }
    if (_currToken == JsonToken.VALUE_NUMBER_FLOAT) {
        _parseSlowFloat(expType);
        return;
    }
    _reportError("Current token ("+_currToken+") not numeric, can not use numeric value accessors");
}
 

import com.fasterxml.jackson.core.io.NumberInput; //导入方法依赖的package包/类
/**
 * Method that will parse actual numeric value out of a syntactically
 * valid number value. Type it will parse into depends on whether
 * it is a floating point number, as well as its magnitude: smallest
 * legal type (of ones available) is used for efficiency.
 *
 * @param expType Numeric type that we will immediately need, if any;
 *   mostly necessary to optimize handling of floating point numbers
 */
protected void _parseNumericValue(int expType)
    throws IOException, JsonParseException
{
    // Int or float?
    if (_currToken == JsonToken.VALUE_NUMBER_INT) {
        char[] buf = _textBuffer.getTextBuffer();
        int offset = _textBuffer.getTextOffset();
        int len = _intLength;
        if (_numberNegative) {
            ++offset;
        }
        if (len <= 9) { // definitely fits in int
            int i = NumberInput.parseInt(buf, offset, len);
            _numberInt = _numberNegative ? -i : i;
            _numTypesValid = NR_INT;
            return;
        }
        if (len <= 18) { // definitely fits AND is easy to parse using 2 int parse calls
            long l = NumberInput.parseLong(buf, offset, len);
            if (_numberNegative) {
                l = -l;
            }
            // [JACKSON-230] Could still fit in int, need to check
            if (len == 10) {
                if (_numberNegative) {
                    if (l >= MIN_INT_L) {
                        _numberInt = (int) l;
                        _numTypesValid = NR_INT;
                        return;
                    }
                } else {
                    if (l <= MAX_INT_L) {
                        _numberInt = (int) l;
                        _numTypesValid = NR_INT;
                        return;
                    }
                }
            }
            _numberLong = l;
            _numTypesValid = NR_LONG;
            return;
        }
        _parseSlowIntValue(expType, buf, offset, len);
        return;
    }
    if (_currToken == JsonToken.VALUE_NUMBER_FLOAT) {
        _parseSlowFloatValue(expType);
        return;
    }
    _reportError("Current token ("+_currToken+") not numeric, can not use numeric value accessors");
}