calabash-android 0.4.7.pre4 → 0.4.7.pre6

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/JavaTypeDeserializer.java

@@ -1,38 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonParser;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.JsonToken;
-import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * @since 1.9
- */
-public class JavaTypeDeserializer
-    extends StdScalarDeserializer<JavaType>
-{
-    public JavaTypeDeserializer() { super(JavaType.class); }
-    
-    @Override
-    public JavaType deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        JsonToken curr = jp.getCurrentToken();
-        // Usually should just get string value:
-        if (curr == JsonToken.VALUE_STRING) {
-            String str = jp.getText().trim();
-            if (str.length() == 0) {
-                return getEmptyValue();
-            }
-            return ctxt.getTypeFactory().constructFromCanonical(str);
-        }
-        // or occasionally just embedded object maybe
-        if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) {
-            return (JavaType) jp.getEmbeddedObject();
-        }
-        throw ctxt.mappingException(_valueClass);
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/JsonNodeDeserializer.java

@@ -1,314 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.node.*;
-
-/**
- * Deserializer that can build instances of {@link JsonNode} from any
- * JSON content, using appropriate {@link JsonNode} type.
- * 
- * @since 1.9 (moved from higher-level package)
- */
-public class JsonNodeDeserializer
-    extends BaseNodeDeserializer<JsonNode>
-{
-    /**
-     * Singleton instance of generic deserializer for {@link JsonNode}.
-     * Only used for types other than JSON Object and Array.
-     */
-    private final static JsonNodeDeserializer instance = new JsonNodeDeserializer();
-
-    protected JsonNodeDeserializer() { super(JsonNode.class); }
-
-    /**
-     * Factory method for accessing deserializer for specific node type
-     */
-    public static JsonDeserializer<? extends JsonNode> getDeserializer(Class<?> nodeClass)
-    {
-        if (nodeClass == ObjectNode.class) {
-            return ObjectDeserializer.getInstance();
-        }
-        if (nodeClass == ArrayNode.class) {
-            return ArrayDeserializer.getInstance();
-        }
-        // For others, generic one works fine
-        return instance;
-    }
-    
-    /*
-    /**********************************************************
-    /* Actual deserializer implementations
-    /**********************************************************
-     */
-
-    /**
-     * Implementation that will produce types of any JSON nodes; not just one
-     * deserializer is registered to handle (in case of more specialized handler).
-     * Overridden by typed sub-classes for more thorough checking
-     */
-    @Override
-    public JsonNode deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        switch (jp.getCurrentToken()) {
-        case START_OBJECT:
-            return deserializeObject(jp, ctxt, ctxt.getNodeFactory());
-        case START_ARRAY:
-            return deserializeArray(jp, ctxt, ctxt.getNodeFactory());
-        default:
-            return deserializeAny(jp, ctxt, ctxt.getNodeFactory());
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Specific instances for more accurate types
-    /**********************************************************
-     */
-
-    final static class ObjectDeserializer
-        extends BaseNodeDeserializer<ObjectNode>
-    {
-        protected final static ObjectDeserializer _instance = new ObjectDeserializer();
-
-        protected ObjectDeserializer() {
-            super(ObjectNode.class);
-        }
-
-        public static ObjectDeserializer getInstance() { return _instance; }
-        
-        @Override
-        public ObjectNode deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
-                jp.nextToken();
-                return deserializeObject(jp, ctxt, ctxt.getNodeFactory());
-            }
-            if (jp.getCurrentToken() == JsonToken.FIELD_NAME) {
-                return deserializeObject(jp, ctxt, ctxt.getNodeFactory());
-            }
-            throw ctxt.mappingException(ObjectNode.class);
-         }
-    }
-        
-    final static class ArrayDeserializer
-        extends BaseNodeDeserializer<ArrayNode>
-    {
-        protected final static ArrayDeserializer _instance = new ArrayDeserializer();
-
-        protected ArrayDeserializer() {
-            super(ArrayNode.class);
-        }
-
-        public static ArrayDeserializer getInstance() { return _instance; }
-        
-        @Override
-        public ArrayNode deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (jp.isExpectedStartArrayToken()) {
-                return deserializeArray(jp, ctxt, ctxt.getNodeFactory());
-            }
-            throw ctxt.mappingException(ArrayNode.class);
-        }
-    }
-}
-
-/**
- * Base class for all actual {@link JsonNode} deserializer
- * implementations
- */
-abstract class BaseNodeDeserializer<N extends JsonNode>
-    extends StdDeserializer<N>
-{
-    public BaseNodeDeserializer(Class<N> nodeClass)
-    {
-        super(nodeClass);
-    }
-    
-    @Override
-    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        /* Output can be as JSON Object, Array or scalar: no way to know
-         * a priori. So:
-         */
-        return typeDeserializer.deserializeTypedFromAny(jp, ctxt);
-    }
-
-    /*
-    /**********************************************************
-    /* Overridable methods
-    /**********************************************************
-     */
-    
-    protected void _reportProblem(JsonParser jp, String msg)
-        throws JsonMappingException
-    {
-        throw new JsonMappingException(msg, jp.getTokenLocation());
-    }
-    
-    /**
-     * Method called when there is a duplicate value for a field.
-     * By default we don't care, and the last value is used.
-     * Can be overridden to provide alternate handling, such as throwing
-     * an exception, or choosing different strategy for combining values
-     * or choosing which one to keep.
-     *
-     * @param fieldName Name of the field for which duplicate value was found
-     * @param objectNode Object node that contains values
-     * @param oldValue Value that existed for the object node before newValue
-     *   was added
-     * @param newValue Newly added value just added to the object node
-     */
-    protected void _handleDuplicateField(String fieldName, ObjectNode objectNode,
-                                         JsonNode oldValue, JsonNode newValue)
-        throws JsonProcessingException
-    {
-        // By default, we don't do anything
-        ;
-    }
-    
-    /*
-    /**********************************************************
-    /* Helper methods
-    /**********************************************************
-     */
-    
-    protected final ObjectNode deserializeObject(JsonParser jp, DeserializationContext ctxt,
-            final JsonNodeFactory nodeFactory)            
-        throws IOException, JsonProcessingException
-    {
-        ObjectNode node = nodeFactory.objectNode();
-        JsonToken t = jp.getCurrentToken();
-        if (t == JsonToken.START_OBJECT) {
-            t = jp.nextToken();
-        }
-        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
-            String fieldName = jp.getCurrentName();
-            JsonNode value;
-            switch (jp.nextToken()) {
-            case START_OBJECT:
-                value = deserializeObject(jp, ctxt, nodeFactory);
-                break;
-            case START_ARRAY:
-                value = deserializeArray(jp, ctxt, nodeFactory);
-                break;
-            case VALUE_STRING:
-                value = nodeFactory.textNode(jp.getText());
-                break;
-            default:
-                value = deserializeAny(jp, ctxt, nodeFactory);
-            }
-            JsonNode old = node.put(fieldName, value);
-            if (old != null) {
-                _handleDuplicateField(fieldName, node, old, value);
-            }
-        }
-        return node;
-    }
-    
-    protected final ArrayNode deserializeArray(JsonParser jp, DeserializationContext ctxt,
-            final JsonNodeFactory nodeFactory)            
-        throws IOException, JsonProcessingException
-    {
-        ArrayNode node = nodeFactory.arrayNode();
-        while (true) {
-            switch (jp.nextToken()) {
-            case START_OBJECT:
-                node.add(deserializeObject(jp, ctxt, nodeFactory));
-                break;
-            case START_ARRAY:
-                node.add(deserializeArray(jp, ctxt, nodeFactory));
-                break;
-            case END_ARRAY:
-                return node;
-            case VALUE_STRING:
-                node.add(nodeFactory.textNode(jp.getText()));
-                break;
-            default:
-                node.add(deserializeAny(jp, ctxt, nodeFactory));
-                break;
-            }
-        }
-    }
-
-    protected final JsonNode deserializeAny(JsonParser jp, DeserializationContext ctxt,
-            final JsonNodeFactory nodeFactory)            
-        throws IOException, JsonProcessingException
-    {
-        switch (jp.getCurrentToken()) {
-        case START_OBJECT:
-            return deserializeObject(jp, ctxt, nodeFactory);
-
-        case START_ARRAY:
-            return deserializeArray(jp, ctxt, nodeFactory);
-
-        case FIELD_NAME:
-            return deserializeObject(jp, ctxt, nodeFactory);
-
-        case VALUE_EMBEDDED_OBJECT:
-            // [JACKSON-796]
-            {
-                Object ob = jp.getEmbeddedObject();
-                if (ob == null) { // should this occur?
-                    return nodeFactory.nullNode();
-                }
-                Class<?> type = ob.getClass();
-                if (type == byte[].class) { // most common special case
-                    return nodeFactory.binaryNode((byte[]) ob);
-                }
-                // any other special handling needed?
-                return nodeFactory.POJONode(ob);
-            }
-
-        case VALUE_STRING:
-            return nodeFactory.textNode(jp.getText());
-
-        case VALUE_NUMBER_INT:
-            {
-                JsonParser.NumberType nt = jp.getNumberType();
-                if (nt == JsonParser.NumberType.BIG_INTEGER
-                    || ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS)) {
-                    return nodeFactory.numberNode(jp.getBigIntegerValue());
-                }
-                if (nt == JsonParser.NumberType.INT) {
-                    return nodeFactory.numberNode(jp.getIntValue());
-                }
-                return nodeFactory.numberNode(jp.getLongValue());
-            }
-
-        case VALUE_NUMBER_FLOAT:
-            {
-                JsonParser.NumberType nt = jp.getNumberType();
-                if (nt == JsonParser.NumberType.BIG_DECIMAL
-                    || ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS)) {
-                    return nodeFactory.numberNode(jp.getDecimalValue());
-                }
-                return nodeFactory.numberNode(jp.getDoubleValue());
-            }
-
-        case VALUE_TRUE:
-            return nodeFactory.booleanNode(true);
-
-        case VALUE_FALSE:
-            return nodeFactory.booleanNode(false);
-
-        case VALUE_NULL:
-            return nodeFactory.nullNode();
-            
-            // These states can not be mapped; input stream is
-            // off by an event or two
-
-        //case END_OBJECT:
-        //case END_ARRAY:
-        default:
-            throw ctxt.mappingException(getValueClass());
-        }
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/MapDeserializer.java

