calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,83 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-
-/**
- * Helper class needed to be able to efficiently access class
- * member functions ({@link Method}s and {@link Constructor}s)
- * in {@link java.util.Map}s.
- */
-public final class MemberKey
-{
-    final static Class<?>[] NO_CLASSES = new Class<?>[0];
-
-    final String _name;
-    final Class<?>[] _argTypes;
-
-    public MemberKey(Method m)
-    {
-        this(m.getName(), m.getParameterTypes());
-    }
-
-    public MemberKey(Constructor<?> ctor)
-    {
-        this("", ctor.getParameterTypes());
-    }
-
-    public MemberKey(String name, Class<?>[] argTypes)
-    {
-        _name = name;
-        _argTypes = (argTypes == null) ? NO_CLASSES : argTypes;
-    }
-
-    @Override
-    public String toString() {
-        return _name + "(" + _argTypes.length+"-args)";
-    }
-
-    @Override
-    public int hashCode()
-    {
-        return _name.hashCode() + _argTypes.length;
-    }
-
-    @Override
-    public boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (o.getClass() != getClass()) {
-            return false;
-        }
-        MemberKey other = (MemberKey) o;
-        if (!_name.equals(other._name)) {
-            return false;
-        }
-        Class<?>[] otherArgs = other._argTypes;
-        int len = _argTypes.length;
-        if (otherArgs.length != len) {
-            return false;
-        }
-        for (int i = 0; i < len; ++i) {
-            Class<?> type1 = otherArgs[i];
-            Class<?> type2 = _argTypes[i];
-            if (type1 == type2) {
-                continue;
-            }
-            /* 23-Feb-2009, tatu: Are there any cases where we would have to
-             *   consider some narrowing conversions or such? For now let's
-             *   assume exact type match is enough
-             */
-            /* 07-Apr-2009, tatu: Indeed there are (see [JACKSON-97]).
-             *    This happens with generics when a bound is specified.
-             *    I hope this works; check here must be transitive
-             */
-            if (type1.isAssignableFrom(type2) || type2.isAssignableFrom(type1)) {
-                continue;
-            }
-            return false;
-        }
-        return true;
-    }
-}

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

@@ -1,12 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.reflect.Method;
-
-/**
- * Simple interface that defines API used to filter out irrelevant
- * methods
- */
-public interface MethodFilter
-{
-    public boolean includeMethod(Method m);
-}

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

