calabash-android 0.0.1

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

@@ -0,0 +1,15 @@
+/**
+ * Contains public standard implementations of abstraction that
+ * Jackson uses. This means that they are not merely implementation
+ * details, but part of semi-public interface where project
+ * tries to maintain backwards compatibility at higher level
+ * than for 'impl' types (although less so than with fully
+ * public interfaces).
+ *<p>
+ * Note that since this package was only added relatively late
+ * in development cycle, not all classes that belong here are
+ * included. Plan is to move more classes over time.
+ * 
+ * @since 1.9
+ */
+package sh.calaba.org.codehaus.jackson.map.deser.std;

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/exc/UnrecognizedPropertyException.java

@@ -0,0 +1,75 @@
+package sh.calaba.org.codehaus.jackson.map.exc;
+
+import sh.calaba.org.codehaus.jackson.JsonLocation;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+
+/**
+ * Specialized {@link JsonMappingException} sub-class specifically used
+ * to indicate problems due to encountering a JSON property that could
+ * not be mapped to an Object property (via getter, constructor argument
+ * or field).
+ * 
+ * @since 1.6
+ */
+public class UnrecognizedPropertyException
+    extends JsonMappingException
+{
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Class that does not contain mapping for the unrecognized property.
+     */
+    protected final Class<?> _referringClass;
+    
+    /**
+     *<p>
+     * Note: redundant information since it is also included in the
+     * reference path.
+     */
+    protected final String _unrecognizedPropertyName;
+    
+    public UnrecognizedPropertyException(String msg, JsonLocation loc,
+            Class<?> referringClass, String propName)
+    {
+        
+        super(msg, loc);
+        _referringClass = referringClass;
+        _unrecognizedPropertyName = propName;
+    }
+
+    public static UnrecognizedPropertyException from(JsonParser jp, Object fromObjectOrClass, String propertyName)
+    {
+        if (fromObjectOrClass == null) {
+            throw new IllegalArgumentException();
+        }
+        Class<?> ref;
+        if (fromObjectOrClass instanceof Class<?>) {
+            ref = (Class<?>) fromObjectOrClass;
+        } else {
+            ref = fromObjectOrClass.getClass();
+        }
+        String msg = "Unrecognized field \""+propertyName+"\" (Class "+ref.getName()+"), not marked as ignorable";
+        UnrecognizedPropertyException e = new UnrecognizedPropertyException(msg, jp.getCurrentLocation(), ref, propertyName);
+        // but let's also ensure path includes this last (missing) segment
+        e.prependPath(fromObjectOrClass, propertyName);
+        return e;
+    }
+
+    /**
+     * Method for accessing type (class) that is missing definition to allow
+     * binding of the unrecognized property.
+     */
+    public Class<?> getReferringClass() {
+        return _referringClass;
+    }
+    
+    /**
+     * Convenience method for accessing logical property name that could
+     * not be mapped. Note that it is the last path reference in the
+     * underlying path.
+     */
+    public String getUnrecognizedPropertyName() {
+        return _unrecognizedPropertyName;
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ext/CoreXMLDeserializers.java

@@ -0,0 +1,114 @@
+package sh.calaba.org.codehaus.jackson.map.ext;
+
+import java.io.IOException;
+import java.util.*;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.Duration;
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.namespace.QName;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.deser.std.FromStringDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdScalarDeserializer;
+import sh.calaba.org.codehaus.jackson.map.util.Provider;
+
+/**
+ * Container deserializers that handle "core" XML types: ones included in standard
+ * JDK 1.5. Types are directly needed by JAXB, and are thus supported within core
+ * mapper package, not in "xc" package.
+ *
+ * @since 1.3
+ */
+public class CoreXMLDeserializers
+    implements Provider<StdDeserializer<?>>
+{
+    /**
+     * Data type factories are thread-safe after instantiation (and
+     * configuration, if any); and since instantion (esp. implementation
+     * introspection) can be expensive we better reuse the instance.
+     */
+    final static DatatypeFactory _dataTypeFactory;
+    static {
+        try {
+            _dataTypeFactory = DatatypeFactory.newInstance();
+        } catch (DatatypeConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    /*
+    /**********************************************************
+    /* Provider implementation
+    /**********************************************************
+     */
+
+    /**
+     * Method called by {@link sh.calaba.org.codehaus.jackson.map.deser.BasicDeserializerFactory}
+     * to register deserializers this class provides.
+     */
+    @Override
+    public Collection<StdDeserializer<?>> provide()
+    {
+        return Arrays.asList(new StdDeserializer<?>[] {
+            new DurationDeserializer()
+            ,new GregorianCalendarDeserializer()
+            ,new QNameDeserializer()
+        });
+    }
+    
+    /*
+    /**********************************************************
+    /* Concrete deserializers
+    /**********************************************************
+     */
+
+    public static class DurationDeserializer
+        extends FromStringDeserializer<Duration>
+    {
+        public DurationDeserializer() { super(Duration.class); }
+    
+        @Override
+        protected Duration _deserialize(String value, DeserializationContext ctxt)
+            throws IllegalArgumentException
+        {
+            return _dataTypeFactory.newDuration(value);
+        }
+    }
+
+    public static class GregorianCalendarDeserializer
+        extends StdScalarDeserializer<XMLGregorianCalendar>
+    {
+        public GregorianCalendarDeserializer() { super(XMLGregorianCalendar.class); }
+        
+        @Override
+        public XMLGregorianCalendar deserialize(JsonParser jp, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+        {
+            Date d = _parseDate(jp, ctxt);
+            if (d == null) {
+                return null;
+            }
+            GregorianCalendar calendar = new GregorianCalendar();
+            calendar.setTime(d);
+            return _dataTypeFactory.newXMLGregorianCalendar(calendar);
+        }
+    }
+
+    public static class QNameDeserializer
+        extends FromStringDeserializer<QName>
+    {
+        public QNameDeserializer() { super(QName.class); }
+        
+        @Override
+        protected QName _deserialize(String value, DeserializationContext ctxt)
+            throws IllegalArgumentException
+        {
+            return QName.valueOf(value);
+        }
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ext/CoreXMLSerializers.java

@@ -0,0 +1,72 @@
+package sh.calaba.org.codehaus.jackson.map.ext;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.datatype.Duration;
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.namespace.QName;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.ser.std.CalendarSerializer;
+import sh.calaba.org.codehaus.jackson.map.ser.std.SerializerBase;
+import sh.calaba.org.codehaus.jackson.map.ser.std.ToStringSerializer;
+import sh.calaba.org.codehaus.jackson.map.util.Provider;
+
+/**
+ * Provider for serializers of XML types that are part of full JDK 1.5, but
+ * that some alleged 1.5 platforms are missing (Android, GAE).
+ * And for this reason these are added using more dynamic mechanism.
+ *<p>
+ * Note: since many of classes defined are abstract, caller must take
+ * care not to just use straight equivalency check but rather consider
+ * subclassing as well.
+ *
+ * @since 1.4
+ */
+public class CoreXMLSerializers
+    implements Provider<Map.Entry<Class<?>,JsonSerializer<?>>>
+{
+    final static HashMap<Class<?>,JsonSerializer<?>> _serializers = new HashMap<Class<?>,JsonSerializer<?>>();
+    /**
+     * We will construct instances statically, during class loading, to try to
+     * make things fail-fast, i.e. to catch problems as soon as possible.
+     */
+    static {
+        ToStringSerializer tss = ToStringSerializer.instance;
+        _serializers.put(Duration.class, tss);
+        _serializers.put(XMLGregorianCalendar.class, new XMLGregorianCalendarSerializer());
+        _serializers.put(QName.class, tss);
+    }
+    
+    @Override
+    public Collection<Map.Entry<Class<?>,JsonSerializer<?>>> provide() {
+        return _serializers.entrySet();
+    }
+
+    public static class XMLGregorianCalendarSerializer extends SerializerBase<XMLGregorianCalendar>
+    {
+        public XMLGregorianCalendarSerializer() {
+            super(XMLGregorianCalendar.class);
+        }
+
+        @Override
+        public void serialize(XMLGregorianCalendar value, JsonGenerator jgen, SerializerProvider provider)
+                throws IOException, JsonGenerationException {
+            CalendarSerializer.instance.serialize(value.toGregorianCalendar(), jgen, provider);
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException {
+            return CalendarSerializer.instance.getSchema(provider, typeHint);
+        }
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ext/DOMDeserializer.java

@@ -0,0 +1,65 @@
+package sh.calaba.org.codehaus.jackson.map.ext;
+
+import java.io.StringReader;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.deser.std.FromStringDeserializer;
+
+/**
+ * Base for serializers that allows parsing DOM Documents from JSON Strings.
+ * Nominal type can be either {@link org.w3c.dom.Node} or
+ * {@link org.w3c.dom.Document}.
+ */
+public abstract class DOMDeserializer<T> extends FromStringDeserializer<T>
+{
+    final static DocumentBuilderFactory _parserFactory;
+    static {
+        _parserFactory = DocumentBuilderFactory.newInstance();
+        // yup, only cave men do XML without recognizing namespaces...
+        _parserFactory.setNamespaceAware(true);
+    }
+
+    protected DOMDeserializer(Class<T> cls) { super(cls); }
+
+    @Override
+    public abstract T _deserialize(String value, DeserializationContext ctxt);
+
+    protected final Document parse(String value) throws IllegalArgumentException
+    {
+        try {
+            return _parserFactory.newDocumentBuilder().parse(new InputSource(new StringReader(value)));
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Failed to parse JSON String as XML: "+e.getMessage(), e);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Concrete deserializers
+    /**********************************************************
+     */
+    
+    public static class NodeDeserializer extends DOMDeserializer<Node>
+    {
+        public NodeDeserializer() { super(Node.class); }
+        @Override
+        public Node _deserialize(String value, DeserializationContext ctxt) throws IllegalArgumentException {
+            return parse(value);
+        }
+    }    
+
+    public static class DocumentDeserializer extends DOMDeserializer<Document>
+    {
+        public DocumentDeserializer() { super(Document.class); }
+        @Override
+        public Document _deserialize(String value, DeserializationContext ctxt) throws IllegalArgumentException {
+            return parse(value);
+        }
+    }    
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ext/OptionalHandlerFactory.java

@@ -0,0 +1,217 @@
+package sh.calaba.org.codehaus.jackson.map.ext;
+
+import java.util.Collection;
+import java.util.Map;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdDeserializer;
+import sh.calaba.org.codehaus.jackson.map.util.Provider;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Helper class used for isolating details of handling optional+external types (Joda datetime,
+ * javax.xml classes) from standard factories that offer them.
+ * 
+ * @author tatu
+ *
+ * @since 1.6.1
+ */
+public class OptionalHandlerFactory
+{
+    /* 1.6.1+ To make 2 main "optional" handler groups (javax.xml.stream, Joda date/time)
+     * more dynamic, we better only figure out handlers completely dynamically, if and
+     * when they are needed. To do this we need to assume package prefixes.
+     */
+
+    private final static String PACKAGE_PREFIX_JODA_DATETIME = "org.joda.time.";
+    private final static String PACKAGE_PREFIX_JAVAX_XML = "javax.xml.";
+
+    private final static String SERIALIZERS_FOR_JODA_DATETIME = "sh.calaba.org.codehaus.jackson.map.ext.JodaSerializers";
+    private final static String SERIALIZERS_FOR_JAVAX_XML = "sh.calaba.org.codehaus.jackson.map.ext.CoreXMLSerializers";
+    private final static String DESERIALIZERS_FOR_JODA_DATETIME = "sh.calaba.org.codehaus.jackson.map.ext.JodaDeserializers";
+    private final static String DESERIALIZERS_FOR_JAVAX_XML = "sh.calaba.org.codehaus.jackson.map.ext.CoreXMLDeserializers";
+
+    // Plus we also have a single serializer for DOM Node:
+    private final static String CLASS_NAME_DOM_NODE = "org.w3c.dom.Node";
+    private final static String CLASS_NAME_DOM_DOCUMENT = "org.w3c.dom.Node";
+    private final static String SERIALIZER_FOR_DOM_NODE = "sh.calaba.org.codehaus.jackson.map.ext.DOMSerializer";
+    private final static String DESERIALIZER_FOR_DOM_DOCUMENT = "sh.calaba.org.codehaus.jackson.map.ext.DOMDeserializer$DocumentDeserializer";
+    private final static String DESERIALIZER_FOR_DOM_NODE = "sh.calaba.org.codehaus.jackson.map.ext.DOMDeserializer$NodeDeserializer";
+    
+    public final static OptionalHandlerFactory instance = new OptionalHandlerFactory();
+    
+    protected OptionalHandlerFactory() { }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+    
+    public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType type)
+//            BasicBeanDescription beanInfo, BeanProperty property)
+    {
+        Class<?> rawType = type.getRawClass();
+        String className = rawType.getName();
+        String factoryName;
+        
+        if (className.startsWith(PACKAGE_PREFIX_JODA_DATETIME)) {
+            factoryName = SERIALIZERS_FOR_JODA_DATETIME;
+        } else if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML)
+                || hasSupertypeStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
+            factoryName = SERIALIZERS_FOR_JAVAX_XML;
+        } else if (doesImplement(rawType, CLASS_NAME_DOM_NODE)) {
+            return (JsonSerializer<?>) instantiate(SERIALIZER_FOR_DOM_NODE);
+        } else {
+            return null;
+        }
+
+        Object ob = instantiate(factoryName);
+        if (ob == null) { // could warn, if we had logging system (j.u.l?)
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        Provider<Map.Entry<Class<?>,JsonSerializer<?>>> prov = (Provider<Map.Entry<Class<?>,JsonSerializer<?>>>) ob;
+        Collection<Map.Entry<Class<?>,JsonSerializer<?>>> entries = prov.provide();
+
+        // first, check for exact match (concrete)
+        for (Map.Entry<Class<?>,JsonSerializer<?>> entry : entries) {
+            if (rawType == entry.getKey()) {
+                return entry.getValue();
+            }
+        }
+        // if no match, check super-type match
+        for (Map.Entry<Class<?>,JsonSerializer<?>> entry : entries) {
+            if (entry.getKey().isAssignableFrom(rawType)) {
+                return entry.getValue();
+            }
+        }
+        // but maybe there's just no match to be found?
+        return null;
+    }
+
+    public JsonDeserializer<?> findDeserializer(JavaType type, DeserializationConfig config, DeserializerProvider p)
+    {
+        Class<?> rawType = type.getRawClass();
+        String className = rawType.getName();
+        String factoryName;
+        
+        if (className.startsWith(PACKAGE_PREFIX_JODA_DATETIME)) {
+            factoryName = DESERIALIZERS_FOR_JODA_DATETIME;
+        } else if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML)
+                || hasSupertypeStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
+            factoryName = DESERIALIZERS_FOR_JAVAX_XML;
+        } else if (doesImplement(rawType, CLASS_NAME_DOM_DOCUMENT)) {
+            return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_DOCUMENT);
+        } else if (doesImplement(rawType, CLASS_NAME_DOM_NODE)) {
+            return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_NODE);
+        } else {
+            return null;
+        }
+        Object ob = instantiate(factoryName);
+        if (ob == null) { // could warn, if we had logging system (j.u.l?)
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        Provider<StdDeserializer<?>> prov = (Provider<StdDeserializer<?>>) ob;
+        Collection<StdDeserializer<?>> entries = prov.provide();
+
+        // first, check for exact match (concrete)
+        for (StdDeserializer<?> deser : entries) {
+            if (rawType == deser.getValueClass()) {
+                return deser;
+            }
+        }
+        // if no match, check super-type match
+        for (StdDeserializer<?> deser : entries) {
+            if (deser.getValueClass().isAssignableFrom(rawType)) {
+                return deser;
+            }
+        }
+        // but maybe there's just no match to be found?
+        return null;
+    }
+    
+    /*
+    /**********************************************************
+    /* Internal helper methods
+    /**********************************************************
+     */
+
+    private Object instantiate(String className)
+    {
+        try {
+            return Class.forName(className).newInstance();
+        }
+        catch (LinkageError e) { }
+        // too many different kinds to enumerate here:
+        catch (Exception e) { }
+        return null;
+    }
+    
+    private boolean doesImplement(Class<?> actualType, String classNameToImplement)
+    {
+        for (Class<?> type = actualType; type != null; type = type.getSuperclass()) {
+            if (type.getName().equals(classNameToImplement)) {
+                return true;
+            }
+            // or maybe one of super-interfaces
+            if (hasInterface(type, classNameToImplement)) {
+                return true;
+            }
+        }
+        return false;
+    }
+        
+    private boolean hasInterface(Class<?> type, String interfaceToImplement)
+    {
+        Class<?>[] interfaces = type.getInterfaces();
+        for (Class<?> iface : interfaces) {
+            if (iface.getName().equals(interfaceToImplement)) {
+                return true;
+            }
+        }
+        // maybe super-interface?
+        for (Class<?> iface : interfaces) {
+            if (hasInterface(iface, interfaceToImplement)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasSupertypeStartingWith(Class<?> rawType, String prefix)
+    {
+        // first, superclasses
+        for (Class<?> supertype = rawType.getSuperclass(); supertype != null; supertype = supertype.getSuperclass()) {
+            if (supertype.getName().startsWith(prefix)) {
+                return true;
+            }
+        }
+        // then interfaces
+        for (Class<?> cls = rawType; cls != null; cls = cls.getSuperclass()) {
+            if (hasInterfaceStartingWith(cls, prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasInterfaceStartingWith(Class<?> type, String prefix)
+    {
+        Class<?>[] interfaces = type.getInterfaces();
+        for (Class<?> iface : interfaces) {
+            if (iface.getName().startsWith(prefix)) {
+                return true;
+            }
+        }
+        // maybe super-interface?
+        for (Class<?> iface : interfaces) {
+            if (hasInterfaceStartingWith(iface, prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+}