@@ -1,412 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.JsonParser;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.JsonToken;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
-import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
-import sh.calaba.org.codehaus.jackson.map.deser.impl.PropertyBasedCreator;
-import sh.calaba.org.codehaus.jackson.map.deser.impl.PropertyValueBuffer;
-import sh.calaba.org.codehaus.jackson.map.deser.std.ContainerDeserializerBase;
-import sh.calaba.org.codehaus.jackson.map.deser.std.StdValueInstantiator;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedConstructor;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedWithParams;
-import sh.calaba.org.codehaus.jackson.map.util.ArrayBuilders;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Basic serializer that can take Json "Object" structure and
- * construct a {@link java.util.Map} instance, with typed contents.
- *<p>
- * Note: for untyped content (one indicated by passing Object.class
- * as the type), {@link UntypedObjectDeserializer} is used instead.
- * It can also construct {@link java.util.Map}s, but not with specific
- * POJO types, only other containers and primitives/wrappers.
- */
-@JacksonStdImpl
-public class MapDeserializer
-    extends ContainerDeserializerBase<Map<Object,Object>>
-    implements ResolvableDeserializer
-{
-    // // Configuration: typing, deserializers
-
-    protected final JavaType _mapType;
-
-    /**
-     * Key deserializer used, if not null. If null, String from JSON
-     * content is used as is.
-     */
-    protected final KeyDeserializer _keyDeserializer;
-
-    /**
-     * Value deserializer.
-     */
-    protected final JsonDeserializer<Object> _valueDeserializer;
-
-    /**
-     * If value instances have polymorphic type information, this
-     * is the type deserializer that can handle it
-     */
-    protected final TypeDeserializer _valueTypeDeserializer;
-    
-    // // Instance construction settings:
-
-    /**
-     * @since 1.9
-     */
-    protected final ValueInstantiator _valueInstantiator;
-
-    /**
-     * @since 1.9
-     */
-    protected final boolean _hasDefaultCreator;
-    
-    /**
-     * If the Map is to be instantiated using non-default constructor
-     * or factory method
-     * that takes one or more named properties as argument(s),
-     * this creator is used for instantiation.
-     */
-    protected PropertyBasedCreator _propertyBasedCreator;    
-    
-    /**
-     * Deserializer that is used iff delegate-based creator is
-     * to be used for deserializing from JSON Object.
-     */
-    protected JsonDeserializer<Object> _delegateDeserializer;
-    
-    // // Any properties to ignore if seen?
-    
-    protected HashSet<String> _ignorableProperties;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    /**
-     * @deprecated Since 1.9, use variant that takes ValueInstantiator
-     */
-    @Deprecated
-    protected MapDeserializer(JavaType mapType, Constructor<Map<Object,Object>> defCtor,
-            KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
-            TypeDeserializer valueTypeDeser)
-    {
-        super(Map.class);
-        _mapType = mapType;
-        _keyDeserializer = keyDeser;
-        _valueDeserializer = valueDeser;
-        _valueTypeDeserializer = valueTypeDeser;
-        // not super-clean, but has to do...
-        StdValueInstantiator inst = new StdValueInstantiator(null, mapType);
-        if (defCtor != null) {
-            AnnotatedConstructor aCtor = new AnnotatedConstructor(defCtor,
-                    null, null);
-            inst.configureFromObjectSettings(aCtor, null, null, null, null);
-        }
-        _hasDefaultCreator = (defCtor != null);
-        _valueInstantiator = inst;
-    }
-
-    public MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator,
-            KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
-            TypeDeserializer valueTypeDeser)
-    {
-        super(Map.class);
-        _mapType = mapType;
-        _keyDeserializer = keyDeser;
-        _valueDeserializer = valueDeser;
-        _valueTypeDeserializer = valueTypeDeser;
-        _valueInstantiator = valueInstantiator;
-        if (valueInstantiator.canCreateFromObjectWith()) {
-            _propertyBasedCreator = new PropertyBasedCreator(valueInstantiator);
-        } else {
-            _propertyBasedCreator = null;
-        }
-        _hasDefaultCreator = valueInstantiator.canCreateUsingDefault();
-    }
-
-    /**
-     * Copy-constructor that can be used by sub-classes to allow
-     * copy-on-write styling copying of settings of an existing instance.
-     * 
-     * @since 1.9
-     */
-    protected MapDeserializer(MapDeserializer src)
-    {
-        super(src._valueClass);
-        _mapType = src._mapType;
-        _keyDeserializer = src._keyDeserializer;
-        _valueDeserializer = src._valueDeserializer;
-        _valueTypeDeserializer = src._valueTypeDeserializer;
-        _valueInstantiator = src._valueInstantiator;
-        _propertyBasedCreator = src._propertyBasedCreator;
-        _delegateDeserializer = src._delegateDeserializer;
-        _hasDefaultCreator = src._hasDefaultCreator;
-        // should we make a copy here?
-        _ignorableProperties = src._ignorableProperties;
-    }
-
-    public void setIgnorableProperties(String[] ignorable)
-    {
-        _ignorableProperties = (ignorable == null || ignorable.length == 0) ?
-            null : ArrayBuilders.arrayToSet(ignorable);
-    }
-
-    /*
-    /**********************************************************
-    /* Validation, post-processing (ResolvableDeserializer)
-    /**********************************************************
-     */
-
-    /**
-     * Method called to finalize setup of this deserializer,
-     * after deserializer itself has been registered. This
-     * is needed to handle recursive and transitive dependencies.
-     */
-    @Override
-    public void resolve(DeserializationConfig config, DeserializerProvider provider)
-        throws JsonMappingException
-    {
-        // May need to resolve types for delegate- and/or property-based creators:
-        if (_valueInstantiator.canCreateUsingDelegate()) {
-            JavaType delegateType = _valueInstantiator.getDelegateType();
-            if (delegateType == null) {
-                throw new IllegalArgumentException("Invalid delegate-creator definition for "+_mapType
-                        +": value instantiator ("+_valueInstantiator.getClass().getName()
-                        +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
-            }
-            AnnotatedWithParams delegateCreator = _valueInstantiator.getDelegateCreator();
-            // Need to create a temporary property to allow contextual deserializers:
-            // Note: unlike BeanDeserializer, we don't have an AnnotatedClass around; hence no annotations passed
-            BeanProperty.Std property = new BeanProperty.Std(null,
-                    delegateType, null, delegateCreator);
-            _delegateDeserializer = findDeserializer(config, provider, delegateType, property);
-        }
-        if (_propertyBasedCreator != null) {
-            for (SettableBeanProperty prop : _propertyBasedCreator.getCreatorProperties()) {
-                if (!prop.hasValueDeserializer()) {
-                    _propertyBasedCreator.assignDeserializer(prop, findDeserializer(config, provider, prop.getType(), prop));
-                }
-            }
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* ContainerDeserializerBase API
-    /**********************************************************
-     */
-
-    @Override
-    public JavaType getContentType() {
-        return _mapType.getContentType();
-    }
-
-    @Override
-    public JsonDeserializer<Object> getContentDeserializer() {
-        return _valueDeserializer;
-    }
-    
-    /*
-    /**********************************************************
-    /* JsonDeserializer API
-    /**********************************************************
-     */
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public Map<Object,Object> deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        if (_propertyBasedCreator != null) {
-            return _deserializeUsingCreator(jp, ctxt);
-        }
-        if (_delegateDeserializer != null) {
-            return (Map<Object,Object>) _valueInstantiator.createUsingDelegate(_delegateDeserializer.deserialize(jp, ctxt));
-        }
-        if (!_hasDefaultCreator) {
-            throw ctxt.instantiationException(getMapClass(), "No default constructor found");
-        }
-        // Ok: must point to START_OBJECT, FIELD_NAME or END_OBJECT
-        JsonToken t = jp.getCurrentToken();
-        if (t != JsonToken.START_OBJECT && t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) {
-            // [JACKSON-620] (empty) String may be ok however:
-            if (t == JsonToken.VALUE_STRING) {
-                return (Map<Object,Object>) _valueInstantiator.createFromString(jp.getText());
-            }
-            throw ctxt.mappingException(getMapClass());
-        }
-        final Map<Object,Object> result = (Map<Object,Object>) _valueInstantiator.createUsingDefault();
-        _readAndBind(jp, ctxt, result);
-        return result;
-    }
-
-    @Override
-    public Map<Object,Object> deserialize(JsonParser jp, DeserializationContext ctxt,
-            Map<Object,Object> result)
-        throws IOException, JsonProcessingException
-    {
-        // Ok: must point to START_OBJECT or FIELD_NAME
-        JsonToken t = jp.getCurrentToken();
-        if (t != JsonToken.START_OBJECT && t != JsonToken.FIELD_NAME) {
-            throw ctxt.mappingException(getMapClass());
-        }
-        _readAndBind(jp, ctxt, result);
-        return result;
-    }
-
-    @Override
-    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        // In future could check current token... for now this should be enough:
-        return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
-    }
-    
-    /*
-    /**********************************************************
-    /* Other public accessors
-    /**********************************************************
-     */
-
-    @SuppressWarnings("unchecked")
-    public final Class<?> getMapClass() { return (Class<Map<Object,Object>>) _mapType.getRawClass(); }
-
-    @Override public JavaType getValueType() { return _mapType; }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    protected final void _readAndBind(JsonParser jp, DeserializationContext ctxt,
-                                      Map<Object,Object> result)
-        throws IOException, JsonProcessingException
-    {
-        JsonToken t = jp.getCurrentToken();
-        if (t == JsonToken.START_OBJECT) {
-            t = jp.nextToken();
-        }
-        final KeyDeserializer keyDes = _keyDeserializer;
-        final JsonDeserializer<Object> valueDes = _valueDeserializer;
-        final TypeDeserializer typeDeser = _valueTypeDeserializer;
-        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
-            // Must point to field name
-            String fieldName = jp.getCurrentName();
-            Object key = keyDes.deserializeKey(fieldName, ctxt);
-            // And then the value...
-            t = jp.nextToken();
-            if (_ignorableProperties != null && _ignorableProperties.contains(fieldName)) {
-                jp.skipChildren();
-                continue;
-            }
-            // Note: must handle null explicitly here; value deserializers won't
-            Object value;            
-            if (t == JsonToken.VALUE_NULL) {
-                value = null;
-            } else if (typeDeser == null) {
-                value = valueDes.deserialize(jp, ctxt);
-            } else {
-                value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
-            }
-            /* !!! 23-Dec-2008, tatu: should there be an option to verify
-             *   that there are no duplicate field names? (and/or what
-             *   to do, keep-first or keep-last)
-             */
-            result.put(key, value);
-        }
-    }
-
-    @SuppressWarnings("unchecked") 
-    public Map<Object,Object> _deserializeUsingCreator(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        final PropertyBasedCreator creator = _propertyBasedCreator;
-        PropertyValueBuffer buffer = creator.startBuilding(jp, ctxt);
-
-        JsonToken t = jp.getCurrentToken();
-        if (t == JsonToken.START_OBJECT) {
-            t = jp.nextToken();
-        }
-        final JsonDeserializer<Object> valueDes = _valueDeserializer;
-        final TypeDeserializer typeDeser = _valueTypeDeserializer;
-        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
-            String propName = jp.getCurrentName();
-            t = jp.nextToken(); // to get to value
-            if (_ignorableProperties != null && _ignorableProperties.contains(propName)) {
-                jp.skipChildren(); // and skip it (in case of array/object)
-                continue;
-            }
-            // creator property?
-            SettableBeanProperty prop = creator.findCreatorProperty(propName);
-            if (prop != null) {
-                // Last property to set?
-                Object value = prop.deserialize(jp, ctxt);
-                if (buffer.assignParameter(prop.getPropertyIndex(), value)) {
-                    jp.nextToken();
-                    Map<Object,Object> result;
-                    try {
-                        result = (Map<Object,Object>)creator.build(buffer);
-                    } catch (Exception e) {
-                        wrapAndThrow(e, _mapType.getRawClass());
-                        return null;
-                    }
-                    _readAndBind(jp, ctxt, result);
-                    return result;
-                }
-                continue;
-            }
-            // other property? needs buffering
-            String fieldName = jp.getCurrentName();
-            Object key = _keyDeserializer.deserializeKey(fieldName, ctxt);
-            Object value;            
-            if (t == JsonToken.VALUE_NULL) {
-                value = null;
-            } else if (typeDeser == null) {
-                value = valueDes.deserialize(jp, ctxt);
-            } else {
-                value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
-            }
-            buffer.bufferMapProperty(key, value);
-        }
-        // end of JSON object?
-        // if so, can just construct and leave...
-        try {
-            return (Map<Object,Object>)creator.build(buffer);
-        } catch (Exception e) {
-            wrapAndThrow(e, _mapType.getRawClass());
-            return null;
-        }
-    }
-
-    // note: copied form BeanDeserializer; should try to share somehow...
-    protected void wrapAndThrow(Throwable t, Object ref)
-        throws IOException
-    {
-        // to handle StackOverflow:
-        while (t instanceof InvocationTargetException && t.getCause() != null) {
-            t = t.getCause();
-        }
-        // Errors and "plain" IOExceptions to be passed as is
-        if (t instanceof Error) {
-            throw (Error) t;
-        }
-        // ... except for mapping exceptions
-        if (t instanceof IOException && !(t instanceof JsonMappingException)) {
-            throw (IOException) t;
-        }
-        throw JsonMappingException.wrapWithPath(t, ref, null);
-    }
-
-}