Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.deser.std;
  
  import java.util.*;
  
  
Base class for common deserializers. Contains shared base functionality for dealing with primitive values, such as (re)parsing from String.
 
 public abstract class StdDeserializer<T>
     extends JsonDeserializer<T>
     implements java.io.Serializable
 {
     private static final long serialVersionUID = 1L;

    
Type of values this deserializer handles: sometimes exact types, other time most specific supertype of types deserializer handles (which may be as generic as java.lang.Object in some case)
 
     final protected Class<?> _valueClass;
 
     protected StdDeserializer(Class<?> vc) {
          = vc;
     }
 
     protected StdDeserializer(JavaType valueType) {
          = (valueType == null) ? null : valueType.getRawClass();
     }
     
     /*
     /**********************************************************
     /* Extended API
     /**********************************************************
      */
 
     public Class<?> getValueClass() { return ; }

    
Exact structured type deserializer handles, if known.

Default implementation just returns null.

 
     public JavaType getValueType() { return null; }

    
Method that can be called to determine if given deserializer is the default deserializer Jackson uses; as opposed to a custom deserializer installed by a module or calling application. Determination is done using com.fasterxml.jackson.databind.annotation.JacksonStdImpl annotation on deserializer class.
 
     protected boolean isDefaultDeserializer(JsonDeserializer<?> deserializer) {
         return (deserializer != null && deserializer.getClass().getAnnotation(JacksonStdImpl.class) != null);
     }
 
     protected boolean isDefaultKeyDeserializer(KeyDeserializer keyDeser) {
         return (keyDeser != null && keyDeser.getClass().getAnnotation(JacksonStdImpl.class) != null);
     }
     
     /*
     /**********************************************************
     /* Partial JsonDeserializer implementation 
     /**********************************************************
      */
    
    
Base implementation that does not assume specific type inclusion mechanism. Sub-classes are expected to override this method if they are to handle type information.
 
     @Override
             TypeDeserializer typeDeserializer)
         throws IOExceptionJsonProcessingException
     {
         return typeDeserializer.deserializeTypedFromAny(jpctxt);
     }
     
     /*
     /**********************************************************
     /* Helper methods for sub-classes, parsing: while mostly
     /* useful for numeric types, can be also useful for dealing
     /* with things serialized as numbers (such as Dates).
     /**********************************************************
      */
 
     protected final boolean _parseBooleanPrimitive(JsonParser jpDeserializationContext ctxt)
         throws IOExceptionJsonProcessingException
     {
        JsonToken t = jp.getCurrentToken();
        if (t == .) {
            return true;
        }
        if (t == .) {
            return false;
        }
        if (t == .) {
            return false;
        }
        // [JACKSON-78]: should accept ints too, (0 == false, otherwise true)
        if (t == .) {
            // 11-Jan-2012, tatus: May be outside of int...
            if (jp.getNumberType() == .) {
                return (jp.getIntValue() != 0);
            }
            return _parseBooleanFromNumber(jpctxt);
        }
        // And finally, let's allow Strings to be converted too
        if (t == .) {
            String text = jp.getText().trim();
            if ("true".equals(text)) {
                return true;
            }
            if ("false".equals(text) || text.length() == 0) {
                return .;
            }
            throw ctxt.weirdStringException(text"only \"true\" or \"false\" recognized");
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final Boolean _parseBoolean(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == .) {
            return .;
        }
        if (t == .) {
            return .;
        }
        // [JACKSON-78]: should accept ints too, (0 == false, otherwise true)
        if (t == .) {
            // 11-Jan-2012, tatus: May be outside of int...
            if (jp.getNumberType() == .) {
                return (jp.getIntValue() == 0) ? . : .;
            }
            return Boolean.valueOf(_parseBooleanFromNumber(jpctxt));
        }
        if (t == .) {
            return (BooleangetNullValue();
        }
        // And finally, let's allow Strings to be converted too
        if (t == .) {
            String text = jp.getText().trim();
            if ("true".equals(text)) {
                return .;
            }
            if ("false".equals(text)) {
                return .;
            }
            if (text.length() == 0) {
                return (BooleangetEmptyValue();
            }
            throw ctxt.weirdStringException(text"only \"true\" or \"false\" recognized");
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final boolean _parseBooleanFromNumber(JsonParser jpDeserializationContext ctxt)
            throws IOExceptionJsonProcessingException
    {
        if (jp.getNumberType() == .) {
            return (jp.getLongValue() == 0L) ? . : .;
        }
        // no really good logic; let's actually resort to textual comparison
        String str = jp.getText();
        if ("0.0".equals(str) || "0".equals(str)) {
            return .;
        }
        return .;
    }
    protected Byte _parseByte(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == . || t == .) { // coercing should work too
            return jp.getByteValue();
        }
        if (t == .) { // let's do implicit re-parse
            String text = jp.getText().trim();
            int value;
            try {
                int len = text.length();
                if (len == 0) {
                    return (BytegetEmptyValue();
                }
                value = NumberInput.parseInt(text);
            } catch (IllegalArgumentException iae) {
                throw ctxt.weirdStringException(text"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 < . || value > 255) {
                throw ctxt.weirdStringException(text"overflow, value can not be represented as 8-bit value");
            }
            return Byte.valueOf((bytevalue);
        }
        if (t == .) {
            return (BytegetNullValue();
        }
        throw ctxt.mappingException(t);
    }
    
    protected Short _parseShort(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == . || t == .) { // coercing should work too
            return jp.getShortValue();
        }
        if (t == .) { // let's do implicit re-parse
            String text = jp.getText().trim();
            int value;
            try {
                int len = text.length();
                if (len == 0) {
                    return (ShortgetEmptyValue();
                }
                value = NumberInput.parseInt(text);
            } catch (IllegalArgumentException iae) {
                throw ctxt.weirdStringException(text"not a valid Short value");
            }
            // So far so good: but does it fit?
            if (value < . || value > .) {
                throw ctxt.weirdStringException(text"overflow, value can not be represented as 16-bit value");
            }
            return Short.valueOf((shortvalue);
        }
        if (t == .) {
            return (ShortgetNullValue();
        }
        throw ctxt.mappingException(t);
    }
    protected final short _parseShortPrimitive(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        int value = _parseIntPrimitive(jpctxt);
        // So far so good: but does it fit?
        if (value < . || value > .) {
            throw ctxt.weirdStringException(String.valueOf(value),
                    "overflow, value can not be represented as 16-bit value");
        }
        return (shortvalue;
    }
    
    protected final int _parseIntPrimitive(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        // Int works as is, coercing fine as well
        if (t == . || t == .) { // coercing should work too
            return jp.getIntValue();
        }
        if (t == .) { // 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 < . || l > .) {
                        throw ctxt.weirdStringException(text,
                            "Overflow: numeric value ("+text+") out of range of int ("+.+" - "+.+")");
                    }
                    return (intl;
                }
                if (len == 0) {
                    return 0;
                }
                return NumberInput.parseInt(text);
            } catch (IllegalArgumentException iae) {
                throw ctxt.weirdStringException(text"not a valid int value");
            }
        }
        if (t == .) {
            return 0;
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final Integer _parseInteger(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == . || t == .) { // coercing should work too
            return Integer.valueOf(jp.getIntValue());
        }
        if (t == .) { // let's do implicit re-parse
            String text = jp.getText().trim();
            try {
                int len = text.length();
                if (len > 9) {
                    long l = Long.parseLong(text);
                    if (l < . || l > .) {
                        throw ctxt.weirdStringException(text,
                            "Overflow: numeric value ("+text+") out of range of Integer ("+.+" - "+.+")");
                    }
                    return Integer.valueOf((intl);
                }
                if (len == 0) {
                    return (IntegergetEmptyValue();
                }
                return Integer.valueOf(NumberInput.parseInt(text));
            } catch (IllegalArgumentException iae) {
                throw ctxt.weirdStringException(text"not a valid Integer value");
            }
        }
        if (t == .) {
            return (IntegergetNullValue();
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final Long _parseLong(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
    
        // it should be ok to coerce (although may fail, too)
        if (t == . || t == .) {
            return jp.getLongValue();
        }
        // let's allow Strings to be converted too
        if (t == .) {
            // !!! 05-Jan-2009, tatu: Should we try to limit value space, JDK is too lenient?
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return (LonggetEmptyValue();
            }
            try {
                return Long.valueOf(NumberInput.parseLong(text));
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid Long value");
        }
        if (t == .) {
            return (LonggetNullValue();
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final long _parseLongPrimitive(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == . || t == .) {
            return jp.getLongValue();
        }
        if (t == .) {
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return 0L;
            }
            try {
                return NumberInput.parseLong(text);
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid long value");
        }
        if (t == .) {
            return 0L;
        }
        throw ctxt.mappingException(t);
    }
    
    protected final Float _parseFloat(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        // We accept couple of different types; obvious ones first:
        JsonToken t = jp.getCurrentToken();
        
        if (t == . || t == .) { // coercing should work too
            return jp.getFloatValue();
        }
        // And finally, let's allow Strings to be converted too
        if (t == .) {
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return (FloatgetEmptyValue();
            }
            switch (text.charAt(0)) {
            case 'I':
                if ("Infinity".equals(text) || "INF".equals(text)) {
                    return .;
                }
                break;
            case 'N':
                if ("NaN".equals(text)) {
                    return .;
                }
                break;
            case '-':
                if ("-Infinity".equals(text) || "-INF".equals(text)) {
                    return .;
                }
                break;
            }
            try {
                return Float.parseFloat(text);
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid Float value");
        }
        if (t == .) {
            return (FloatgetNullValue();
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final float _parseFloatPrimitive(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        
        if (t == . || t == .) { // coercing should work too
            return jp.getFloatValue();
        }
        if (t == .) {
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return 0.0f;
            }
            switch (text.charAt(0)) {
            case 'I':
                if ("Infinity".equals(text) || "INF".equals(text)) {
                    return .;
                }
                break;
            case 'N':
                if ("NaN".equals(text)) {
                    return .;
                }
                break;
            case '-':
                if ("-Infinity".equals(text) || "-INF".equals(text)) {
                    return .;
                }
                break;
            }
            try {
                return Float.parseFloat(text);
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid float value");
        }
        if (t == .) {
            return 0.0f;
        }
        // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final Double _parseDouble(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        
        if (t == . || t == .) { // coercing should work too
            return jp.getDoubleValue();
        }
        if (t == .) {
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return (DoublegetEmptyValue();
            }
            switch (text.charAt(0)) {
            case 'I':
                if ("Infinity".equals(text) || "INF".equals(text)) {
                    return .;
                }
                break;
            case 'N':
                if ("NaN".equals(text)) {
                    return .;
                }
                break;
            case '-':
                if ("-Infinity".equals(text) || "-INF".equals(text)) {
                    return .;
                }
                break;
            }
            try {
                return parseDouble(text);
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid Double value");
        }
        if (t == .) {
            return (DoublegetNullValue();
        }
            // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected final double _parseDoublePrimitive(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        // We accept couple of different types; obvious ones first:
        JsonToken t = jp.getCurrentToken();
        
        if (t == . || t == .) { // coercing should work too
            return jp.getDoubleValue();
        }
        // And finally, let's allow Strings to be converted too
        if (t == .) {
            String text = jp.getText().trim();
            if (text.length() == 0) {
                return 0.0;
            }
            switch (text.charAt(0)) {
            case 'I':
                if ("Infinity".equals(text) || "INF".equals(text)) {
                    return .;
                }
                break;
            case 'N':
                if ("NaN".equals(text)) {
                    return .;
                }
                break;
            case '-':
                if ("-Infinity".equals(text) || "-INF".equals(text)) {
                    return .;
                }
                break;
            }
            try {
                return parseDouble(text);
            } catch (IllegalArgumentException iae) { }
            throw ctxt.weirdStringException(text"not a valid double value");
        }
        if (t == .) {
            return 0.0;
        }
            // Otherwise, no can do:
        throw ctxt.mappingException(t);
    }
    protected java.util.Date _parseDate(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == .) {
            return new java.util.Date(jp.getLongValue());
        }
        if (t == .) {
            return (java.util.DategetNullValue();
        }
        if (t == .) {
            String value = null;
            try {
                // As per [JACKSON-203], take empty Strings to mean
                value = jp.getText().trim();
                if (value.length() == 0) {
                    return (DategetEmptyValue();
                }
                return ctxt.parseDate(value);
            } catch (IllegalArgumentException iae) {
                throw ctxt.weirdStringException(value,
                        "not a valid representation (error: "+iae.getMessage()+")");
            }
        }
        throw ctxt.mappingException(t);
    }

    
Helper method for encapsulating calls to low-level double value parsing; single place just because we need a work-around that must be applied to all calls.
    protected final static double parseDouble(String numStrthrows NumberFormatException
    {
        // [JACKSON-486]: avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
        // for now, MIN_VALUE, since MIN_NORMAL is JDK 1.6
        if (..equals(numStr)) {
            return .;
        }
        return Double.parseDouble(numStr);
    }
    
    
Helper method used for accessing String value, if possible, doing necessary conversion or throwing exception as necessary.

Since:
2.1
    protected final String _parseString(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        String value = jp.getValueAsString();
        if (value != null) {
            return value;
        }
        throw ctxt.mappingException(String.classjp.getCurrentToken());
    }
    
    /*
    /****************************************************
    /* Helper methods for sub-classes, resolving dependencies
    /****************************************************
     */

    
Helper method used to locate deserializers for properties the type this deserializer handles contains (usually for properties of bean types)

Parameters:
type Type of property to deserialize
property Actual property object (field, method, constuctor parameter) used for passing deserialized values; provided so deserializer can be contextualized if necessary (since 1.7)
            JavaType typeBeanProperty property)
        throws JsonMappingException
    {
        return ctxt.findContextualValueDeserializer(typeproperty);
    }
    /*
    /**********************************************************
    /* Helper methods for sub-classes, problem reporting
    /**********************************************************
     */

    
Method called to deal with a property that did not map to a known Bean property. Method can deal with the problem as it sees fit (ignore, throw exception); but if it does return, it has to skip the matching Json content parser has.

NOTE: method signature was changed in version 1.5; explicit JsonParser must be passed since it may be something other than what context has. Prior versions did not include the first parameter.

Parameters:
jp Parser that points to value of the unknown property
ctxt Context for deserialization; allows access to the parser, error reporting functionality
instanceOrClass Instance that is being populated by this deserializer, or if not known, Class that would be instantiated. If null, will assume type is what getValueClass() returns.
propName Name of the property that can not be mapped
    protected void handleUnknownProperty(JsonParser jpDeserializationContext ctxt,
            Object instanceOrClassString propName)
        throws IOExceptionJsonProcessingException
    {
        if (instanceOrClass == null) {
            instanceOrClass = getValueClass();
        }
        // Maybe we have configured handler(s) to take care of it?
        if (ctxt.handleUnknownProperty(jpthisinstanceOrClasspropName)) {
            return;
        }
        // Nope, not handled. Potentially that's a problem...
        ctxt.reportUnknownProperty(instanceOrClasspropNamethis);
        /* But if we do get this far, need to skip whatever value we
         * are pointing to now.
         */
        jp.skipChildren();
    }
New to GrepCode? Check out our FAQ X