@@ -1,209 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.lang.annotation.Annotation;
-
-import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
-import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
-import sh.calaba.org.codehaus.jackson.map.KeyDeserializer;
-import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize.Typing;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Dummy, "no-operation" implementation of {@link AnnotationIntrospector}.
- * Can be used as is to suppress handling of annotations; or as a basis
- * for simple complementary annotators
- */
-public class NopAnnotationIntrospector
-    extends AnnotationIntrospector
-{
-    /**
-     * Static immutable and shareable instance that can be used as
-     * "null" introspector: one that never finds any annotation
-     * information.
-     */
-    public final static NopAnnotationIntrospector instance = new NopAnnotationIntrospector();
-
-    /*
-    /**********************************************************
-    /* General annotation properties
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isHandled(Annotation ann) {
-        return false;
-    }
-
-    /*
-    /**********************************************************
-    /* General annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findEnumValue(Enum<?> value) {
-        return null;
-    }
-    
-    /*
-    /**********************************************************
-    /* General Class annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findRootName(AnnotatedClass ac) {
-        return null;
-    }
-
-    @Override
-    public String[] findPropertiesToIgnore(AnnotatedClass ac) {
-        return null;
-    }
-
-    @Override
-    public Boolean findIgnoreUnknownProperties(AnnotatedClass ac) {
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* General member (field, method/constructor) annotations
-    /**********************************************************
-     */
-
-    @Override
-    public boolean hasIgnoreMarker(AnnotatedMember member) {
-        return false;
-    }
-    
-    /*
-    /**********************************************************
-    /* General Method annotations
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isIgnorableConstructor(AnnotatedConstructor c) {
-        return false;
-    }
-
-    @Override
-    public boolean isIgnorableMethod(AnnotatedMethod m) {
-        return false;
-    }
-    
-    /*
-    /**********************************************************
-    /* General field annotations
-    /**********************************************************
-     */
-
-    @Override
-    public boolean isIgnorableField(AnnotatedField f) {
-        return false;
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: general annotations
-    /**********************************************************
-     */
-
-    @Override
-    public Object findSerializer(Annotated am) {
-        return null;
-    }
-
-    @Override
-    public Class<?> findSerializationType(Annotated a) {
-        return null;
-    }
-
-    @Override
-    public Typing findSerializationTyping(Annotated a) {
-        return null;
-    }
-
-    @Override
-    public Class<?>[] findSerializationViews(Annotated a) {
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: class annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
-        return null;
-    }
-
-    @Override
-    public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) {
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Serialization: method annotations
-    /**********************************************************
-     */
-
-    @Override
-    public String findGettablePropertyName(AnnotatedMethod am) {
-        return null;
-    }
-
-    @Override
-    public boolean hasAsValueAnnotation(AnnotatedMethod am) {
-        return false;
-    }
-    
-    @Override
-    public String findDeserializablePropertyName(AnnotatedField af) {
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationContentType(Annotated am, JavaType t, String propName) {
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationKeyType(Annotated am, JavaType t, String propName) {
-        return null;
-    }
-
-    @Override
-    public Class<?> findDeserializationType(Annotated am, JavaType t, String propName) {
-        return null;
-    }
-
-    @Override
-    public Object findDeserializer(Annotated am) { return null; }
-
-    @Override
-    public Class<KeyDeserializer> findKeyDeserializer(Annotated am) { return null; }
-
-    @Override
-    public Class<JsonDeserializer<?>> findContentDeserializer(Annotated am) { return null; }
-
-
-    @Override
-    public String findPropertyNameForParam(AnnotatedParameter param) {
-        return null;
-    }
-
-    @Override
-    public String findSerializablePropertyName(AnnotatedField af) {
-        return null;
-    }
-    
-    @Override
-    public String findSettablePropertyName(AnnotatedMethod am) {
-        return null;
-    }
-}

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

@@ -1,713 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.introspect;
-
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.util.BeanUtil;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Helper class used for aggregating information about all possible
- * properties of a POJO.
- * 
- * @since 1.9
- */
-public class POJOPropertiesCollector
-{
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-    
-    /**
-     * Configuration settings
-     */
-    protected final MapperConfig<?> _config;
-
-    /**
-     * True if introspection is done for serialization (giving
-     *   precedence for serialization annotations), or not (false, deserialization)
-     */
-    protected final boolean _forSerialization;
-    
-    /**
-     * Type of POJO for which properties are being collected.
-     */
-    protected final JavaType _type;
-
-    /**
-     * Low-level introspected class information (methods, fields etc)
-     */
-    protected final AnnotatedClass _classDef;
-
-    protected final VisibilityChecker<?> _visibilityChecker;
-
-    protected final AnnotationIntrospector _annotationIntrospector;
-    
-    /*
-    /**********************************************************
-    /* Collected information
-    /**********************************************************
-     */
-
-    /**
-     * Set of logical property information collected so far
-     */
-    protected final LinkedHashMap<String, POJOPropertyBuilder> _properties
-        = new LinkedHashMap<String, POJOPropertyBuilder>();
-
-    protected LinkedList<POJOPropertyBuilder> _creatorProperties = null;
-    
-    protected LinkedList<AnnotatedMethod> _anyGetters = null;
-
-    protected LinkedList<AnnotatedMethod> _anySetters = null;
-
-    /**
-     * Method(s) marked with 'JsonValue' annotation
-     */
-    protected LinkedList<AnnotatedMethod> _jsonValueGetters = null;
-
-    /**
-     * Lazily collected list of properties that can be implicitly
-     * ignored during serialization; only updated when collecting
-     * information for deserialization purposes
-     */
-    protected Set<String> _ignoredPropertyNames;
-
-    /**
-     * Alternate set of property names that have been marked for
-     * explicit ignoral for deserialization: needed to deal with
-     * 1.x definition of ignorable with respect to "any setter"
-     * (see [JACKSON-313], [JACKSON-383])
-     * 
-     * @since 1.9.4
-     */
-    protected Set<String> _ignoredPropertyNamesForDeser;
-    
-    /**
-     * Lazily collected list of members that were annotated to
-     * indicate that they represent mutators for deserializer
-     * value injection.
-     */
-    protected LinkedHashMap<Object, AnnotatedMember> _injectables;
-    
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-    
-    protected POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization,
-            JavaType type, AnnotatedClass classDef)
-    {
-        _config = config;
-        _forSerialization = forSerialization;
-        _type = type;
-        _classDef = classDef;
-        _annotationIntrospector = config.isAnnotationProcessingEnabled() ?
-                _config.getAnnotationIntrospector() : null;
-        if (_annotationIntrospector == null) {
-            _visibilityChecker = _config.getDefaultVisibilityChecker();
-        } else {
-            _visibilityChecker = _annotationIntrospector.findAutoDetectVisibility(classDef,
-                    _config.getDefaultVisibilityChecker());
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    public MapperConfig<?> getConfig() {
-        return _config;
-    }
-
-    public JavaType getType() {
-        return _type;
-    }
-    
-    public AnnotatedClass getClassDef() {
-        return _classDef;
-    }
-
-    public AnnotationIntrospector getAnnotationIntrospector() {
-        return _annotationIntrospector;
-    }
-    
-    public List<BeanPropertyDefinition> getProperties() {
-        // make sure we return a copy, so caller can remove entries if need be:
-        return new ArrayList<BeanPropertyDefinition>(_properties.values());
-    }
-
-    public Map<Object, AnnotatedMember> getInjectables() {
-        return _injectables;
-    }
-    
-    public AnnotatedMethod getJsonValueMethod()
-    {
-        // If @JsonValue defined, must have a single one
-        if (_jsonValueGetters != null) {
-            if (_jsonValueGetters.size() > 1) {
-                reportProblem("Multiple value properties defined ("+_jsonValueGetters.get(0)+" vs "
-                        +_jsonValueGetters.get(1)+")");
-            }
-            // otherwise we won't greatly care
-            return _jsonValueGetters.get(0);
-        }
-        return null;
-    }
-
-    public AnnotatedMethod getAnyGetterMethod()
-    {
-        if (_anyGetters != null) {
-            if (_anyGetters.size() > 1) {
-                reportProblem("Multiple 'any-getters' defined ("+_anyGetters.get(0)+" vs "
-                        +_anyGetters.get(1)+")");
-            }
-            return _anyGetters.getFirst();
-        }        
-        return null;
-    }
-
-    public AnnotatedMethod getAnySetterMethod()
-    {
-        if (_anySetters != null) {
-            if (_anySetters.size() > 1) {
-                reportProblem("Multiple 'any-setters' defined ("+_anySetters.get(0)+" vs "
-                        +_anySetters.get(1)+")");
-            }
-            return _anySetters.getFirst();
-        }
-        return null;
-    }
-
-    public Set<String> getIgnoredPropertyNames() {
-        return _ignoredPropertyNames;
-    }
-
-    /**
-     * @since 1.9.4
-     */
-    public Set<String> getIgnoredPropertyNamesForDeser() {
-        return _ignoredPropertyNamesForDeser;
-    }
-    
-    // for unit tests:
-    protected Map<String, POJOPropertyBuilder> getPropertyMap() {
-        return _properties;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API: main-level collection
-    /**********************************************************
-     */
-
-    /**
-     * Method that orchestrates collection activities, and needs to be called
-     * after creating the instance.
-     */
-    public POJOPropertiesCollector collect()
-    {
-        _properties.clear();
-        
-        // First: gather basic data
-        _addFields();
-        _addMethods();
-        _addCreators();
-        _addInjectables();
-
-        // Remove ignored properties, individual entries
-        _removeUnwantedProperties();
-
-        // Rename remaining properties
-        _renameProperties();
-        // And use custom naming strategy, if applicable...
-        PropertyNamingStrategy naming = _config.getPropertyNamingStrategy();
-        if (naming != null) {
-            _renameUsing(naming);
-        }
-
-        /* Sort by visibility (explicit over implicit); drop all but first
-         * of member type (getter, setter etc) if there is visibility
-         * difference
-         */
-        for (POJOPropertyBuilder property : _properties.values()) {
-            property.trimByVisibility();
-        }
-
-        // and then the final step, "merge" annotations
-        for (POJOPropertyBuilder property : _properties.values()) {
-            property.mergeAnnotations(_forSerialization);
-        }
-
-        // well, almost last: there's still ordering...
-        _sortProperties();
-        return this;
-    }
-
-    /*
-    /**********************************************************
-    /* Overridable internal methods, sorting
-    /**********************************************************
-     */
-    
-    /* First, order by [JACKSON-90] (explicit ordering and/or alphabetic)
-     * and then for [JACKSON-170] (implicitly order creator properties before others)
-     */
-    protected void _sortProperties()
-    {
-        // Then how about explicit ordering?
-        AnnotationIntrospector intr = _config.getAnnotationIntrospector();
-        boolean sort;
-        Boolean alpha = intr.findSerializationSortAlphabetically(_classDef);
-        
-        if (alpha == null) {
-            sort = _config.shouldSortPropertiesAlphabetically();
-        } else {
-            sort = alpha.booleanValue();
-        }
-        String[] propertyOrder = intr.findSerializationPropertyOrder(_classDef);
-        
-        // no sorting? no need to shuffle, then
-        if (!sort && (_creatorProperties == null) && (propertyOrder == null)) {
-            return;
-        }
-        int size = _properties.size();
-        Map<String, POJOPropertyBuilder> all;
-        // Need to (re)sort alphabetically?
-        if (sort) {
-            all = new TreeMap<String,POJOPropertyBuilder>();
-        } else {
-            all = new LinkedHashMap<String,POJOPropertyBuilder>(size+size);
-        }
-
-        for (POJOPropertyBuilder prop : _properties.values()) {
-            all.put(prop.getName(), prop);
-        }
-        Map<String,POJOPropertyBuilder> ordered = new LinkedHashMap<String,POJOPropertyBuilder>(size+size);
-        // Ok: primarily by explicit order
-        if (propertyOrder != null) {
-            for (String name : propertyOrder) {
-                POJOPropertyBuilder w = all.get(name);
-                if (w == null) { // also, as per [JACKSON-268], we will allow use of "implicit" names
-                    for (POJOPropertyBuilder prop : _properties.values()) {
-                        if (name.equals(prop.getInternalName())) {
-                            w = prop;
-                            // plus re-map to external name, to avoid dups:
-                            name = prop.getName();
-                            break;
-                        }
-                    }
-                }
-                if (w != null) {
-                    ordered.put(name, w);
-                }
-            }
-        }
-        // And secondly by sorting Creator properties before other unordered properties
-        if (_creatorProperties != null) {
-            for (POJOPropertyBuilder prop : _creatorProperties) {
-                ordered.put(prop.getName(), prop);
-            }
-        }
-        // And finally whatever is left (trying to put again will not change ordering)
-        ordered.putAll(all);
-        
-        _properties.clear();
-        _properties.putAll(ordered);
-    }        
-
-    /*
-    /**********************************************************
-    /* Overridable internal methods, adding members
-    /**********************************************************
-     */
-    
-    /**
-     * Method for collecting basic information on all fields found
-     */
-    protected void _addFields()
-    {
-        final AnnotationIntrospector ai = _annotationIntrospector;
-        
-        for (AnnotatedField f : _classDef.fields()) {
-            String implName = f.getName();
-
-            String explName;
-            if (ai == null) {
-                explName = null;
-            } else if (_forSerialization) {
-                /* 18-Aug-2011, tatu: As per existing unit tests, we should only
-                 *   use serialization annotation (@JsonSerializer) when serializing
-                 *   fields, and similarly for deserialize-only annotations... so
-                 *   no fallbacks in this particular case.
-                 */
-                explName = ai.findSerializablePropertyName(f);
-            } else {
-                explName = ai.findDeserializablePropertyName(f);
-            }
-            if ("".equals(explName)) { // empty String meaning "use default name", here just means "same as field name"
-                explName = implName;
-            }
-            // having explicit name means that field is visible; otherwise need to check the rules
-            boolean visible = (explName != null);
-            if (!visible) {
-                visible = _visibilityChecker.isFieldVisible(f);
-            }
-            // and finally, may also have explicit ignoral
-            boolean ignored = (ai != null) && ai.hasIgnoreMarker(f);
-            _property(implName).addField(f, explName, visible, ignored);
-        }
-    }
-
-    /**
-     * Method for collecting basic information on constructor(s) found
-     */
-    protected void _addCreators()
-    {
-        final AnnotationIntrospector ai = _annotationIntrospector;
-        // can be null if annotation processing is disabled...
-        if (ai == null) {
-            return;
-        }
-        for (AnnotatedConstructor ctor : _classDef.getConstructors()) {
-            if (_creatorProperties == null) {
-                _creatorProperties = new LinkedList<POJOPropertyBuilder>();
-            }
-            for (int i = 0, len = ctor.getParameterCount(); i < len; ++i) {
-                AnnotatedParameter param = ctor.getParameter(i);
-                String name = ai.findPropertyNameForParam(param);
-                // is it legal not to have name?
-                if (name != null) {
-                    // shouldn't need to worry about @JsonIgnore (no real point, so)
-                    POJOPropertyBuilder prop = _property(name);
-                    prop.addCtor(param, name, true, false);
-                    _creatorProperties.add(prop);
-                }
-            }
-        }
-        for (AnnotatedMethod factory : _classDef.getStaticMethods()) {
-            if (_creatorProperties == null) {
-                _creatorProperties = new LinkedList<POJOPropertyBuilder>();
-            }
-            for (int i = 0, len = factory.getParameterCount(); i < len; ++i) {
-                AnnotatedParameter param = factory.getParameter(i);
-                String name = ai.findPropertyNameForParam(param);
-                // is it legal not to have name?
-                if (name != null) {
-                    // shouldn't need to worry about @JsonIgnore (no real point, so)
-                    POJOPropertyBuilder prop = _property(name);
-                    prop.addCtor(param, name, true, false);
-                    _creatorProperties.add(prop);
-                }
-            }
-        }
-    }
-
-    /**
-     * Method for collecting basic information on all fields found
-     */
-    protected void _addMethods()
-    {
-        final AnnotationIntrospector ai = _annotationIntrospector;
-        
-        for (AnnotatedMethod m : _classDef.memberMethods()) {
-            String explName; // from annotation(s)
-            String implName; // from naming convention
-            
-            /* For methods, handling differs between getters and setters; and
-             * we will also only consider entries that either follow the bean
-             * naming convention or are explicitly marked: just being visible
-             * is not enough (unlike with fields)
-             */
-            int argCount = m.getParameterCount();
-            boolean visible;
-            
-            if (argCount == 0) { // getters (including 'any getter')
-                // any getter?
-                if (ai != null) {
-                    if (ai.hasAnyGetterAnnotation(m)) {
-                        if (_anyGetters == null) {
-                            _anyGetters = new LinkedList<AnnotatedMethod>();
-                        }
-                        _anyGetters.add(m);
-                        continue;
-                    }
-                    // @JsonValue?
-                    if (ai.hasAsValueAnnotation(m)) {
-                        if (_jsonValueGetters == null) {
-                            _jsonValueGetters = new LinkedList<AnnotatedMethod>();
-                        }
-                        _jsonValueGetters.add(m);
-                        continue;
-                    }
-                }
-                
-                explName = (ai == null) ? null : ai.findGettablePropertyName(m);
-                if (explName == null) { // no explicit name; must follow naming convention
-                    implName = BeanUtil.okNameForRegularGetter(m, m.getName());
-                    if (implName == null) { // if not, must skip
-                        implName = BeanUtil.okNameForIsGetter(m, m.getName());
-                        if (implName == null) {
-                            continue;
-                        }
-                        visible = _visibilityChecker.isIsGetterVisible(m);
-                    } else {
-                        visible = _visibilityChecker.isGetterVisible(m);
-                    }
-                } else { // explicit indication of inclusion, but may be empty
-                    // we still need implicit name to link with other pieces
-                    implName = BeanUtil.okNameForGetter(m);
-                    // if not regular getter name, use method name as is
-                    if (implName == null) {
-                        implName = m.getName();
-                    }
-                    if (explName.length() == 0) {
-                        explName = implName;
-                    }
-                    visible = true;
-                }
-                boolean ignore = (ai == null) ? false : ai.hasIgnoreMarker(m);
-                _property(implName).addGetter(m, explName, visible, ignore);
-            } else if (argCount == 1) { // setters
-                explName = (ai == null) ? null : ai.findSettablePropertyName(m);
-                if (explName == null) { // no explicit name; must follow naming convention
-                    implName = BeanUtil.okNameForSetter(m);
-                    if (implName == null) { // if not, must skip
-                        continue;
-                    }
-                    visible = _visibilityChecker.isSetterVisible(m);
-                } else { // explicit indication of inclusion, but may be empty
-                    // we still need implicit name to link with other pieces
-                    implName = BeanUtil.okNameForSetter(m);
-                    // if not regular getter name, use method name as is
-                    if (implName == null) {
-                        implName = m.getName();
-                    }
-                    if (explName.length() == 0) { 
-                        explName = implName;
-                    }
-                    visible = true;
-                }
-                boolean ignore = (ai == null) ? false : ai.hasIgnoreMarker(m);
-                _property(implName).addSetter(m, explName, visible, ignore);
-
-            } else if (argCount == 2) { // any getter?
-                if (ai != null  && ai.hasAnySetterAnnotation(m)) {
-                    if (_anySetters == null) {
-                        _anySetters = new LinkedList<AnnotatedMethod>();
-                    }
-                    _anySetters.add(m);
-                }
-            }
-        }
-    }
-
-    protected void _addInjectables()
-    {
-        final AnnotationIntrospector ai = _annotationIntrospector;
-        if (ai == null) {
-            return;
-        }
-        
-        // first fields, then methods
-        for (AnnotatedField f : _classDef.fields()) {
-            _doAddInjectable(ai.findInjectableValueId(f), f);
-        }
-        
-        for (AnnotatedMethod m : _classDef.memberMethods()) {
-            /* for now, only allow injection of a single arg
-             * (to be changed in future)
-             */
-            if (m.getParameterCount() != 1) {
-                continue;
-            }
-            _doAddInjectable(ai.findInjectableValueId(m), m);
-        }
-    }
-
-    protected void _doAddInjectable(Object id, AnnotatedMember m)
-    {
-        if (id == null) {
-            return;
-        }
-        if (_injectables == null) {
-            _injectables = new LinkedHashMap<Object, AnnotatedMember>();
-        }
-        AnnotatedMember prev = _injectables.put(id, m);
-        if (prev != null) {
-            String type = (id == null) ? "[null]" : id.getClass().getName();
-            throw new IllegalArgumentException("Duplicate injectable value with id '"
-                    +String.valueOf(id)+"' (of type "+type+")");
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods; removing ignored properties
-    /**********************************************************
-     */
-
-    /**
-     * Method called to get rid of candidate properties that are marked
-     * as ignored, or that are not visible.
-     */
-    protected void _removeUnwantedProperties()
-    {
-        Iterator<Map.Entry<String,POJOPropertyBuilder>> it = _properties.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry<String, POJOPropertyBuilder> entry = it.next();
-            POJOPropertyBuilder prop = entry.getValue();
-
-            // First: if nothing visible, just remove altogether
-            if (!prop.anyVisible()) {
-                it.remove();
-                continue;
-            }
-            // Otherwise, check ignorals
-            if (prop.anyIgnorals()) {
-                _addIgnored(prop);
-                // first: if one or more ignorals, and no explicit markers, remove the whole thing
-                if (!prop.anyExplicitNames()) {
-                    it.remove();
-                    continue;
-                }
-                // otherwise just remove explicitly ignored (and retain others)
-                prop.removeIgnored();
-            }
-            // and finally, handle removal of individual non-visible elements
-            prop.removeNonVisible();
-        }
-    }
-    
-    private void _addIgnored(POJOPropertyBuilder prop)
-    {
-        // not used in any way for serialization side:
-        if (_forSerialization) {
-            return;
-        }
-        /* and with deserialization, two aspects: whether it's ok to see
-         * property ('ignore for failure reporting') and whether we forcifully
-         * ignore it even if there was "any setter" available.
-         */
-        // but do not add unless ignoral was for field, setter or ctor param
-        String name = prop.getName();
-        _ignoredPropertyNames = addToSet(_ignoredPropertyNames, name);
-        if (prop.anyDeserializeIgnorals()) {
-            _ignoredPropertyNamesForDeser = addToSet(_ignoredPropertyNamesForDeser, name);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods; renaming properties
-    /**********************************************************
-     */
-
-    protected void _renameProperties()
-    {
-        // With renaming need to do in phases: first, find properties to rename
-        Iterator<Map.Entry<String,POJOPropertyBuilder>> it = _properties.entrySet().iterator();
-        LinkedList<POJOPropertyBuilder> renamed = null;
-        while (it.hasNext()) {
-            Map.Entry<String, POJOPropertyBuilder> entry = it.next();
-            POJOPropertyBuilder prop = entry.getValue();
-            String newName = prop.findNewName();
-            if (newName != null) {
-                if (renamed == null) {
-                    renamed = new LinkedList<POJOPropertyBuilder>();
-                }
-                prop = prop.withName(newName);
-                renamed.add(prop);
-                it.remove();
-            }
-        }
-        
-        // and if any were renamed, merge back in...
-        if (renamed != null) {
-            for (POJOPropertyBuilder prop : renamed) {
-                String name = prop.getName();
-                POJOPropertyBuilder old = _properties.get(name);
-                if (old == null) {
-                    _properties.put(name, prop);
-                } else {
-                    old.addAll(prop);
-                }
-            }
-        }
-    }
-
-    protected void _renameUsing(PropertyNamingStrategy naming)
-    {
-        POJOPropertyBuilder[] props = _properties.values().toArray(new POJOPropertyBuilder[_properties.size()]);
-        _properties.clear();
-        for (POJOPropertyBuilder prop : props) {
-            String name = prop.getName();
-            if (_forSerialization) {
-                if (prop.hasGetter()) {
-                    name = naming.nameForGetterMethod(_config, prop.getGetter(), name);
-                } else if (prop.hasField()) {
-                    name = naming.nameForField(_config, prop.getField(), name);
-                }
-            } else {
-                if (prop.hasSetter()) {
-                    name = naming.nameForSetterMethod(_config, prop.getSetter(), name);
-                } else if (prop.hasConstructorParameter()) {
-                    name = naming.nameForConstructorParameter(_config, prop.getConstructorParameter(), name);
-                } else if (prop.hasField()) {
-                    name = naming.nameForField(_config, prop.getField(), name);
-                } else if (prop.hasGetter()) {
-                    /* Plus, when getter-as-setter is used, need to convert that too..
-                     * (should we verify that's enabled? For now, assume it's ok always)
-                     */
-                    name = naming.nameForGetterMethod(_config, prop.getGetter(), name);
-                }
-            }
-            if (!name.equals(prop.getName())) {
-                prop = prop.withName(name);
-            }
-            /* As per [JACKSON-687], need to consider case where there may already be
-             * something in there...
-             */
-            POJOPropertyBuilder old = _properties.get(name);
-            if (old == null) {
-                _properties.put(name, prop);
-            } else {
-                old.addAll(prop);
-            }
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods; helpers
-    /**********************************************************
-     */
-
-    protected void reportProblem(String msg) {
-        throw new IllegalArgumentException("Problem with definition of "+_classDef+": "+msg);
-    }
-    
-    protected POJOPropertyBuilder _property(String implName)
-    {
-        POJOPropertyBuilder prop = _properties.get(implName);
-        if (prop == null) {
-            prop = new POJOPropertyBuilder(implName);
-            _properties.put(implName, prop);
-        }
-        return prop;
-    }
-
-    private Set<String> addToSet(Set<String> set, String str)
-    {
-        if (set == null) {
-            set = new HashSet<String>();
-        }
-        set.add(str);
-        return set;
-    }        
-}