calabash-android 0.0.1

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

@@ -0,0 +1,171 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedConstructor;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedField;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import sh.calaba.org.codehaus.jackson.map.introspect.VisibilityChecker;
+import sh.calaba.org.codehaus.jackson.map.type.TypeBindings;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Basic container for information gathered by {@link ClassIntrospector} to
+ * help in constructing serializers and deserializers.
+ * Note that the main implementation type is
+ * {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription},
+ * meaning that it is safe to upcast to this type.
+ * 
+ * @author tatu
+ */
+public abstract class BeanDescription
+{
+    /*
+    /**********************************************************
+    /* Configuration
+    /**********************************************************
+     */
+
+    /**
+     * Bean type information, including raw class and possible
+     * * generics information
+     */
+    protected final JavaType _type;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    protected BeanDescription(JavaType type)
+    {
+    	_type = type;
+    }
+
+    /*
+    /**********************************************************
+    /* Simple accesors
+    /**********************************************************
+     */
+
+    /**
+     * Method for accessing declared type of bean being introspected,
+     * including full generic type information (from declaration)
+     */
+    public JavaType getType() { return _type; }
+
+    public Class<?> getBeanClass() { return _type.getRawClass(); }
+
+    public abstract AnnotatedClass getClassInfo();
+    
+    public abstract boolean hasKnownClassAnnotations();
+
+    /**
+     * Accessor for type bindings that may be needed to fully resolve
+     * types of member object, such as return and argument types of
+     * methods and constructors, and types of fields.
+     */
+    public abstract TypeBindings bindingsForBeanType();
+
+    /**
+     * Method for resolving given JDK type, using this bean as the
+     * generic type resolution context.
+     * 
+     * @since 1.9
+     */
+    public abstract JavaType resolveType(java.lang.reflect.Type jdkType);
+    
+    /**
+     * Method for accessing collection of annotations the bean
+     * class has.
+     * 
+     * @since 1.7
+     */
+    public abstract Annotations getClassAnnotations();
+    
+    /*
+    /**********************************************************
+    /* Basic API for finding properties, related
+    /**********************************************************
+     */
+    
+    /**
+     * @return Ordered Map with logical property name as key, and
+     *    matching getter method as value.
+     *    
+     * @since 1.9
+     */
+    public abstract List<BeanPropertyDefinition> findProperties();
+
+    /**
+     * @since 1.9
+     */
+    public abstract Map<Object, AnnotatedMember> findInjectables();
+    
+    /**
+     * @since 1.9
+     */
+    public abstract AnnotatedMethod findAnyGetter();
+
+    /**
+     * @since 1.9
+     */
+    public abstract AnnotatedMethod findAnySetter();
+
+    /**
+     * @since 1.9
+     */
+    public abstract AnnotatedMethod findJsonValueMethod();
+
+    /**
+     * @since 1.9
+     */
+    public abstract AnnotatedConstructor findDefaultConstructor();
+    
+    /**
+     * @since 1.9
+     */
+    public abstract Set<String> getIgnoredPropertyNames();
+
+    /*
+    /**********************************************************
+    /* Deprecated methods
+    /**********************************************************
+     */
+
+    /**
+     * @deprecated Since 1.9 use {@link #findProperties}
+     */
+    @Deprecated
+    public abstract LinkedHashMap<String,AnnotatedMethod> findGetters(VisibilityChecker<?> visibilityChecker,
+            Collection<String> ignoredProperties);
+
+    /**
+     * @deprecated Since 1.9 use {@link #findProperties}
+     */
+    @Deprecated
+    public abstract LinkedHashMap<String,AnnotatedMethod> findSetters(VisibilityChecker<?> visibilityChecker);
+
+    /**
+     * @deprecated Since 1.9 use {@link #findProperties}
+     */
+    @Deprecated
+    public abstract LinkedHashMap<String,AnnotatedField> findDeserializableFields(VisibilityChecker<?> visibilityChecker,
+            Collection<String> ignoredProperties);
+
+    /**
+     * @deprecated Since 1.9 use the non-deprecated version
+     */
+    @Deprecated
+    public abstract Map<String,AnnotatedField> findSerializableFields(VisibilityChecker<?> visibilityChecker,
+            Collection<String> ignoredProperties);
+
+}

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

