/** * 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); }
public static long parseLong(String s) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = s.length(); if (length <= 9) { return (long) parseInt(s); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(s); }
/** * 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); }
public static long parseLong(String s) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = s.length(); if (length <= 9) { return (long) parseInt(s); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(s); }
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); }
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); }
/** * @since 2.9 */ protected final int _parseIntPrimitive(DeserializationContext ctxt, String text) throws IOException { try { if (text.length() > 9) { long l = Long.parseLong(text); if (_intOverflow(l)) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "Overflow: numeric value (%s) out of range of int (%d -%d)", text, Integer.MIN_VALUE, Integer.MAX_VALUE); return _nonNullNumber(v).intValue(); } return (int) l; } return NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid int value"); return _nonNullNumber(v).intValue(); } }
return Integer.valueOf(NumberInput.parseInt(text)); } catch (IllegalArgumentException iae) { return (Integer) ctxt.handleWeirdStringValue(_valueClass, text,
int value; try { value = NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { return (Short) ctxt.handleWeirdStringValue(_valueClass, text,
int value; try { value = NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { return (Byte) ctxt.handleWeirdStringValue(_valueClass, text,
public static long parseLong(String s) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = s.length(); if (length <= 9) { return (long) parseInt(s); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(s); }
public static long parseLong(String s) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = s.length(); if (length <= 9) { return (long) parseInt(s); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(s); }
public static long parseLong(String s) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = s.length(); if (length <= 9) { return (long) parseInt(s); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(s); }
public final static long parseLong(String str) { /* Ok, now; as the very first thing, let's just optimize case of "fake longs"; * that is, if we know they must be ints, call int parsing */ int length = str.length(); if (length <= 9) { return (long) parseInt(str); } // !!! TODO: implement efficient 2-int parsing... return Long.parseLong(str); }