Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.deser.std;
  
  import java.util.*;
  
  
Deserializer implementation that is used if it is necessary to bind content of "unknown" type; something declared as basic java.lang.Object (either explicitly, or due to type erasure). If so, "natural" mapping is used to convert JSON values to their natural Java object matches: JSON arrays to Java java.util.Lists (or, if configured, Object[]), JSON objects to java.util.Maps, numbers to java.lang.Numbers, booleans to java.lang.Booleans and strings to java.lang.String (and nulls to nulls).
 
     extends StdDeserializer<Object>
 {
     private final static Object[] NO_OBJECTS = new Object[0];
     
     public UntypedObjectDeserializer() { super(Object.class); }
 
     /*
     /**********************************************************
     /* Deserializer API
     /**********************************************************
      */
     
     @Override
     public Object deserialize(JsonParser jpDeserializationContext ctxt)
         throws IOExceptionJsonProcessingException
     {
         switch (jp.getCurrentToken()) {
         case :
             return mapObject(jpctxt);
         case // invalid
             break;
         case :
             return mapArray(jpctxt);
         case // invalid
             break;
         case :
             return mapObject(jpctxt);
         case :
             return jp.getEmbeddedObject();
         case :
             return jp.getText();
 
         case :
             /* [JACKSON-100]: caller may want to get all integral values
              * returned as BigInteger, for consistency
              */
             if (ctxt.isEnabled(.)) {
                 return jp.getBigIntegerValue(); // should be optimal, whatever it is
             }
             return jp.getNumberValue(); // should be optimal, whatever it is
 
         case :
             /* [JACKSON-72]: need to allow overriding the behavior regarding
              *   which type to use
              */
             if (ctxt.isEnabled(.)) {
                 return jp.getDecimalValue();
             }
             return Double.valueOf(jp.getDoubleValue());
 
         case :
             return .;
         case :
             return .;
 
         case // should not get this but...
             return null;
             
          }
 
         throw ctxt.mappingException(Object.class);
     }
 
     @Override
             TypeDeserializer typeDeserializer)
         throws IOExceptionJsonProcessingException
     {
         JsonToken t = jp.getCurrentToken();
         switch (t) {
         // First: does it look like we had type id wrapping of some kind?
         case :
         case :
         case :
            /* Output can be as JSON Object, Array or scalar: no way to know
             * a this point:
             */
            return typeDeserializer.deserializeTypedFromAny(jpctxt);
        /* Otherwise we probably got a "native" type (ones that map
         * naturally and thus do not need or use type ids)
         */
        case :
            return jp.getText();
        case :
            // For [JACKSON-100], see above:
            if (ctxt.isEnabled(.)) {
                return jp.getBigIntegerValue();
            }
            /* and as per [JACKSON-839], allow "upgrade" to bigger types: out-of-range
             * entries can not be produced without type, so this should "just work",
             * even if it is bit unclean
             */
            return jp.getNumberValue();
        case :
            // For [JACKSON-72], see above
            if (ctxt.isEnabled(.)) {
                return jp.getDecimalValue();
            }
            return Double.valueOf(jp.getDoubleValue());
        case :
            return .;
        case :
            return .;
        case :
            return jp.getEmbeddedObject();
        case // should not get this far really but...
            return null;
        }
        throw ctxt.mappingException(Object.class);
    }
    /*
    /**********************************************************
    /* Internal methods
    /**********************************************************
     */
    
    
Method called to map a JSON Array into a Java value.
    protected Object mapArray(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
            return mapArrayToArray(jpctxt);
        }
        // Minor optimization to handle small lists (default size for ArrayList is 10)
        if (jp.nextToken()  == .) {
            return new ArrayList<Object>(4);
        }
        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
        Object[] values = buffer.resetAndStart();
        int ptr = 0;
        int totalSize = 0;
        do {
            Object value = deserialize(jpctxt);
            ++totalSize;
            if (ptr >= values.length) {
                values = buffer.appendCompletedChunk(values);
                ptr = 0;
            }
            values[ptr++] = value;
        } while (jp.nextToken() != .);
        // let's create almost full array, with 1/8 slack
        ArrayList<Objectresult = new ArrayList<Object>(totalSize + (totalSize >> 3) + 1);
        buffer.completeAndClearBuffer(valuesptrresult);
        return result;
    }

    
Method called to map a JSON Object into a Java value.
    protected Object mapObject(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        JsonToken t = jp.getCurrentToken();
        if (t == .) {
            t = jp.nextToken();
        }
        // 1.6: minor optimization; let's handle 1 and 2 entry cases separately
        if (t != .) { // and empty one too
            // empty map might work; but caller may want to modify... so better just give small modifiable
            return new LinkedHashMap<String,Object>(4);
        }
        String field1 = jp.getText();
        jp.nextToken();
        Object value1 = deserialize(jpctxt);
        if (jp.nextToken() != .) { // single entry; but we want modifiable
            LinkedHashMap<StringObjectresult = new LinkedHashMap<StringObject>(4);
            result.put(field1value1);
            return result;
        }
        String field2 = jp.getText();
        jp.nextToken();
        Object value2 = deserialize(jpctxt);
        if (jp.nextToken() != .) {
            LinkedHashMap<StringObjectresult = new LinkedHashMap<StringObject>(4);
            result.put(field1value1);
            result.put(field2value2);
            return result;
        }
        // And then the general case; default map size is 16
        LinkedHashMap<StringObjectresult = new LinkedHashMap<StringObject>();
        result.put(field1value1);
        result.put(field2value2);
        do {
            String fieldName = jp.getText();
            jp.nextToken();
            result.put(fieldNamedeserialize(jpctxt));
        } while (jp.nextToken() != .);
        return result;
    }

    
Method called to map a JSON Array into a Java Object array (Object[]).
    protected Object[] mapArrayToArray(JsonParser jpDeserializationContext ctxt)
        throws IOExceptionJsonProcessingException
    {
        // Minor optimization to handle small lists (default size for ArrayList is 10)
        if (jp.nextToken()  == .) {
            return ;
        }
        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
        Object[] values = buffer.resetAndStart();
        int ptr = 0;
        do {
            Object value = deserialize(jpctxt);
            if (ptr >= values.length) {
                values = buffer.appendCompletedChunk(values);
                ptr = 0;
            }
            values[ptr++] = value;
        } while (jp.nextToken() != .);
        return buffer.completeAndClearBuffer(valuesptr);
    }
New to GrepCode? Check out our FAQ X