@@ -0,0 +1,123 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.lang.annotation.Annotation;
+
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.map.util.Named;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Bean properties are logical entities that represent data
+ * Java objects ("beans", although more accurately POJOs)
+ * contain; and that are accessed using some combination
+ * of methods (getter, setter), field and constructor
+ * parameter.
+ * Instances allow access to annotations directly associated
+ * to property (via field or method), as well as contextual
+ * annotations (annotations for class that contains properties).
+ *<p>
+ * Instances are passed during construction of serializers and
+ * deserializers, and references can be stored by serializers
+ * and deserializers for futher use; mostly to retain access
+ * to annotations when dynamically locating handlers for
+ * sub-properties or dynamic types.
+ *
+ * @since 1.7
+ */
+public interface BeanProperty extends Named
+{
+    /**
+     * Method to get logical name of the property
+     */
+    @Override
+    public String getName();
+    
+    /**
+     * Method to get declared type of the property.
+     */
+    public JavaType getType();
+
+    /**
+     * Method for finding annotation associated with this property;
+     * meaning annotation associated with one of entities used to
+     * access property.
+     */
+    public <A extends Annotation> A getAnnotation(Class<A> acls);
+
+    /**
+     * Method for finding annotation associated with context of
+     * this property; usually class in which member is declared
+     * (or its subtype if processing subtype).
+     */
+    public <A extends Annotation> A getContextAnnotation(Class<A> acls);
+
+    /**
+     * Method for accessing primary physical entity that represents the property;
+     * annotated field, method or constructor property.
+     */
+    public AnnotatedMember getMember();
+    
+    /*
+    /**********************************************************
+    /* Simple stand-alone implementation, useful as a placeholder
+    /* or base class.
+    /**********************************************************
+     */
+
+    public static class Std implements BeanProperty
+    {
+        protected final String _name;
+        protected final JavaType _type;
+
+        /**
+         * Physical entity (field, method or constructor argument) that
+         * is used to access value of property (or in case of constructor
+         * property, just placeholder)
+         */
+        protected final AnnotatedMember _member;
+
+        /**
+         * Annotations defined in the context class (if any); may be null
+         * if no annotations were found
+         */
+        protected final Annotations _contextAnnotations;
+        
+        public Std(String name, JavaType type, Annotations contextAnnotations, AnnotatedMember member)
+        {
+            _name = name;
+            _type = type;
+            _member = member;
+            _contextAnnotations = contextAnnotations;
+        }
+
+        public Std withType(JavaType type) {
+            return new Std(_name, type, _contextAnnotations, _member);
+        }
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _member.getAnnotation(acls);
+        }
+
+        @Override
+        public <A extends Annotation> A getContextAnnotation(Class<A> acls) {
+            return (_contextAnnotations == null) ? null : _contextAnnotations.get(acls);
+        }
+        
+        @Override
+        public String getName() {
+            return _name;
+        }
+
+        @Override
+        public JavaType getType() {
+            return _type;
+        }
+
+        @Override
+        public AnnotatedMember getMember() {
+            return _member;
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedField;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedParameter;
+import sh.calaba.org.codehaus.jackson.map.util.Named;
+
+/**
+ * Simple value classes that contain definitions of properties,
+ * used during introspection of properties to use for
+ * serialization and deserialization purposes.
+ * These instances are created before actual {@link BeanProperty}
+ * instances are created, i.e. they are used earlier in the process
+ * flow.
+ *
+ * @since 1.9
+ */
+public abstract class BeanPropertyDefinition
+    implements Named
+{
+    /**
+     * Accessor for name used for external representation (in JSON).
+     */
+    @Override // from Named
+    public abstract String getName();
+
+    /**
+     * Accessor that can be used to determine implicit name from underlying
+     * element(s) before possible renaming. This is the "internal"
+     * name derived from accessor ("x" from "getX"), and is not based on
+     * annotations or naming strategy.
+     */
+    public abstract String getInternalName();
+    
+    public abstract boolean hasGetter();
+    public abstract boolean hasSetter();
+    public abstract boolean hasField();
+    public abstract boolean hasConstructorParameter();
+
+    public boolean couldDeserialize() {
+        return getMutator() != null;
+    }
+    public boolean couldSerialize() {
+        return getAccessor() != null;
+    }
+
+    public abstract AnnotatedMethod getGetter();
+    public abstract AnnotatedMethod getSetter();
+    public abstract AnnotatedField getField();
+    public abstract AnnotatedParameter getConstructorParameter();
+
+    /**
+     * Method used to find accessor (getter, field to access) to use for accessing
+     * value of the property.
+     * Null if no such member exists.
+     */
+    public abstract AnnotatedMember getAccessor();
+
+    /**
+     * Method used to find mutator (constructor parameter, setter, field) to use for
+     * changing value of the property.
+     * Null if no such member exists.
+     */
+    public abstract AnnotatedMember getMutator();
+}

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

@@ -0,0 +1,117 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Helper class used to introspect features of POJO value classes
+ * used with Jackson. The main use is for finding out
+ * POJO construction (creator) and value access (getters, setters)
+ * methods and annotations that define configuration of using
+ * those methods.
+ */
+public abstract class ClassIntrospector<T extends BeanDescription>
+{
+    /*
+    /**********************************************************
+    /* Helper interfaces
+    /**********************************************************
+     */
+
+    /**
+     * Interface used for decoupling details of how mix-in annotation
+     * definitions are accessed (via this interface), and how
+     * they are stored (defined by classes that implement the interface)
+     */
+    public interface MixInResolver
+    {
+        /**
+         * Method that will check if there are "mix-in" classes (with mix-in
+         * annotations) for given class
+         */
+        public Class<?> findMixInClassFor(Class<?> cls);
+    }
+
+    protected ClassIntrospector() { }
+	
+    /*
+    /**********************************************************
+    /* Public API: factory methods
+    /**********************************************************
+     */
+    
+    /**
+     * Factory method that constructs an introspector that has all
+     * information needed for serialization purposes.
+     */
+    public abstract T forSerialization(SerializationConfig cfg, JavaType type,
+            MixInResolver r);
+
+    /**
+     * Factory method that constructs an introspector that has all
+     * information needed for deserialization purposes.
+     */
+    public abstract T forDeserialization(DeserializationConfig cfg, JavaType type,
+            MixInResolver r);
+    
+    /**
+     * Factory method that constructs an introspector that has
+     * information necessary for creating instances of given
+     * class ("creator"), as well as class annotations, but
+     * no information on member methods
+     */
+    public abstract T forCreation(DeserializationConfig cfg, JavaType type,
+            MixInResolver r);
+
+    /**
+     * Factory method that constructs an introspector that only has
+     * information regarding annotations class itself (or its supertypes) has,
+     * but nothing on methods or constructors.
+     */
+    public abstract T forClassAnnotations(MapperConfig<?> cfg, JavaType type,
+            MixInResolver r);
+
+    /**
+     * Factory method that constructs an introspector that only has
+     * information regarding annotations class itself has (but NOT including
+     * its supertypes), but nothing on methods or constructors.
+     * 
+     * @since 1.5
+     */
+    public abstract T forDirectClassAnnotations(MapperConfig<?> cfg, JavaType type,
+            MixInResolver r);
+    
+    /*
+    /**********************************************************
+    /* Deprecated methods
+    /**********************************************************
+     */
+    
+    /**
+     * Factory method that constructs an introspector that only has
+     * information regarding annotations class itself (or its supertypes) has,
+     * but nothing on methods or constructors.
+     * 
+     * @deprecated since 1.9, use variant that takes JavaType
+     */
+    @Deprecated
+    public T forClassAnnotations(MapperConfig<?> cfg, Class<?> cls,
+            MixInResolver r) {
+        return forClassAnnotations(cfg, cfg.constructType(cls), r);
+    }
+
+    /**
+     * Factory method that constructs an introspector that only has
+     * information regarding annotations class itself has (but NOT including
+     * its supertypes), but nothing on methods or constructors.
+     * 
+     * @since 1.5
+     * 
+     * @deprecated since 1.9, use variant that takes JavaType
+     */
+    @Deprecated
+    public T forDirectClassAnnotations(MapperConfig<?> cfg, Class<?> cls,
+            MixInResolver r) {
+        return forDirectClassAnnotations(cfg, cfg.constructType(cls), r);
+    }
+}
+