classmate、jpa移包

depedence-adapter/README.md

@@ -1,3 +0,0 @@
-# dependence-adapter
-
-该模块为一个辅助的中间模块，为改过包名的第三方包之间的相互引用作适配

depedence-adapter/src/com/fr/third/adapter/druid/DruidConnectionProvider.java

@@ -1,65 +0,0 @@
-package com.fr.third.adapter.druid;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Map;
-
-import com.fr.third.org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
-import com.fr.third.org.hibernate.service.spi.Configurable;
-import com.fr.third.org.hibernate.service.spi.Stoppable;
-
-import com.fr.third.alibaba.druid.pool.DruidDataSource;
-import com.fr.third.alibaba.druid.pool.DruidDataSourceFactory;
-
-public class DruidConnectionProvider implements ConnectionProvider, Configurable, Stoppable {
-
-    private static final long serialVersionUID = 1026193803901107651L;
-
-    private DruidDataSource   dataSource;
-
-    public DruidConnectionProvider(){
-        dataSource = new DruidDataSource();
-    }
-
-    @SuppressWarnings("rawtypes")
-    @Override
-    public boolean isUnwrappableAs(Class unwrapType) {
-        return dataSource.isWrapperFor(unwrapType);
-    }
-
-    @Override
-    public <T> T unwrap(Class<T> unwrapType) {
-        return dataSource.unwrap(unwrapType);
-    }
-
-    @Override
-    public Connection getConnection() throws SQLException {
-        return dataSource.getConnection();
-    }
-
-    @Override
-    public void closeConnection(Connection conn) throws SQLException {
-        conn.close();
-    }
-
-    @Override
-    public boolean supportsAggressiveRelease() {
-        return false;
-    }
-
-    @SuppressWarnings("rawtypes")
-    @Override
-    public void configure(Map configurationValues) {
-        try {
-            DruidDataSourceFactory.config(dataSource, configurationValues);
-        } catch (SQLException e) {
-            throw new IllegalArgumentException("config error", e);
-        }
-    }
-
-    @Override
-    public void stop() {
-        dataSource.close();
-    }
-
-}

fine-classmate/README.md

@@ -0,0 +1,6 @@
+# fine-classmate
+
+改包名的classmate（1.3.0），以下模块需要依赖该模块：
+
+- fine-hibernate
+

fine-classmate/fine-classmate.iml

@@ -7,7 +7,5 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="module" module-name="fine-druid" />
-    <orderEntry type="module" module-name="fine-hibernate" />
   </component>
 </module>

fine-classmate/src/com/fasterxml/classmate/AnnotationConfiguration.java

@@ -0,0 +1,115 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.util.*;
+
+import com.fasterxml.classmate.util.ClassKey;
+
+/**
+ * Interface for object that determines handling of annotations in regards
+ * to inheritance, overrides.
+ */
+@SuppressWarnings("serial")
+public abstract class AnnotationConfiguration implements Serializable
+{
+    /**
+     * Method called to figure out how to handle instances of specified annotation
+     * type when used as class annotation.
+     */
+    public abstract AnnotationInclusion getInclusionForClass(Class<? extends Annotation> annotationType);
+
+    /**
+     * Method called to figure out how to handle instances of specified annotation
+     * type when used as constructor annotation.
+     *<p>
+     * Note that constructor annotations can never be inherited so this just determines
+     * between inclusion or non-inclusion.
+     */
+    public abstract AnnotationInclusion getInclusionForConstructor(Class<? extends Annotation> annotationType);
+    
+    /**
+     * Method called to figure out how to handle instances of specified annotation
+     * type when used as field annotation.
+     *<p>
+     * Note that field annotations can never be inherited so this just determines
+     * between inclusion or non-inclusion.
+     */
+    public abstract AnnotationInclusion getInclusionForField(Class<? extends Annotation> annotationType);
+    
+    /**
+     * Method called to figure out how to handle instances of specified annotation
+     * type when used as method annotation.
+     *<p>
+     * Note that method annotations can be inherited for member methods, but not for static
+     * methods; for static methods thereby this just determines between inclusion and
+     * non-inclusion.
+     */
+    public abstract AnnotationInclusion getInclusionForMethod(Class<? extends Annotation> annotationType);
+
+    /**
+     * Method called to figure out how to handle instances of specified annotation
+     * type when used as parameter annotation.
+     *<p>
+     * Note that parameter annotations can be inherited for member methods, but not for static
+     * methods; for static methods thereby this just determines between inclusion and
+     * non-inclusion.
+     */
+    public abstract AnnotationInclusion getInclusionForParameter(Class<? extends Annotation> annotationType);
+    
+    /**
+     * Simple implementation that can be configured with default behavior
+     * for unknown annotations, as well as explicit behaviors for
+     * enumerated annotation types. Same default is used for both class and
+     * member method annotations (constructor, field and static method
+     * annotations are never inherited)
+     */
+    public static class StdConfiguration extends AnnotationConfiguration implements Serializable
+    {
+        protected final AnnotationInclusion _defaultInclusion;
+
+        protected final HashMap<ClassKey,AnnotationInclusion> _inclusions = new HashMap<ClassKey,AnnotationInclusion>();
+        
+        public StdConfiguration(AnnotationInclusion defaultBehavior)
+        {
+            _defaultInclusion = defaultBehavior;
+        }
+        
+        @Override
+        public AnnotationInclusion getInclusionForClass(Class<? extends Annotation> annotationType) {
+            return _inclusionFor(annotationType);
+        }
+
+        @Override
+        public AnnotationInclusion getInclusionForConstructor(Class<? extends Annotation> annotationType) {
+            return _inclusionFor(annotationType);
+        }
+
+        @Override
+        public AnnotationInclusion getInclusionForField(Class<? extends Annotation> annotationType) {
+            return getInclusionForClass(annotationType);
+        }
+        
+        @Override
+        public AnnotationInclusion getInclusionForMethod(Class<? extends Annotation> annotationType) {
+            return getInclusionForClass(annotationType);
+        }
+
+        @Override
+        public AnnotationInclusion getInclusionForParameter(Class<? extends Annotation> annotationType) {
+            return getInclusionForClass(annotationType);
+        }
+
+        public void setInclusion(Class<? extends Annotation> annotationType, AnnotationInclusion incl)
+        {
+            _inclusions.put(new ClassKey(annotationType), incl);
+        }
+
+        protected AnnotationInclusion _inclusionFor(Class<? extends Annotation> annotationType)
+        {
+            ClassKey key = new ClassKey(annotationType);
+            AnnotationInclusion beh = _inclusions.get(key);
+            return (beh == null) ? _defaultInclusion : beh;
+        }
+    }
+}

fine-classmate/src/com/fasterxml/classmate/AnnotationInclusion.java

@@ -0,0 +1,44 @@
+package com.fasterxml.classmate;
+
+/**
+ * Enumeration that defines different settings for handling behavior
+ * of individual annotations
+ */
+public enum AnnotationInclusion
+{
+    /**
+     * Value that indicates that annotation is to be ignored, not included
+     * in resolved bean information.
+     * Applicable to all member types.
+     */
+    DONT_INCLUDE,
+
+    /**
+     * Value that indicates that annotation is to be included in results, but
+     * only if directly associated with included member (or attached mix-in);
+     * will not inherit from supertypes.
+     * Applicable only to member methods; if used with other members will
+     * mean basic inclusion.
+     */
+    INCLUDE_BUT_DONT_INHERIT,
+
+    /**
+     * Value that indicates that annotation is to be included in results, and
+     * values from overridden members are inherited only if the annotation is
+     * marked with the {@link java.lang.annotation.Inherited} annotation.
+     * Applicable only to member methods; if used with other members will
+     * mean basic inclusion.
+     */
+    INCLUDE_AND_INHERIT_IF_INHERITED,
+
+    /**
+     * Value that indicates that annotation is to be included in results; and
+     * values from overridden members are also inherited if not overridden
+     * by members of subtypes.
+     * Note that inheritance only matters with member methods; for other types
+     * it just means "include".
+     */
+    INCLUDE_AND_INHERIT
+    ;
+
+}

fine-classmate/src/com/fasterxml/classmate/AnnotationOverrides.java

@@ -0,0 +1,100 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+import java.util.*;
+
+import com.fasterxml.classmate.util.ClassKey;
+
+/**
+ * Interface for object that can provide mix-ins to override annotations.
+ */
+@SuppressWarnings("serial")
+public abstract class AnnotationOverrides implements Serializable
+{
+    /*
+    /**********************************************************************
+    /* Public API
+    /**********************************************************************
+     */
+
+    /**
+     * Method called to find out which class(es) are to be used as source
+     * for annotations to mix in for given type.
+     * 
+     * @return List of mix-in sources (starting with  highest priority); 
+     *   can be null or empty list if no mix-ins are to be used.
+     */
+    public List<Class<?>> mixInsFor(Class<?> beanClass) {
+        return mixInsFor(new ClassKey(beanClass));
+    }
+
+    public abstract List<Class<?>> mixInsFor(ClassKey beanClass);
+
+    /**
+     * Method for constructing builder for creating simple overrides provider
+     * that just uses direct assignments (target-to-override classes)
+     */
+    public static StdBuilder builder() {
+        return new StdBuilder();
+    }
+
+    /*
+    /**********************************************************************
+    /* Helper types
+    /**********************************************************************
+     */
+    
+    /**
+     * To make it easy to use simple override implementation (where overrides
+     * are direct and explicit), here is a build that allow constructing
+     * such override instance.
+     */
+    public static class StdBuilder
+    {
+        protected final HashMap<ClassKey,List<Class<?>>> _targetsToOverrides = new HashMap<ClassKey,List<Class<?>>>();
+
+        public StdBuilder() { }
+
+        public StdBuilder add(Class<?> target, Class<?> mixin) {
+            return add(new ClassKey(target), mixin);
+        }
+
+        public StdBuilder add(ClassKey target, Class<?> mixin)
+        {
+            List<Class<?>> mixins = _targetsToOverrides.get(target);
+            if (mixins == null) {
+                mixins = new ArrayList<Class<?>>();
+                _targetsToOverrides.put(target, mixins);
+            }
+            mixins.add(mixin);
+            return this;
+        }
+        
+        /**
+         * Method that will construct a {@link AnnotationOverrides} instance using
+         * mappings that have been added using this builder
+         */
+        public AnnotationOverrides build() {
+            return new StdImpl(_targetsToOverrides);
+        }
+    }
+    
+    /**
+     * Simple implementation configured with explicit associations with
+     * target class as key, and overrides as ordered list of classes
+     * (with first entry having precedence over later ones).
+     */
+    public static class StdImpl extends AnnotationOverrides
+    {
+        protected final HashMap<ClassKey,List<Class<?>>> _targetsToOverrides;
+        
+        public StdImpl(HashMap<ClassKey,List<Class<?>>> overrides) {
+            _targetsToOverrides = new HashMap<ClassKey,List<Class<?>>>(overrides);
+        }
+
+        @Override
+        public List<Class<?>> mixInsFor(ClassKey target) {
+            return _targetsToOverrides.get(target);
+        }
+    }
+}

fine-classmate/src/com/fasterxml/classmate/Annotations.java

@@ -0,0 +1,132 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.util.*;
+
+/**
+ * Container class used for storing set of annotations resolved for types (classes)
+ * as members (methods, fields, constructors).
+ * 
+ * @author tatu
+ */
+@SuppressWarnings("serial")
+public class Annotations implements Serializable, Iterable<Annotation>
+{
+    private final Annotation[] NO_ANNOTATIONS = new Annotation[0];
+     
+    protected LinkedHashMap<Class<? extends Annotation>,Annotation> _annotations;
+
+    /*
+    /**********************************************************************
+    /* Life-cycle
+    /**********************************************************************
+     */
+    
+    public Annotations() { }
+
+    /**
+     * Method for adding specified annotation, overriding existing value
+     * for the annotation type.
+     */
+    public void add(Annotation override)
+    {
+        if (_annotations == null) {
+            _annotations = new LinkedHashMap<Class<? extends Annotation>,Annotation>();
+        }
+        _annotations.put(override.annotationType(), override);
+    }
+
+    /**
+     * Method for adding all annotations from specified set, as overrides
+     * to annotations this set has
+     */
+    public void addAll(Annotations overrides)
+    {
+        if (_annotations == null) {
+            _annotations = new LinkedHashMap<Class<? extends Annotation>,Annotation>();
+        }
+        for (Annotation override : overrides._annotations.values()) {
+            _annotations.put(override.annotationType(), override);
+        }
+    }
+    
+    /**
+     * Method for adding specified annotation if and only if no value
+     * exists for the annotation type.
+     */
+    public void addAsDefault(Annotation defValue)
+    {
+        Class<? extends Annotation> type = defValue.annotationType();
+        if (_annotations == null) {
+            _annotations = new LinkedHashMap<Class<? extends Annotation>,Annotation>();
+            _annotations.put(type, defValue);
+        } else if (!_annotations.containsKey(type)) {
+            _annotations.put(type, defValue);
+        }
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public Iterator<Annotation> iterator()
+    {
+        if (_annotations == null) {
+            _annotations = new LinkedHashMap<Class<? extends Annotation>,Annotation>();
+        }
+        return _annotations.values().iterator();
+    }
+    
+    public int size() {
+        return (_annotations == null) ? 0 : _annotations.size();
+    }
+
+    @SuppressWarnings("unchecked")
+    public <A extends Annotation> A get(Class<A> cls)
+    {
+        if (_annotations == null) {
+            return null;
+        }
+        return (A) _annotations.get(cls);
+    }
+
+    /**
+     * @since 1.1.1
+     */
+    public Annotation[] asArray() {
+         if (_annotations == null || _annotations.isEmpty()) {
+              return NO_ANNOTATIONS;
+         }
+         return _annotations.values().toArray(new Annotation[_annotations.size()]);
+    }
+
+    /**
+     * @since 1.1.1
+     */
+    public List<Annotation> asList() {
+         if (_annotations == null || _annotations.isEmpty()) {
+              return Collections.emptyList();
+         }
+         List<Annotation> l = new ArrayList<Annotation>(_annotations.size());
+         l.addAll(_annotations.values());
+         return l;
+    }
+
+    /*
+    /**********************************************************************
+    /* Standard method overrides
+    /**********************************************************************
+     */
+    
+    @Override public String toString()
+    {
+        if (_annotations == null) {
+            return "[null]";
+        }
+        return _annotations.toString();
+    }
+}

fine-classmate/src/com/fasterxml/classmate/Filter.java

@@ -0,0 +1,10 @@
+package com.fasterxml.classmate;
+
+/**
+ * Interface that defines API for basic filtering objects, used to prune set
+ * of things to include in result sets like flattened member lists.
+ */
+public interface Filter<T>
+{
+    public boolean include(T element);
+}

fine-classmate/src/com/fasterxml/classmate/GenericType.java

@@ -0,0 +1,25 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+
+/**
+ * This class is used to pass full generics type information, and
+ * avoid problems with type erasure (that basically removes most
+ * usable type references from runtime Class objects).
+ * It is based on ideas from
+ * <a href="http://gafter.blogspot.com/2006/12/super-type-tokens.html"
+ * >http://gafter.blogspot.com/2006/12/super-type-tokens.html</a>,
+ *<p>
+ * Usage is by sub-classing: here is one way to instantiate reference
+ * to generic type <code>List&lt;Integer></code>:
+ *<pre>
+ *  GenericType type = new GenericType&lt;List&lt;Integer>>() { };
+ *</pre>
+ * which can be passed to methods that accept <code>GenericReference</code>.
+ */
+@SuppressWarnings("serial")
+public abstract class GenericType<T>
+    implements Serializable, java.lang.reflect.Type
+{
+    protected GenericType() { }
+}

fine-classmate/src/com/fasterxml/classmate/MemberResolver.java

@@ -0,0 +1,235 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+import java.util.*;
+
+import com.fasterxml.classmate.members.*;
+import com.fasterxml.classmate.util.ClassKey;
+
+/**
+ * Builder class used to completely resolve members (fields, methods,
+ * constructors) of {@link ResolvedType}s (generics-aware classes).
+ */
+@SuppressWarnings("serial")
+public class MemberResolver implements Serializable
+{
+    
+    /**
+     * Type resolved needed for resolving types of member objects
+     * (method argument and return; field types; constructor argument types)
+     */
+    protected final TypeResolver _typeResolver;
+    
+    /*
+    /**********************************************************************
+    /* Modifiable configuration
+    /**********************************************************************
+     */
+    
+    /**
+     * Configuration setting that determines whether members from
+     * {@link java.lang.Object} are included or not; by default
+     * false meaning that they are not.
+     */
+    protected boolean _cfgIncludeLangObject;
+
+    /**
+     * Filter used for determining whether given
+     * field (static or member)
+     * is to be included in aggregation of all
+     * fields.
+     */
+    protected Filter<RawField> _fieldFilter;
+
+    /**
+     * Filter used for determining whether given
+     * method (static or member)
+     * is to be included in aggregation of all
+     * methods.
+     */
+    protected Filter<RawMethod> _methodFilter;
+
+    /**
+     * Filter used for determining whether given
+     * constructor
+     * is to be included in aggregation of all
+     * constructors.
+     */
+    protected Filter<RawConstructor> _constructorFilter;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle (construct and config)
+    /**********************************************************************
+     */
+
+    /**
+     * Constructor for resolver that does not include <code>java.lang.Object</code>
+     * in type hierarchy
+     */
+    public MemberResolver(TypeResolver typeResolver)
+    {
+        _typeResolver = typeResolver;
+    }
+
+    /**
+     * Configuration method for specifying whether members of <code>java.lang.Object</code>
+     * are to be included in resolution; if false, no members from {@link java.lang.Object}
+     * are to be included; if true, will be included.
+     */
+    public MemberResolver setIncludeLangObject(boolean state) {
+        _cfgIncludeLangObject = state;
+        return this;
+    }
+
+    public MemberResolver setFieldFilter(Filter<RawField> f) {
+        _fieldFilter = f;
+        return this;
+    }
+
+    public MemberResolver setMethodFilter(Filter<RawMethod> f) {
+        _methodFilter = f;
+        return this;
+    }
+
+    public MemberResolver setConstructorFilter(Filter<RawConstructor> f) {
+        _constructorFilter = f;
+        return this;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Public API
+    /**********************************************************************
+     */
+
+    /**
+     * Method for constructing hierarchy object needed to fully resolve
+     * member information, including basic type flattening as well as
+     * addition of mix-in types in appropriate positions.
+     * 
+     * @param mainType Resolved type that is the starting point (i.e. the leaf class)
+     *    for member resolution.
+     * @param annotationConfig Configuration of annotation types; which ones to include, how to inherit
+     * @param annotationOverrides Definitions of annotation overrides to use, if any (may be null)
+     */
+    public ResolvedTypeWithMembers resolve(final ResolvedType mainType,
+            AnnotationConfiguration annotationConfig,
+            AnnotationOverrides annotationOverrides)
+    {
+        // First: flatten basic type hierarchy (highest to lowest precedence)
+        HashSet<ClassKey> seenTypes = new HashSet<ClassKey>();
+        ArrayList<ResolvedType> types = new ArrayList<ResolvedType>();
+        _gatherTypes(mainType, seenTypes, types);
+
+        // Second step: inject mix-ins (keeping order from highest to lowest)
+        HierarchicType[] htypes;
+        HierarchicType mainHierarchicType = null;
+
+        // Third step: add mix-ins (if any), reverse order (lowest to highest precedence)
+        if (annotationOverrides == null) { // just create hierarchic instances:
+            int len = types.size();
+            htypes = new HierarchicType[len];
+            for (int i = 0; i < len; ++i) {
+                // false -> not a mix-in
+                htypes[i] = new HierarchicType(types.get(i), false, i);
+            }
+            mainHierarchicType = htypes[0];
+        } else { // need to add mix-ins, reorder
+            ArrayList<HierarchicType> typesWithMixins = new ArrayList<HierarchicType>();
+            for (ResolvedType type : types) {
+                // First add mix-ins (which override type itself)
+                List<Class<?>> m = annotationOverrides.mixInsFor(type.getErasedType());
+                if (m != null) {
+                    for (Class<?> mixinClass : m) {
+                        _addOverrides(typesWithMixins, seenTypes, mixinClass);
+                    }
+                }
+
+                // Then actual type:
+                HierarchicType ht = new HierarchicType(type, false, typesWithMixins.size());
+                if (mainHierarchicType == null) {
+                    mainHierarchicType = ht;
+                }
+                typesWithMixins.add(ht);
+            }
+            htypes = typesWithMixins.toArray(new HierarchicType[typesWithMixins.size()]);
+        }
+        // And that's about all we need to do; rest computed lazily
+        return new ResolvedTypeWithMembers(_typeResolver, annotationConfig, mainHierarchicType, htypes,
+                _constructorFilter, _fieldFilter, _methodFilter);
+    }
+
+    private void _addOverrides(List<HierarchicType> typesWithOverrides, Set<ClassKey> seenTypes, Class<?> override)
+    {
+        ClassKey key = new ClassKey(override);
+        if (!seenTypes.contains(key)) {
+            seenTypes.add(key);
+            ResolvedType resolvedOverride = _typeResolver.resolve(override);
+            typesWithOverrides.add(new HierarchicType(resolvedOverride, true, typesWithOverrides.size()));
+            for (ResolvedType r : resolvedOverride.getImplementedInterfaces()) { // interfaces?
+                _addOverrides(typesWithOverrides, seenTypes, r);
+            }
+            ResolvedType superClass = resolvedOverride.getParentClass();
+            _addOverrides(typesWithOverrides, seenTypes, superClass);
+        }
+    }
+
+    private void _addOverrides(List<HierarchicType> typesWithOverrides, Set<ClassKey> seenTypes, ResolvedType override)
+    {
+        if (override == null) return;
+        // first: may need to exclude Object.class:
+        Class<?> raw = override.getErasedType();
+        if (!_cfgIncludeLangObject && Object.class == raw) return;
+        ClassKey key = new ClassKey(raw);
+        if (!seenTypes.contains(key)) {
+            seenTypes.add(key);
+            typesWithOverrides.add(new HierarchicType(override, true, typesWithOverrides.size()));
+            for (ResolvedType r : override.getImplementedInterfaces()) { // interfaces?
+                _addOverrides(typesWithOverrides, seenTypes, r);
+            }
+            ResolvedType superClass = override.getParentClass();
+            if (superClass != null) {
+                _addOverrides(typesWithOverrides, seenTypes, superClass);
+            }
+        }
+    }
+    
+    /*
+    /**********************************************************************
+    /* Internal methods
+    /**********************************************************************
+     */
+    
+    protected void _gatherTypes(ResolvedType currentType, Set<ClassKey> seenTypes, List<ResolvedType> types)
+    {
+        // may get called with null if no parent type
+        if (currentType == null) {
+            return;
+        }
+        Class<?> raw = currentType.getErasedType();
+        // Also, don't include Object.class unless that's ok
+        if (!_cfgIncludeLangObject && raw == Object.class) {
+            return;
+        }
+        // Finally, only include first instance of an interface, so:
+        ClassKey key = new ClassKey(currentType.getErasedType());
+        if (seenTypes.contains(key)) {
+            return;
+        }
+        // If all good so far, append
+        seenTypes.add(key);
+        types.add(currentType);
+        /* and check supertypes; starting with interfaces. Why interfaces?
+         * So that "highest" interfaces get priority; otherwise we'd recurse
+         * super-class stack and actually start with the bottom. Usually makes
+         * little difference, but in cases where it does this seems like the
+         * correct order.
+         */
+        for (ResolvedType t : currentType.getImplementedInterfaces()) {
+            _gatherTypes(t, seenTypes, types);
+        }
+        // and then superclass
+        _gatherTypes(currentType.getParentClass(), seenTypes, types);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/ResolvedType.java

@@ -0,0 +1,399 @@
+package com.fasterxml.classmate;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import com.fasterxml.classmate.members.*;
+
+public abstract class ResolvedType
+    implements Type
+{
+    public final static ResolvedType[] NO_TYPES = new ResolvedType[0];
+
+    protected final static RawConstructor[] NO_CONSTRUCTORS = new RawConstructor[0];
+    protected final static RawField[] NO_FIELDS = new RawField[0];
+    protected final static RawMethod[] NO_METHODS = new RawMethod[0];
+    
+    protected final Class<?> _erasedType;
+
+    /**
+     * Type bindings active when resolving members (methods, fields,
+     * constructors) of this type
+     */
+    protected final TypeBindings _typeBindings;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    protected ResolvedType(Class<?> cls, TypeBindings bindings)
+    {
+        _erasedType = cls;
+        _typeBindings = (bindings == null) ? TypeBindings.emptyBindings() : bindings;
+    }
+    
+    /**
+     * Method that can be used to check if call to {@link TypeResolver#resolveSubtype(ResolvedType, Class)}
+     * may ever succeed; if false, it will fail with an exception, if true, it may succeed.
+     */
+    public abstract boolean canCreateSubtypes();
+
+    /**
+     * Method that can be used to check if call to {@link TypeResolver#resolveSubtype(ResolvedType, Class)}
+     * will succeed for specific type; if false, it will fail with an exception; if tru it
+     * will succeed.
+     */
+    public final boolean canCreateSubtype(Class<?> subtype) {
+        return canCreateSubtypes() && _erasedType.isAssignableFrom(subtype);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    /**
+     * Returns type-erased Class<?> that this resolved type has.
+     */
+    public Class<?> getErasedType() { return _erasedType; }
+
+    /**
+     * Returns parent class of this type, if it has one; primitive types
+     * and interfaces have no parent class, nor does Object type
+     * {@link java.lang.Object}.
+     * Also, placeholders for cyclic (recursive) types return null for
+     * this method.
+     */
+    public abstract ResolvedType getParentClass();
+
+    /**
+     * Accessor that must be used to find out actual type in
+     * case of "self-reference"; case where type refers
+     * recursive to itself (like, <code>T implements Comparable&lt;T></code>).
+     * For all other types returns null but for self-references "real" type.
+     * Separate accessor is provided to avoid accidental infinite loops.
+     */
+    public abstract ResolvedType getSelfReferencedType();
+    
+    /**
+     * Method that can be used to access element type of array types; will return
+     * null for non-array types, and non-null type for array types.
+     */
+    public abstract ResolvedType getArrayElementType();
+
+    /**
+     * Returns ordered list of interfaces (in declaration order) that this type
+     * implements.
+     * 
+     * @return List of interfaces this type implements, if any; empty list if none
+     */
+    public abstract List<ResolvedType> getImplementedInterfaces();
+
+    /**
+     * Returns list of generic type declarations for this type, in order they
+     * are declared in class description.
+     */
+    public List<ResolvedType> getTypeParameters() {
+        return _typeBindings.getTypeParameters();
+    }
+
+    /**
+     * Method for accessing bindings of type variables to resolved types in context
+     * of this type. It has same number of entries as return List of
+     * {@link #getTypeParameters}, accessible using declared name to which they
+     * bind; for example, {@link java.util.Map} has 2 type bindings; one for
+     * key type (name "K", from Map.java) and one for value type
+     * (name "V", from Map.java).
+     */
+    public TypeBindings getTypeBindings() { return _typeBindings; }
+    
+    /**
+     * Method that will try to find type parameterization this type
+     * has for specified super type
+     * 
+     * @return List of type parameters for specified supertype (which may
+     *   be empty, if supertype is not a parametric type); null if specified
+     *   type is not a super type of this type
+     */
+    public List<ResolvedType> typeParametersFor(Class<?> erasedSupertype)
+    {
+        ResolvedType type = findSupertype(erasedSupertype);
+        if (type != null) {
+            return type.getTypeParameters();
+        }
+        // nope; doesn't look like we extend or implement super type in question
+        return null;
+    }
+
+    /**
+     * Method for finding super type of this type that has specified type
+     * erased signature. If supertype is an interface which is implemented
+     * using multiple inheritance paths, preference is given to interfaces
+     * implemented "highest up the stack" (directly implemented interfaces
+     * over interfaces superclass implements).
+     */
+    public ResolvedType findSupertype(Class<?> erasedSupertype)
+    {
+        if (erasedSupertype == _erasedType) {
+            return this;
+        }
+        // Check super interfaces first:
+        if (erasedSupertype.isInterface()) {
+            for (ResolvedType it : getImplementedInterfaces()) {
+                ResolvedType type = it.findSupertype(erasedSupertype);
+                if (type != null) {
+                    return type;
+                }
+            }
+        }
+        // and if not found, super class and its supertypes
+        ResolvedType pc = getParentClass();
+        if (pc != null) {
+            ResolvedType type = pc.findSupertype(erasedSupertype);
+            if (type != null) {
+                return type;
+            }
+        }
+        // nope; doesn't look like we extend or implement super type in question
+        return null;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for simple properties
+    /**********************************************************************
+     */
+    
+    public abstract boolean isInterface();
+    public final boolean isConcrete() { return !isAbstract(); }
+    public abstract boolean isAbstract();
+
+    /**
+     * Method that indicates whether this type is an array type.
+     */
+    public abstract boolean isArray();
+
+    /**
+     * Method that indicates whether this type is one of small number of primitive
+     * Java types; not including array types of primitive types but just basic
+     * primitive types.
+     */
+    public abstract boolean isPrimitive();
+
+    public final boolean isInstanceOf(Class<?> type) {
+        return type.isAssignableFrom(_erasedType);
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+
+    public List<RawConstructor> getConstructors() { return Collections.emptyList(); }
+    public List<RawField> getMemberFields() { return Collections.emptyList(); }
+    public List<RawMethod> getMemberMethods() { return Collections.emptyList(); }
+    public List<RawField> getStaticFields() { return Collections.emptyList(); }
+    public List<RawMethod> getStaticMethods() { return Collections.emptyList(); }
+
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    /**
+     * Method that returns full generic signature of the type; suitable
+     * as signature for things like ASM package.
+     */
+    public String getSignature() {
+        StringBuilder sb = new StringBuilder();
+        return appendSignature(sb).toString();
+    }
+
+    /**
+     * Method that returns type erased signature of the type; suitable
+     * as non-generic signature some packages need
+     */
+    public String getErasedSignature() {
+        StringBuilder sb = new StringBuilder();
+        return appendErasedSignature(sb).toString();
+    }
+
+    /**
+     * Human-readable full description of type, which includes specification
+     * of super types (in brief format)
+     */
+    public String getFullDescription() {
+        StringBuilder sb = new StringBuilder();
+        return appendFullDescription(sb).toString();
+    }
+
+    /**
+     * Human-readable brief description of type, which does not include
+     * information about super types.
+     */
+    public String getBriefDescription() {
+        StringBuilder sb = new StringBuilder();
+        return appendBriefDescription(sb).toString();
+    }
+
+    public abstract StringBuilder appendBriefDescription(StringBuilder sb);
+    public abstract StringBuilder appendFullDescription(StringBuilder sb);
+    public abstract StringBuilder appendSignature(StringBuilder sb);
+    public abstract StringBuilder appendErasedSignature(StringBuilder sb);
+    
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public String toString() {
+        return getBriefDescription();
+    }
+
+    @Override public int hashCode() {
+        return _erasedType.getName().hashCode() + _typeBindings.hashCode();
+    }
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        // sub-types must be same:
+        if (o == null || o.getClass() != getClass()) return false;
+        // Should be possible to actually implement here...
+        ResolvedType other = (ResolvedType) o;
+        if (other._erasedType != _erasedType) {
+            return false;
+        }
+        // and type bindings must match as well
+        return _typeBindings.equals(other._typeBindings);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Helper methods for sub-classes; string construction
+    /**********************************************************************
+     */
+    
+    protected StringBuilder _appendClassSignature(StringBuilder sb)
+    {
+        sb.append('L');
+        sb = _appendClassName(sb);
+        int count = _typeBindings.size();
+        if (count > 0) {
+            sb.append('<');
+            for (int i = 0; i < count; ++i) {
+                sb = _typeBindings.getBoundType(i).appendErasedSignature(sb);
+            }
+            sb.append('>');
+        }
+        sb.append(';');
+        return sb;
+    }
+
+    protected StringBuilder _appendErasedClassSignature(StringBuilder sb)
+    {
+        sb.append('L');
+        sb = _appendClassName(sb);
+        sb.append(';');
+        return sb;
+    }
+
+    protected StringBuilder _appendClassDescription(StringBuilder sb)
+    {
+        sb.append(_erasedType.getName());
+        int count = _typeBindings.size();
+        if (count > 0) {
+            sb.append('<');
+            for (int i = 0; i < count; ++i) {
+                if (i > 0) {
+                    sb.append(',');
+                }
+                sb = _typeBindings.getBoundType(i).appendBriefDescription(sb);
+            }
+            sb.append('>');
+        }
+        return sb;
+    }
+    
+    protected StringBuilder _appendClassName(StringBuilder sb)
+    {
+        String name = _erasedType.getName();
+        for (int i = 0, len = name.length(); i < len; ++i) {
+            char c = name.charAt(i);
+            if (c == '.') c = '/';
+            sb.append(c);
+        }
+        return sb;
+    }
+
+    /*
+    /**********************************************************************
+    /* Helper methods for sub-classes; gathering members
+    /**********************************************************************
+     */
+    
+    /**
+     * @param statics Whether to return static methods (true) or member methods (false)
+     */
+    protected RawField[] _getFields(boolean statics)
+    {
+        ArrayList<RawField> fields = new ArrayList<RawField>();
+        for (Field f : _erasedType.getDeclaredFields()) {
+            // Only skip synthetic fields, which should not really be exposed
+            if (!f.isSynthetic()) {
+                if (Modifier.isStatic(f.getModifiers()) == statics) {
+                    fields.add(new RawField(this, f));
+                }
+            }
+        }
+        if (fields.isEmpty()) {
+            return NO_FIELDS;
+        }
+        return fields.toArray(new RawField[fields.size()]);
+    }
+
+    /**
+     * @param statics Whether to return static methods (true) or member methods (false)
+     */
+    protected RawMethod[] _getMethods(boolean statics)
+    {
+        ArrayList<RawMethod> methods = new ArrayList<RawMethod>();
+        for (Method m : _erasedType.getDeclaredMethods()) {
+            // Only skip synthetic fields, which should not really be exposed
+            if (!m.isSynthetic()) {
+                if (Modifier.isStatic(m.getModifiers()) == statics) {
+                    methods.add(new RawMethod(this, m));
+                }
+            }
+        }
+        if (methods.isEmpty()) {
+            return NO_METHODS;
+        }
+        return methods.toArray(new RawMethod[methods.size()]);
+    }
+
+    protected RawConstructor[] _getConstructors()
+    {
+        ArrayList<RawConstructor> ctors = new ArrayList<RawConstructor>();
+        for (Constructor<?> c : _erasedType.getDeclaredConstructors()) {
+            // Only skip synthetic fields, which should not really be exposed
+            if (!c.isSynthetic()) {
+                ctors.add(new RawConstructor(this, c));
+            }
+        }
+        if (ctors.isEmpty()) {
+            return NO_CONSTRUCTORS;
+        }
+        return ctors.toArray(new RawConstructor[ctors.size()]);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/ResolvedTypeWithMembers.java

@@ -0,0 +1,715 @@
+package com.fasterxml.classmate;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Inherited;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import com.fasterxml.classmate.members.*;
+import com.fasterxml.classmate.util.MethodKey;
+
+/**
+ * Class that contains information about fully resolved members of a
+ * type; resolution meaning that masking is handled for methods, and
+ * all inheritable annotations are flattened using optional overrides
+ * as well ("mix-in annotations").
+ * Instances are created by {@link com.fasterxml.classmate.MemberResolver}.
+ *<p>
+ * Note that instances are not thread-safe, as the expectation is that instances
+ * will not be shared (unlike raw members or resolved types)
+ */
+public class ResolvedTypeWithMembers
+{
+    private final static ResolvedType[] NO_RESOLVED_TYPES = new ResolvedType[0];
+
+    private final static ResolvedMethod[] NO_RESOLVED_METHODS = new ResolvedMethod[0];
+    private final static ResolvedField[] NO_RESOLVED_FIELDS = new ResolvedField[0];
+    private final static ResolvedConstructor[] NO_RESOLVED_CONSTRUCTORS = new ResolvedConstructor[0];
+    
+    /**
+     * Default annotation configuration is to ignore all annotations types.
+     */
+    protected final static AnnotationConfiguration DEFAULT_ANNOTATION_CONFIG
+        = new AnnotationConfiguration.StdConfiguration(AnnotationInclusion.DONT_INCLUDE);
+
+    /**
+     * Need to be able to resolve member types still
+     */
+    protected final TypeResolver _typeResolver;
+
+    /**
+     * Handler for resolving annotation information
+     */
+    protected final AnnotationHandler _annotationHandler;
+    
+    /**
+     * Leaf of the type hierarchy, i.e. type from which this hierarchy
+     * was generated.
+     */
+    protected final HierarchicType _mainType;
+
+    /**
+     * All types that hierarchy contains, in order of increasing precedence
+     * (that is, later entries override members of earlier members)
+     */
+    protected final HierarchicType[] _types;
+
+    /**
+     * Filter to use for selecting fields to include
+     */
+    protected Filter<RawField> _fieldFilter;
+
+    /**
+     * Filter to use for selecting constructors to include
+     */
+    protected Filter<RawConstructor> _constructorFilter;
+    
+    /**
+     * Filter to use for selecting methods to include
+     */
+    protected Filter<RawMethod> _methodFilter;
+    
+    /*
+    /**********************************************************************
+    /* Lazily constructed members
+    /**********************************************************************
+     */
+
+    protected ResolvedMethod[] _staticMethods = null;
+
+    protected ResolvedField[] _staticFields = null;
+
+    protected ResolvedMethod[] _memberMethods = null;
+
+    protected ResolvedField[] _memberFields = null;
+
+    protected ResolvedConstructor[] _constructors = null;
+
+    /*
+    /**********************************************************************
+    /* Life cycle at this point
+    /**********************************************************************
+     */
+    
+    public ResolvedTypeWithMembers(TypeResolver typeResolver, AnnotationConfiguration annotationConfig,
+            HierarchicType mainType, HierarchicType[] types,
+            Filter<RawConstructor> constructorFilter, Filter<RawField> fieldFilter, Filter<RawMethod> methodFilter)
+    {
+        _typeResolver = typeResolver;
+        _mainType = mainType;
+        _types = types;
+        if (annotationConfig == null) {
+            annotationConfig = DEFAULT_ANNOTATION_CONFIG;
+        }
+        _annotationHandler = new AnnotationHandler(annotationConfig);
+        _constructorFilter = constructorFilter;
+        _fieldFilter = fieldFilter;
+        _methodFilter = methodFilter;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Public API, access to component types
+    /**********************************************************************
+     */
+    
+    public int size() { return _types.length; }
+
+    /**
+     * Accessor for getting full type hierarchy as priority-ordered list, from
+     * the lowest precedence to highest precedence (main type, its mix-in overrides)
+     */
+    public List<HierarchicType> allTypesAndOverrides() {
+        return Arrays.asList(_types);
+    }
+
+    /**
+     * Accessor for getting subset of type hierarchy which only contains main type
+     * and possible overrides (mix-ins) it has, but not supertypes or their overrides.
+     */
+    public List<HierarchicType> mainTypeAndOverrides()
+    {
+        List<HierarchicType> l = Arrays.asList(_types);
+        int end = _mainType.getPriority() + 1;
+        if (end < l.size()) {
+            l = l.subList(0, end);
+        }
+        return l;
+    }
+
+    /**
+     * Accessor for finding just overrides for the main type (if any).
+     */
+    public List<HierarchicType> overridesOnly()
+    {
+        int index = _mainType.getPriority();
+        if (index == 0) {
+            return Collections.emptyList();
+        }
+        List<HierarchicType> l = Arrays.asList(_types);
+        return l.subList(0, index);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Public API, actual resolution of members
+    /**********************************************************************
+     */
+
+    /**
+     * Method for finding all static fields of the main type (except for ones
+     * possibly filtered out by filter) and applying annotation overrides, if any,
+     * to annotations.
+     * 
+     * @since 1.2.0
+     */
+    public ResolvedField[] getStaticFields()
+    {
+        if (_staticFields == null) {
+            _staticFields = resolveStaticFields();
+        }
+        return _staticFields;
+    }
+    
+    /**
+     * Method for finding all static methods of the main type (except for ones
+     * possibly filtered out by filter) and applying annotation overrides, if any,
+     * to annotations.
+     */
+    public ResolvedMethod[] getStaticMethods()
+    {
+        if (_staticMethods == null) {
+            _staticMethods = resolveStaticMethods();
+        }
+        return _staticMethods;
+    }
+
+    public ResolvedField[] getMemberFields()
+    {
+        if (_memberFields == null) {
+            _memberFields = resolveMemberFields();
+        }
+        return _memberFields;
+    }
+    
+    public ResolvedMethod[] getMemberMethods()
+    {
+        if (_memberMethods == null) {
+            _memberMethods = resolveMemberMethods();
+        }
+        return _memberMethods;
+    }
+
+    public ResolvedConstructor[] getConstructors()
+    {
+        if (_constructors == null) {
+            _constructors = resolveConstructors();
+        }
+        return _constructors;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Internal methods: actual resolution
+    /**********************************************************************
+     */
+    
+    /**
+     * Method that will actually resolve full information (types, annotations)
+     * for constructors of the main type.
+     */
+    protected ResolvedConstructor[] resolveConstructors()
+    {
+        // First get static methods for main type, filter
+        LinkedHashMap<MethodKey, ResolvedConstructor> constructors = new LinkedHashMap<MethodKey, ResolvedConstructor>();
+        for (RawConstructor constructor : _mainType.getType().getConstructors()) {
+            // no filter for constructors (yet?)
+            if (_constructorFilter == null || _constructorFilter.include(constructor)) {
+                constructors.put(constructor.createKey(), resolveConstructor(constructor));
+            }
+        }
+        // then apply overrides (mix-ins):
+        for (HierarchicType type : overridesOnly()) {
+            for (RawConstructor raw : type.getType().getConstructors()) {
+                ResolvedConstructor constructor = constructors.get(raw.createKey()); 
+                // must override something, otherwise to ignore
+                if (constructor != null) {
+                    for (Annotation ann : raw.getAnnotations()) {
+                        if (_annotationHandler.includeMethodAnnotation(ann)) {
+                            constructor.applyOverride(ann);
+                        }
+                    }
+
+                    // and parameter annotations
+                    Annotation[][] params = raw.getRawMember().getParameterAnnotations();
+                    for (int i = 0; i < params.length; i++) {
+                        for (Annotation annotation : params[i]) {
+                            if (_annotationHandler.includeParameterAnnotation(annotation)) {
+                                constructor.applyParamOverride(i, annotation);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (constructors.size() == 0) {
+            return NO_RESOLVED_CONSTRUCTORS;
+        }
+        return constructors.values().toArray(new ResolvedConstructor[constructors.size()]);
+    }
+
+    /**
+     * Method for fully resolving field definitions and associated annotations.
+     * Neither field definitions nor associated annotations inherit, but we may
+     * still need to add annotation overrides, as well as filter out filters
+     * and annotations that caller is not interested in.
+     */
+    protected ResolvedField[] resolveMemberFields()
+    {
+        LinkedHashMap<String, ResolvedField> fields = new LinkedHashMap<String, ResolvedField>();
+
+        /* Fields need different handling: must start from bottom; and annotations only get added
+         * as overrides, never as defaults. And sub-classes fully mask fields. This makes
+         * handling bit simpler than that of member methods.
+         */
+        for (int typeIndex = _types.length; --typeIndex >= 0; ) {
+            HierarchicType thisType = _types[typeIndex];
+            // If it's just a mix-in, add annotations as overrides
+            if (thisType.isMixin()) {
+                for (RawField raw : thisType.getType().getMemberFields()) {
+                    if ((_fieldFilter != null) && !_fieldFilter.include(raw)) {
+                        continue;
+                    }
+                    ResolvedField field = fields.get(raw.getName());
+                    if (field != null) {
+                        for (Annotation ann : raw.getAnnotations()) {
+                            if (_annotationHandler.includeMethodAnnotation(ann)) {
+                                field.applyOverride(ann);
+                            }
+                        }
+                    }
+                }
+            } else { // If actual type, add fields, masking whatever might have existed before:
+                for (RawField field : thisType.getType().getMemberFields()) {
+                    if ((_fieldFilter != null) && !_fieldFilter.include(field)) {
+                        continue;
+                    }
+                    fields.put(field.getName(), resolveField(field));
+                }
+            }
+        }
+        // and that's it?
+        if (fields.size() == 0) {
+            return NO_RESOLVED_FIELDS;
+        }
+        return fields.values().toArray(new ResolvedField[fields.size()]);
+    }
+
+    protected ResolvedMethod[] resolveMemberMethods()
+    {
+        LinkedHashMap<MethodKey, ResolvedMethod> methods = new LinkedHashMap<MethodKey, ResolvedMethod>();
+        LinkedHashMap<MethodKey, Annotations> overrides = new LinkedHashMap<MethodKey, Annotations>();
+        LinkedHashMap<MethodKey, Annotations[]> paramOverrides = new LinkedHashMap<MethodKey, Annotations[]>();
+
+        /* Member methods are handled from top to bottom; and annotations are tracked
+         * alongside (for overrides), as well as "merged down" for inheritable
+         * annotations.
+         */
+        for (HierarchicType type : allTypesAndOverrides()) {
+            for (RawMethod method : type.getType().getMemberMethods()) {
+                // First: ignore methods caller is not interested
+                if (_methodFilter != null && !_methodFilter.include(method)) {
+                    continue;
+                }
+
+                MethodKey key = method.createKey();
+                ResolvedMethod old = methods.get(key);
+                
+                // Ok, now, mix-ins only contribute annotations; whereas 'real' types methods
+                if (type.isMixin()) { // mix-in: only get annotations
+                    for (Annotation ann : method.getAnnotations()) {
+                        // If already have a method, must be inheritable to include
+                        if (old != null) {
+                            if (!methodCanInherit(ann)) {
+                                continue;
+                            }
+                            // and if so, apply as default (i.e. do not override)
+                            old.applyDefault(ann);
+                        } else { // If no method, need to add to annotation override map
+                            Annotations oldAnn = overrides.get(key);
+                            if (oldAnn == null) {
+                                oldAnn = new Annotations();
+                                oldAnn.add(ann);
+                                overrides.put(key, oldAnn);
+                            } else {
+                                oldAnn.addAsDefault(ann);
+                            }
+                        }
+                    }
+
+                    // override argument annotations
+                    final Annotation[][] argAnnotations = method.getRawMember().getParameterAnnotations();
+                    if (old == null) { // no method (yet), add argument annotations to override map
+                        Annotations[] oldParamAnns = paramOverrides.get(key);
+                        if (oldParamAnns == null) { // no existing argument annotations for method
+                            oldParamAnns = new Annotations[argAnnotations.length];
+                            for (int i = 0; i < argAnnotations.length; i++) {
+                                oldParamAnns[i] = new Annotations();
+                                for (final Annotation annotation : argAnnotations[i]) {
+                                    if (parameterCanInherit(annotation)) {
+                                        oldParamAnns[i].add(annotation);
+                                    }
+                                }
+                            }
+                            paramOverrides.put(key, oldParamAnns);
+                        } else {
+                            for (int i = 0; i < argAnnotations.length; i++) {
+                                for (final Annotation annotation : argAnnotations[i]) {
+                                    if (parameterCanInherit(annotation)) {
+                                        oldParamAnns[i].addAsDefault(annotation);
+                                    }
+                                }
+                            }
+                        }
+                    } else { // already have a method, apply argument annotations as defaults
+                        for (int i = 0; i < argAnnotations.length; i++) {
+                            for (final Annotation annotation : argAnnotations[i]) {
+                                if (parameterCanInherit(annotation)) {
+                                    old.applyParamDefault(i, annotation);
+                                }
+                            }
+                        }
+                    }
+                } else { // "real" methods; add if not present, possibly add defaults as well
+                    if (old == null) { // new one to add
+                        ResolvedMethod newMethod = resolveMethod(method);
+                        methods.put(key, newMethod);
+                        // But we may also have annotation overrides, so:
+                        Annotations overrideAnn = overrides.get(key);
+                        if (overrideAnn != null) {
+                            newMethod.applyOverrides(overrideAnn);
+                        }
+                        // and apply parameter annotation overrides
+                        Annotations[] annotations = paramOverrides.get(key);
+                        if (annotations != null) {
+                            for (int i = 0; i < annotations.length; i++) {
+                                newMethod.applyParamOverrides(i, annotations[i]);
+                            }
+                        }
+                    } else { // method masked by something else? can only contribute annotations
+                        for (Annotation ann : method.getAnnotations()) {
+                            if (methodCanInherit(ann)) {
+                                old.applyDefault(ann);
+                            }
+                        }
+                        // and parameter annotations
+                        final Annotation[][] parameterAnnotations = method.getRawMember().getParameterAnnotations();
+                        for (int i = 0; i < parameterAnnotations.length; i++) {
+                            for (final Annotation annotation : parameterAnnotations[i]) {
+                                if (parameterCanInherit(annotation)) {
+                                    old.applyParamDefault(i, annotation);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (methods.size() == 0) {
+            return NO_RESOLVED_METHODS;
+        }
+        return methods.values().toArray(new ResolvedMethod[methods.size()]);
+    }
+    
+    /**
+     * Method for fully resolving static field definitions and associated annotations.
+     * Neither field definitions nor associated annotations inherit, but we may
+     * still need to add annotation overrides, as well as filter out filters
+     * and annotations that caller is not interested in.
+     * 
+     * @since 1.2.0
+     */
+    protected ResolvedField[] resolveStaticFields()
+    {
+        // First get static methods for main type, filter
+        LinkedHashMap<String, ResolvedField> fields = new LinkedHashMap<String, ResolvedField>();
+        for (RawField field : _mainType.getType().getStaticFields()) {
+            if (_fieldFilter == null || _fieldFilter.include(field)) {
+                fields.put(field.getName(), resolveField(field));
+            }
+        }
+        // then apply overrides (mix-ins):
+        for (HierarchicType type : overridesOnly()) {
+            for (RawField raw : type.getType().getStaticFields()) {
+                ResolvedField field = fields.get(raw.getName()); 
+                // must override something, otherwise to ignore
+                if (field != null) {
+                    for (Annotation ann : raw.getAnnotations()) {
+                        if (_annotationHandler.includeFieldAnnotation(ann)) {
+                            field.applyOverride(ann);
+                        }
+                    }
+                }
+            }
+        }
+        // and that's it?
+        if (fields.isEmpty()) {
+            return NO_RESOLVED_FIELDS;
+        }
+        return fields.values().toArray(new ResolvedField[ fields.size()]);
+    }
+
+    /**
+     * Method that will actually resolve full information (types, annotations)
+     * for static methods, using configured filter.
+     */
+    protected ResolvedMethod[] resolveStaticMethods()
+    {
+        // First get static methods for main type, filter
+        LinkedHashMap<MethodKey, ResolvedMethod> methods = new LinkedHashMap<MethodKey, ResolvedMethod>();
+        for (RawMethod method : _mainType.getType().getStaticMethods()) {
+            if (_methodFilter == null || _methodFilter.include(method)) {
+                methods.put(method.createKey(), resolveMethod(method));
+            }
+        }
+        // then apply overrides (mix-ins):
+        for (HierarchicType type : overridesOnly()) {
+            for (RawMethod raw : type.getType().getStaticMethods()) {
+                ResolvedMethod method = methods.get(raw.createKey()); 
+                // must override something, otherwise to ignore
+                if (method != null) {
+                    for (Annotation ann : raw.getAnnotations()) {
+                        if (_annotationHandler.includeMethodAnnotation(ann)) {
+                            method.applyOverride(ann);
+                        }
+                    }
+                }
+            }
+        }
+        if (methods.size() == 0) {
+            return NO_RESOLVED_METHODS;
+        }
+        return methods.values().toArray(new ResolvedMethod[methods.size()]);
+    }
+
+    /*
+    /**********************************************************************
+    /* Helper methods
+    /**********************************************************************
+     */
+
+    /**
+     * Method for resolving individual constructor completely
+     */
+    protected ResolvedConstructor resolveConstructor(RawConstructor raw)
+    {
+        final ResolvedType context = raw.getDeclaringType();
+        final TypeBindings bindings = context.getTypeBindings();
+        Constructor<?> ctor = raw.getRawMember();
+        Type[] rawTypes = ctor.getGenericParameterTypes();
+        ResolvedType[] argTypes;
+        if (rawTypes == null || rawTypes.length == 0) {
+            argTypes = NO_RESOLVED_TYPES;
+        } else {
+            argTypes = new ResolvedType[rawTypes.length];
+            for (int i = 0, len = rawTypes.length; i < len; ++i) {
+                argTypes[i] = _typeResolver.resolve(bindings, rawTypes[i]);
+            }
+        }
+        // And then annotations
+        Annotations anns = new Annotations();
+        for (Annotation ann : ctor.getAnnotations()) {
+            if (_annotationHandler.includeConstructorAnnotation(ann)) {
+                anns.add(ann);
+            }
+        }
+
+        ResolvedConstructor constructor = new ResolvedConstructor(context, anns, ctor, argTypes);
+
+        // and parameter annotations
+        Annotation[][] annotations = ctor.getParameterAnnotations();
+        for (int i = 0; i < argTypes.length; i++) {
+            for (Annotation ann : annotations[i]) {
+                constructor.applyParamOverride(i, ann);
+            }
+        }
+
+        return constructor;
+    }
+
+    /**
+     * Method for resolving individual field completely
+     */
+    protected ResolvedField resolveField(RawField raw)
+    {
+        final ResolvedType context = raw.getDeclaringType();
+        Field field = raw.getRawMember();
+        ResolvedType type = _typeResolver.resolve(context.getTypeBindings(), field.getGenericType());
+        // And then annotations
+        Annotations anns = new Annotations();
+        for (Annotation ann : field.getAnnotations()) {
+            if (_annotationHandler.includeFieldAnnotation(ann)) {
+                anns.add(ann);
+            }
+        }
+        return new ResolvedField(context, anns, field, type);
+    }
+    
+    /**
+     * Method for resolving individual method completely
+     */
+    protected ResolvedMethod resolveMethod(RawMethod raw)
+    {
+        final ResolvedType context = raw.getDeclaringType();
+        final TypeBindings bindings = context.getTypeBindings();
+        Method m = raw.getRawMember();
+        Type rawType = m.getGenericReturnType();
+        ResolvedType rt = (rawType == Void.TYPE) ? null : _typeResolver.resolve(bindings, rawType);
+        Type[] rawTypes = m.getGenericParameterTypes();
+        ResolvedType[] argTypes;
+        if (rawTypes == null || rawTypes.length == 0) {
+            argTypes = NO_RESOLVED_TYPES;
+        } else {
+            argTypes = new ResolvedType[rawTypes.length];
+            for (int i = 0, len = rawTypes.length; i < len; ++i) {
+                argTypes[i] = _typeResolver.resolve(bindings, rawTypes[i]);
+            }
+        }
+        // And then annotations
+        Annotations anns = new Annotations();
+        for (Annotation ann : m.getAnnotations()) {
+            if (_annotationHandler.includeMethodAnnotation(ann)) {
+                anns.add(ann);
+            }
+        }
+
+        ResolvedMethod method = new ResolvedMethod(context, anns, m, rt, argTypes);
+
+        // and argument annotations
+        Annotation[][] annotations = m.getParameterAnnotations();
+        for (int i = 0; i < argTypes.length; i++) {
+            for (Annotation ann : annotations[i]) {
+                method.applyParamOverride(i, ann);
+            }
+        }
+        return method;
+    }
+
+    protected boolean methodCanInherit(Annotation annotation) {
+        AnnotationInclusion annotationInclusion = _annotationHandler.methodInclusion(annotation);
+        if (annotationInclusion == AnnotationInclusion.INCLUDE_AND_INHERIT_IF_INHERITED) {
+            return annotation.annotationType().isAnnotationPresent(Inherited.class);
+        }
+        return (annotationInclusion == AnnotationInclusion.INCLUDE_AND_INHERIT);
+    }
+
+    protected boolean parameterCanInherit(Annotation annotation) {
+        AnnotationInclusion annotationInclusion = _annotationHandler.parameterInclusion(annotation);
+        if (annotationInclusion == AnnotationInclusion.INCLUDE_AND_INHERIT_IF_INHERITED) {
+            return annotation.annotationType().isAnnotationPresent(Inherited.class);
+        }
+        return (annotationInclusion == AnnotationInclusion.INCLUDE_AND_INHERIT);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Helper types
+    /**********************************************************************
+     */
+
+    /**
+     * Helper class we use to reduce number of calls to {@link AnnotationConfiguration};
+     * mostly because determination may be expensive.
+     */
+    private final static class AnnotationHandler
+    {
+        private final AnnotationConfiguration _annotationConfig;
+
+        private HashMap<Class<? extends Annotation>, AnnotationInclusion> _fieldInclusions;
+        private HashMap<Class<? extends Annotation>, AnnotationInclusion> _constructorInclusions;
+        private HashMap<Class<? extends Annotation>, AnnotationInclusion> _methodInclusions;
+        private HashMap<Class<? extends Annotation>, AnnotationInclusion> _parameterInclusions;
+
+        public AnnotationHandler(AnnotationConfiguration annotationConfig) {
+            _annotationConfig = annotationConfig;
+        }
+
+        public boolean includeConstructorAnnotation(Annotation ann)
+        {
+            Class<? extends Annotation> annType = ann.annotationType();
+            if (_constructorInclusions == null) {
+                _constructorInclusions = new HashMap<Class<? extends Annotation>, AnnotationInclusion>();
+            } else {
+                AnnotationInclusion incl = _constructorInclusions.get(annType);
+                if (incl != null) {
+                    return (incl != AnnotationInclusion.DONT_INCLUDE);
+                }
+            }
+            AnnotationInclusion incl = _annotationConfig.getInclusionForConstructor(annType);
+            _constructorInclusions.put(annType, incl);
+            return (incl != AnnotationInclusion.DONT_INCLUDE);
+        }
+        
+        public boolean includeFieldAnnotation(Annotation ann)
+        {
+            Class<? extends Annotation> annType = ann.annotationType();
+            if (_fieldInclusions == null) {
+                _fieldInclusions = new HashMap<Class<? extends Annotation>, AnnotationInclusion>();
+            } else {
+                AnnotationInclusion incl = _fieldInclusions.get(annType);
+                if (incl != null) {
+                    return (incl != AnnotationInclusion.DONT_INCLUDE);
+                }
+            }
+            AnnotationInclusion incl = _annotationConfig.getInclusionForField(annType);
+            _fieldInclusions.put(annType, incl);
+            return (incl != AnnotationInclusion.DONT_INCLUDE);
+        }
+
+        public boolean includeMethodAnnotation(Annotation ann)
+        {
+            return methodInclusion(ann) != AnnotationInclusion.DONT_INCLUDE;
+        }
+
+        public AnnotationInclusion methodInclusion(Annotation ann)
+        {
+            Class<? extends Annotation> annType = ann.annotationType();
+            if (_methodInclusions == null) {
+                _methodInclusions = new HashMap<Class<? extends Annotation>, AnnotationInclusion>();
+            } else {
+                AnnotationInclusion incl = _methodInclusions.get(annType);
+                if (incl != null) {
+                    return incl;
+                }
+            }
+            AnnotationInclusion incl = _annotationConfig.getInclusionForMethod(annType);
+            _methodInclusions.put(annType, incl);
+            return incl;
+        }
+
+        public boolean includeParameterAnnotation(Annotation ann)
+        {
+            return parameterInclusion(ann) != AnnotationInclusion.DONT_INCLUDE;
+        }
+
+        public AnnotationInclusion parameterInclusion(Annotation ann)
+        {
+            Class<? extends Annotation> annType = ann.annotationType();
+            if (_parameterInclusions == null) {
+                _parameterInclusions = new HashMap<Class<? extends Annotation>, AnnotationInclusion>();
+            } else {
+                AnnotationInclusion incl = _parameterInclusions.get(annType);
+                if (incl != null) {
+                    return incl;
+                }
+            }
+            AnnotationInclusion incl = _annotationConfig.getInclusionForParameter(annType);
+            _parameterInclusions.put(annType, incl);
+            return incl;
+        }
+    }
+}

fine-classmate/src/com/fasterxml/classmate/TypeBindings.java

@@ -0,0 +1,237 @@
+package com.fasterxml.classmate;
+
+import java.lang.reflect.TypeVariable;
+import java.util.*;
+
+/**
+ * Helper class used for storing binding of local type variables to
+ * matching resolved types, in context of a single class.
+ */
+public final class TypeBindings
+{
+    private final static String[] NO_STRINGS = new String[0];
+
+    private final static ResolvedType[] NO_TYPES = new ResolvedType[0];
+
+    private final static TypeBindings EMPTY = new TypeBindings(NO_STRINGS, NO_TYPES, null);
+
+    /**
+     * Array of type (type variable) names.
+     */
+    private final String[] _names;
+
+    /**
+     * Types matching names
+     */
+    private final ResolvedType[] _types;
+
+    /**
+     * Names of potentially unresolved type variables.
+     *
+     * @since 2.3
+     */
+    private final String[] _unboundVariables;
+    
+    private final int _hashCode;
+    
+    /*
+    /**********************************************************************
+    /* Construction
+    /**********************************************************************
+     */
+    
+    private TypeBindings(String[] names, ResolvedType[] types, String[] uvars)
+    {
+        _names = (names == null) ? NO_STRINGS : names;
+        _types = (types == null) ? NO_TYPES : types;
+        if (_names.length != _types.length) {
+            throw new IllegalArgumentException("Mismatching names ("+_names.length+"), types ("+_types.length+")");
+        }
+        int h = 1;
+        for (int i = 0, len = _types.length; i < len; ++i) {
+            h += _types[i].hashCode();
+        }
+        _unboundVariables = uvars;
+        _hashCode = h;
+    }
+
+    public static TypeBindings emptyBindings() {
+        return EMPTY;
+    }
+
+    /**
+     * Factory method for constructing bindings for given class using specified type
+     * parameters.
+     */
+    public static TypeBindings create(Class<?> erasedType, List<ResolvedType> typeList)
+    {
+        ResolvedType[] types = (typeList == null || typeList.isEmpty()) ?
+                NO_TYPES : typeList.toArray(new ResolvedType[typeList.size()]);
+        return create(erasedType, types);
+    }
+        
+    public static TypeBindings create(Class<?> erasedType, ResolvedType[] types)
+    {
+        if (types == null) {
+            types = NO_TYPES;
+        }
+        TypeVariable<?>[] vars = erasedType.getTypeParameters();
+        String[] names;
+        if (vars == null || vars.length == 0) {
+            names = NO_STRINGS;
+        } else {
+            int len = vars.length;
+            names = new String[len];
+            for (int i = 0; i < len; ++i) {
+                names[i] = vars[i].getName();
+            }
+        }
+        // Check here to give better error message
+        if (names.length != types.length) {
+            throw new IllegalArgumentException("Can not create TypeBinding for class "+erasedType.getName()
+                   +" with "+types.length+" type parameter"
+                   +((types.length == 1) ? "" : "s")+": class expects "+names.length);
+        }
+        return new TypeBindings(names, types, null);
+    }
+
+    /**
+     * Method for creating an instance that has same bindings as this object,
+     * plus an indicator for additional type variable that may be unbound within
+     * this context; this is needed to resolve recursive self-references.
+     * 
+     * @since 1.3 (renamed from "withAdditionalBinding" in 1.2)
+     */
+    public TypeBindings withUnboundVariable(String name)
+    {
+        int len = (_unboundVariables == null) ? 0 : _unboundVariables.length;
+        String[] names =  (len == 0)
+                ? new String[1] : Arrays.copyOf(_unboundVariables, len+1);
+        names[len] = name;
+        return new TypeBindings(_names, _types, names);
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors
+    /**********************************************************************
+     */
+    
+    /**
+     * Find type bound to specified name, if there is one; returns bound type if so, null if not.
+     */
+    public ResolvedType findBoundType(String name)
+    {
+        for (int i = 0, len = _names.length; i < len; ++i) {
+            if (name.equals(_names[i])) {
+                return _types[i];
+            }
+        }
+        return null;
+    }
+
+    public boolean isEmpty() {
+        return (_types.length == 0);
+    }
+    
+    /**
+     * Returns number of bindings contained
+     */
+    public int size() { 
+        return _types.length;
+    }
+
+    public String getBoundName(int index)
+    {
+        if (index < 0 || index >= _names.length) {
+            return null;
+        }
+        return _names[index];
+    }
+
+    public ResolvedType getBoundType(int index)
+    {
+        if (index < 0 || index >= _types.length) {
+            return null;
+        }
+        return _types[index];
+    }
+
+    /**
+     * Accessor for getting bound types in declaration order
+     */
+    public List<ResolvedType> getTypeParameters()
+    {
+        if (_types.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_types);
+    }
+
+    /**
+     * @since 2.3
+     */
+    public boolean hasUnbound(String name) {
+        if (_unboundVariables != null) {
+            for (int i = _unboundVariables.length; --i >= 0; ) {
+                if (name.equals(_unboundVariables[i])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+    
+    @Override public String toString()
+    {
+        if (_types.length == 0) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append('<');
+        for (int i = 0, len = _types.length; i < len; ++i) {
+            if (i > 0) {
+                sb.append(',');
+            }
+            sb = _types[i].appendBriefDescription(sb);
+        }
+        sb.append('>');
+        return sb.toString();
+    }
+
+    @Override public int hashCode() { return _hashCode; }
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        TypeBindings other = (TypeBindings) o;
+        int len = _types.length;
+        if (len != other.size()) {
+            return false;
+        }
+        ResolvedType[] otherTypes = other._types;
+        for (int i = 0; i < len; ++i) {
+            if (!otherTypes[i].equals(_types[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Package accessible methods
+    /**********************************************************************
+     */
+
+    protected ResolvedType[] typeParameterArray() {
+        return _types;
+    }
+}

fine-classmate/src/com/fasterxml/classmate/TypeResolver.java

@@ -0,0 +1,547 @@
+package com.fasterxml.classmate;
+
+import java.io.Serializable;
+import java.lang.reflect.*;
+import java.util.*;
+
+import com.fasterxml.classmate.types.*;
+import com.fasterxml.classmate.util.ClassKey;
+import com.fasterxml.classmate.util.ClassStack;
+import com.fasterxml.classmate.util.ResolvedTypeCache;
+
+/**
+ * Object that is used for resolving generic type information of a class
+ * so that it is accessible using simple API. Resolved types are also starting
+ * point for accessing resolved (generics aware) return and argument types
+ * of class members (methods, fields, constructors).
+ *<p>
+ * Note that resolver instances are stateful in that resolvers cache resolved
+ * types for efficiency. Since this is internal state and not directly visible
+ * to callers, access to state is fully synchronized so that access from
+ * multiple threads is safe.
+ */
+@SuppressWarnings("serial")
+public class TypeResolver implements Serializable
+{
+    private final static ResolvedType[] NO_TYPES = new ResolvedType[0];
+    
+    /*
+    /**********************************************************************
+    /* Pre-created instances
+    /**********************************************************************
+     */
+
+    /**
+     * We will also need to return "unknown" type for cases where type variable binding
+     * is not found ('raw' instances of generic types); easiest way is to
+     * pre-create type for <code>java.lang.Object</code>
+     */
+    private final static ResolvedObjectType sJavaLangObject =
+        ResolvedObjectType.create(Object.class, null, null, null);
+
+    /**
+     * Since number of primitive types is small, and they are frequently needed,
+     * let's actually pre-create them for efficient reuse. Same goes for limited number
+     * of other "standard" types...
+     */
+    protected final static HashMap<ClassKey, ResolvedType> _primitiveTypes;
+    static {
+        _primitiveTypes = new HashMap<ClassKey, ResolvedType>(16);
+        for (ResolvedPrimitiveType type : ResolvedPrimitiveType.all()) {
+            _primitiveTypes.put(new ClassKey(type.getErasedType()), type);
+        }
+        // should we include "void"? might as well...
+        _primitiveTypes.put(new ClassKey(Void.TYPE), ResolvedPrimitiveType.voidType());
+        // and at least java.lang.Object should be added too.
+        _primitiveTypes.put(new ClassKey(Object.class), sJavaLangObject);
+        // but most other types can be added dynamically
+    }
+
+    /*
+    /**********************************************************************
+    /* Caching
+    /**********************************************************************
+     */
+    
+    /**
+     * Simple cache of types resolved by this resolved; capped to last 200 resolved types.
+     * Caching works because type instances themselves are mostly immutable;
+     * and properly synchronized in cases where transient data (raw members) are
+     * accessed.
+     */
+    protected final ResolvedTypeCache _resolvedTypes = new ResolvedTypeCache(200);
+
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    public TypeResolver() { }
+
+    /*
+    /**********************************************************************
+    /* Factory methods, with explicit parameterization
+    /**********************************************************************
+     */
+    
+    /**
+     * Factory method for resolving given base type
+     * using specified types as type parameters.
+     * Sample usage would be:
+     *<pre>
+     *  ResolvedType type = TypeResolver.resolve(List.class, Integer.class);
+     *</pre>
+     * which would be equivalent to
+     *<pre>
+     *  ResolvedType type = TypeResolver.resolve(new GenericType&lt;List&lt;Integer>>() { });
+     *</pre>
+     * Note that you can mix different types of type parameters, whether already
+     * resolved ({@link ResolvedType}), type-erased ({@link java.lang.Class}) or
+     * generic type reference ({@link GenericType}).
+     */
+    public ResolvedType resolve(Type type, Type... typeParameters)
+    {
+        boolean noParams = (typeParameters == null || typeParameters.length == 0);
+        TypeBindings bindings;
+        Class<?> rawBase;
+
+        if (type instanceof Class<?>) {
+            bindings = TypeBindings.emptyBindings();
+            if (noParams) {
+                return _fromClass(null, (Class<?>) type, bindings);
+            }
+            rawBase = (Class<?>) type;
+        } else if (type instanceof GenericType<?>) {
+            bindings = TypeBindings.emptyBindings();
+            if (noParams) {
+                return _fromGenericType(null, (GenericType<?>) type, bindings);
+            }
+            ResolvedType rt = _fromAny(null, type, bindings);
+            rawBase = rt.getErasedType();
+        } else if (type instanceof ResolvedType) {
+            ResolvedType rt = (ResolvedType) type;
+            if (noParams) {
+                return rt;
+            }
+            bindings = rt.getTypeBindings();
+            rawBase = rt.getErasedType();
+        } else {
+            bindings = TypeBindings.emptyBindings();
+            if (noParams) {
+                return resolve(bindings, type);
+            }
+            // Quite convoluted... but necessary to find Class<?> underlying it all
+            ResolvedType rt = _fromAny(null, type, bindings);
+            rawBase = rt.getErasedType();
+        }
+
+        // Next: resolve type parameters
+        int len = typeParameters.length;
+        ResolvedType[] resolvedParams = new ResolvedType[len];
+        for (int i = 0; i < len; ++i) {
+            resolvedParams[i] = _fromAny(null, typeParameters[i], bindings);
+        }
+        return _fromClass(null, rawBase, TypeBindings.create(rawBase, resolvedParams));
+    }
+
+    /**
+     * Factory method for constructing array type of given element type.
+     */
+    public ResolvedArrayType arrayType(Type elementType)
+    {
+        ResolvedType resolvedElementType = resolve(TypeBindings.emptyBindings(), elementType);
+        // Arrays are cumbersome for some reason:
+        Object emptyArray = Array.newInstance(resolvedElementType.getErasedType(), 0);
+        // Should we try to use cache? It's bit tricky, so let's not bother yet
+        return new ResolvedArrayType(emptyArray.getClass(), TypeBindings.emptyBindings(),
+                resolvedElementType);
+    }
+
+    /**
+     * Factory method for resolving specified Java {@link java.lang.reflect.Type}, given
+     * {@link TypeBindings} needed to resolve any type variables.
+     *<p>
+     * Use of this method is discouraged (use if and only if you really know what you
+     * are doing!); but if used, type bindings passed should come from {@link ResolvedType}
+     * instance of declaring class (or interface).
+     *<p>
+     * NOTE: order of arguments was reversed for 0.8, to avoid problems with
+     * overload varargs method.
+     */
+    public ResolvedType resolve(TypeBindings typeBindings, Type jdkType)
+    {
+        return _fromAny(null, jdkType, typeBindings);
+    }
+
+    /**
+     * Factory method for constructing sub-classing specified type; class specified
+     * as sub-class must be compatible according to basic Java inheritance rules
+     * (subtype must properly extend or implement specified supertype).
+     *<p>
+     * A typical use case here is to refine a generic type; for example, given
+     * that we have generic type like <code>List&ltInteger></code>, but we want
+     * a more specific implementation type like
+     * class <code>ArrayList</code> but with same parameterization (here just <code>Integer</code>),
+     * we could achieve it by:
+     *<pre>
+     *  ResolvedType mapType = typeResolver.resolve(List.class, Integer.class);
+     *  ResolveType concreteMapType = typeResolver.resolveSubType(mapType, ArrayList.class);
+     *</pre>
+     * (in this case, it would have been simpler to resolve directly; but in some
+     * cases we are handled supertype and want to refine it, in which case steps
+     * would be the same but separated by other code)
+     *<p>
+     * Note that this method will fail if extension can not succeed; either because
+     * this type is not extendable (sub-classable) -- which is true for primitive
+     * and array types -- or because given class is not a subtype of this type.
+     * To check whether subtyping could succeed, you can call
+     * {@link ResolvedType#canCreateSubtypes()} to see if supertype can ever
+     * be extended.
+     *
+     * @param supertype Type to subtype (extend)
+     * @param subtype Type-erased sub-class or sub-interface
+     * 
+     * @return Resolved subtype
+     * 
+     * @throws IllegalArgumentException If this type can be extended in general, but not into specified sub-class
+     * @throws UnsupportedOperationException If this type can not be sub-classed
+     */
+    public ResolvedType resolveSubtype(ResolvedType supertype, Class<?> subtype)
+        throws IllegalArgumentException, UnsupportedOperationException
+    {
+        // first: if it's a recursive reference, find out referred-to type
+        ResolvedType refType = supertype.getSelfReferencedType();
+        if (refType != null) {
+            supertype = refType;
+        }
+        // Then, trivial check for case where subtype is supertype...
+        if (supertype.getErasedType() == subtype) {
+            return supertype;
+        }
+        
+        if (!supertype.canCreateSubtypes()) {
+            throw new UnsupportedOperationException("Can not subtype primitive or array types (type "+supertype.getFullDescription()+")");
+        }
+        // In general, must be able to subtype as per JVM rules:
+        Class<?> superclass = supertype.getErasedType();
+        if (!superclass.isAssignableFrom(subtype)) {
+            throw new IllegalArgumentException("Can not sub-class "+supertype.getBriefDescription()
+                    +" into "+subtype.getName());
+        }
+        // Ok, then, let us instantiate type with placeholders
+        ResolvedType resolvedSubtype;
+        int paramCount = subtype.getTypeParameters().length;
+        TypePlaceHolder[] placeholders;
+
+        if (paramCount == 0) { // no generics
+            placeholders = null;
+            resolvedSubtype = resolve(subtype);
+        } else {
+            placeholders = new TypePlaceHolder[paramCount];
+            for (int i = 0; i < paramCount; ++i) {
+                placeholders[i] = new TypePlaceHolder(i);
+            }
+            resolvedSubtype = resolve(subtype, placeholders);            
+        }
+        ResolvedType rawSupertype = resolvedSubtype.findSupertype(superclass);
+        if (rawSupertype == null) { // sanity check, should never occur
+            throw new IllegalArgumentException("Internal error: unable to locate supertype ("+subtype.getName()+") for type "+supertype.getBriefDescription());
+        }
+        // Ok, then, let's find and verify type assignments
+        _resolveTypePlaceholders(supertype, rawSupertype);
+        
+        // And then re-construct, if necessary
+        if (paramCount == 0) { // if no type parameters, fine as is
+            return resolvedSubtype;
+        }
+        // but with type parameters, need to reconstruct
+        ResolvedType[] typeParams = new ResolvedType[paramCount];
+        for (int i = 0; i < paramCount; ++i) {
+            ResolvedType t = placeholders[i].actualType();
+            /* Is it ok for it to be left unassigned? For now let's not
+             * allow that
+             */
+            if (t == null) {
+                throw new IllegalArgumentException("Failed to find type parameter #"+(i+1)+"/"
+                        +paramCount+" for "+subtype.getName());
+            }
+            typeParams[i] = t;
+        }
+        return resolve(subtype, typeParams);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Misc other methods
+    /**********************************************************************
+     */
+
+    /**
+     * Helper method that can be used to checked whether given resolved type
+     * (with erased type of <code>java.lang.Object</code>) is a placeholder
+     * for "self-reference"; these are nasty recursive ("self") types
+     * needed with some interfaces
+     */
+    public static boolean isSelfReference(ResolvedType type)
+    {
+        return (type instanceof ResolvedRecursiveType);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Internal methods, second-level factory methods
+    /**********************************************************************
+     */
+
+    private ResolvedType _fromAny(ClassStack context, Type mainType, TypeBindings typeBindings)
+    {
+        if (mainType instanceof Class<?>) {
+            return _fromClass(context, (Class<?>) mainType, typeBindings);
+        }
+        if (mainType instanceof ResolvedType) {
+            return (ResolvedType) mainType;
+        }
+        if (mainType instanceof ParameterizedType) {
+            return _fromParamType(context, (ParameterizedType) mainType, typeBindings);
+        }
+        if (mainType instanceof GenericType<?>) {
+            return _fromGenericType(context, (GenericType<?>) mainType, typeBindings);
+        }
+        if (mainType instanceof GenericArrayType) {
+            return _fromArrayType(context, (GenericArrayType) mainType, typeBindings);
+        }
+        if (mainType instanceof TypeVariable<?>) {
+            return _fromVariable(context, (TypeVariable<?>) mainType, typeBindings);
+        }
+        if (mainType instanceof WildcardType) {
+            return _fromWildcard(context, (WildcardType) mainType, typeBindings);
+        }
+        // should never get here...
+        throw new IllegalArgumentException("Unrecognized type class: "+mainType.getClass().getName());
+    }
+
+    private ResolvedType _fromClass(ClassStack context, Class<?> rawType, TypeBindings typeBindings)
+    {
+        // First: a primitive type perhaps?
+        ResolvedType type = _primitiveTypes.get(new ClassKey(rawType));
+        if (type != null) {
+            return type;
+        }
+        // Second: recursive reference?
+        if (context == null) {
+            context = new ClassStack(rawType);
+        } else {
+            ClassStack prev = context.find(rawType);
+            if (prev != null) {
+                // Self-reference: needs special handling, then...
+                ResolvedRecursiveType selfRef = new ResolvedRecursiveType(rawType, typeBindings);
+                prev.addSelfReference(selfRef);
+                return selfRef;
+            }
+            // no, can just add
+            context = context.child(rawType);
+        }
+        
+        // If not, already recently resolved?
+        ResolvedType[] typeParameters = typeBindings.typeParameterArray();
+        ResolvedTypeCache.Key key = _resolvedTypes.key(rawType, typeParameters);
+                
+        type = _resolvedTypes.find(key);
+        if (type == null) {
+            type = _constructType(context, rawType, typeBindings);
+            _resolvedTypes.put(key, type);
+        }
+        context.resolveSelfReferences(type);
+        return type;
+    }
+
+    /**
+     * Factory method for resolving given generic type, defined by using sub-class
+     * instance of {@link GenericType}
+     */
+    private ResolvedType _fromGenericType(ClassStack context, GenericType<?> generic, TypeBindings typeBindings)
+    {
+        /* To allow multiple levels of inheritance (just in case someone
+         * wants to go to town with inheritance of GenericType),
+         * we better resolve the whole thing; then dig out
+         * type parameterization...
+         */
+        ResolvedType type = _fromClass(context, generic.getClass(), typeBindings);
+        ResolvedType genType = type.findSupertype(GenericType.class);
+        if (genType == null) { // sanity check; shouldn't occur
+            throw new IllegalArgumentException("Unparameterized GenericType instance ("+generic.getClass().getName()+")");
+        }
+        TypeBindings b = genType.getTypeBindings();
+        ResolvedType[] params = b.typeParameterArray();
+        if (params.length == 0) {
+            throw new IllegalArgumentException("Unparameterized GenericType instance ("+generic.getClass().getName()+")");
+        }
+        return params[0];
+    }
+    
+    private ResolvedType _constructType(ClassStack context, Class<?> rawType, TypeBindings typeBindings)
+    {
+        // Ok: no easy shortcut, let's figure out type of type...
+        if (rawType.isArray()) {
+            ResolvedType elementType = _fromAny(context, rawType.getComponentType(), typeBindings);
+            return new ResolvedArrayType(rawType, typeBindings, elementType);
+        }
+        // For other types super interfaces are needed...
+        if (rawType.isInterface()) {
+            return new ResolvedInterfaceType(rawType, typeBindings,
+                    _resolveSuperInterfaces(context, rawType, typeBindings));
+            
+        }
+        return new ResolvedObjectType(rawType, typeBindings,
+                _resolveSuperClass(context, rawType, typeBindings),
+                _resolveSuperInterfaces(context, rawType, typeBindings));
+    }
+
+    private ResolvedType[] _resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings typeBindings)
+    {
+        Type[] types = rawType.getGenericInterfaces();
+        if (types == null || types.length == 0) {
+            return NO_TYPES;
+        }
+        int len = types.length;
+        ResolvedType[] resolved = new ResolvedType[len];
+        for (int i = 0; i < len; ++i) {
+            resolved[i] = _fromAny(context, types[i], typeBindings);
+        }
+        return resolved;
+    }
+
+    /**
+     * NOTE: return type changed in 1.0.1 from {@link ResolvedObjectType} to
+     *    {@link ResolvedType}, since it was found that other types may
+     *    be returned...
+     * 
+     * @return Usually a {@link ResolvedObjectType}, but possibly also
+     *    {@link ResolvedRecursiveType}
+     */
+    private ResolvedType _resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings typeBindings)
+    {
+        Type parent = rawType.getGenericSuperclass();
+        if (parent == null) {
+            return null;
+        }
+        return _fromAny(context, parent, typeBindings);
+    }
+    
+    private ResolvedType _fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings)
+    {
+        /* First: what is the actual base type? One odd thing is that 'getRawType'
+         * returns Type, not Class<?> as one might expect. But let's assume it is
+         * always of type Class: if not, need to add more code to resolve it...
+         */
+        Class<?> rawType = (Class<?>) ptype.getRawType();
+        Type[] params = ptype.getActualTypeArguments();
+        int len = params.length;
+        ResolvedType[] types = new ResolvedType[len];
+
+        for (int i = 0; i < len; ++i) {
+            types[i] = _fromAny(context, params[i], parentBindings);
+        }
+        // Ok: this gives us current bindings for this type:
+        TypeBindings newBindings = TypeBindings.create(rawType, types);
+        return _fromClass(context, rawType, newBindings);
+    }
+
+    private ResolvedType _fromArrayType(ClassStack context, GenericArrayType arrayType, TypeBindings typeBindings)
+    {
+        ResolvedType elementType = _fromAny(context, arrayType.getGenericComponentType(), typeBindings);
+        // Figuring out raw class for generic array is actually bit tricky...
+        Object emptyArray = Array.newInstance(elementType.getErasedType(), 0);
+        return new ResolvedArrayType(emptyArray.getClass(), typeBindings, elementType);
+    }
+
+    private ResolvedType _fromWildcard(ClassStack context, WildcardType wildType, TypeBindings typeBindings)
+    {
+        /* Similar to challenges with TypeVariable, we may have multiple upper bounds.
+         * But it is also possible that if upper bound defaults to Object, we might want to
+         * consider lower bounds instead?
+         * For now, we won't try anything more advanced; above is just for future reference.
+         */
+        return _fromAny(context, wildType.getUpperBounds()[0], typeBindings);
+    }
+    
+    private ResolvedType _fromVariable(ClassStack context, TypeVariable<?> variable, TypeBindings typeBindings)
+    {
+        // ideally should find it via bindings:
+        String name = variable.getName();
+        ResolvedType type = typeBindings.findBoundType(name);
+
+        if (type != null) {
+            return type;
+        }
+        
+        /* but if not, use bounds... note that approach here is simplistic; not taking
+         * into account possible multiple bounds, nor consider upper bounds.
+         */
+        /* 02-Mar-2011, tatu: As per issue#4, need to avoid self-reference cycles here;
+         *   can be handled by (temporarily) adding binding:
+         */
+        if (typeBindings.hasUnbound(name)) {
+            return sJavaLangObject;
+        }
+        typeBindings = typeBindings.withUnboundVariable(name);
+
+        Type[] bounds = variable.getBounds();
+        return _fromAny(context, bounds[0], typeBindings);
+    }
+
+    /*
+    /**********************************************************************
+    /* Internal methods, replacing and verifying type placeholders
+    /**********************************************************************
+     */
+
+    /**
+     * Method called to verify that types match; and if there are
+     */
+    private void _resolveTypePlaceholders(ResolvedType expectedType, ResolvedType actualType)
+        throws IllegalArgumentException
+    {
+        List<ResolvedType> expectedTypes = expectedType.getTypeParameters();
+        List<ResolvedType> actualTypes = actualType.getTypeParameters();
+        for (int i = 0, len = expectedTypes.size(); i < len; ++i) {
+            ResolvedType exp = expectedTypes.get(i);
+            ResolvedType act = actualTypes.get(i);
+            if (!_typesMatch(exp, act)) {
+                throw new IllegalArgumentException("Type parameter #"+(i+1)+"/"+len+" differs; expected "
+                        +exp.getBriefDescription()+", got "+act.getBriefDescription());
+            }
+        }
+    }
+
+    private boolean _typesMatch(ResolvedType exp, ResolvedType act)
+    {
+        // Simple equality check, except for one thing: place holders for 'act'
+        if (act instanceof TypePlaceHolder) {
+            ((TypePlaceHolder) act).actualType(exp);
+            return true;
+        }
+        // but due to recursive nature can't call equality...
+        if (exp.getErasedType() != act.getErasedType()) {
+            return false;
+        }
+        // But we can check type parameters "blindly"
+        List<ResolvedType> expectedTypes = exp.getTypeParameters();
+        List<ResolvedType> actualTypes = act.getTypeParameters();
+        for (int i = 0, len = expectedTypes.size(); i < len; ++i) {
+            ResolvedType exp2 = expectedTypes.get(i);
+            ResolvedType act2 = actualTypes.get(i);
+            if (!_typesMatch(exp2, act2)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Helper classes
+    /**********************************************************************
+     */
+}

fine-classmate/src/com/fasterxml/classmate/members/HierarchicType.java

@@ -0,0 +1,68 @@
+package com.fasterxml.classmate.members;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.ResolvedTypeWithMembers;
+
+/**
+ * Container class used to enclose information about a single {@link ResolvedType}
+ * that is part of {@link ResolvedTypeWithMembers}.
+ */
+public final class HierarchicType
+{
+    /**
+     * Whether this type instance represents a mix-in; if so, it can only result in
+     * addition of annotations but not in addition of actual members.
+     */
+    protected final boolean _isMixin;
+
+    protected final ResolvedType _type;
+    
+    /**
+     * Relative priority of this type in hierarchy; higher priority members can override
+     * lower priority members. Priority values are unique and are based on type index
+     * (starting from 0), although they are not to be used for indexing.
+     */
+    protected final int _priority;
+
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+
+    public HierarchicType(ResolvedType type, boolean mixin, int priority)
+    {
+        _type = type;
+        _isMixin = mixin;
+        _priority = priority;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    public ResolvedType getType() { return _type; }
+    public Class<?> getErasedType() { return _type.getErasedType(); }
+    public boolean isMixin() { return _isMixin; }
+    public int getPriority() { return _priority; }
+    
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public String toString() { return _type.toString(); }
+    @Override public int hashCode() { return _type.hashCode(); }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        HierarchicType other = (HierarchicType) o;
+        return _type.equals(other._type);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/RawConstructor.java

@@ -0,0 +1,61 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Constructor;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.util.MethodKey;
+
+public final class RawConstructor extends RawMember
+{
+    protected final Constructor<?> _constructor;
+
+    protected final int _hashCode;
+
+    public RawConstructor(ResolvedType context, Constructor<?> constructor)
+    {
+        super(context);
+        _constructor = constructor;
+        _hashCode = (_constructor == null ? 0 : _constructor.hashCode());
+    }
+
+    /**
+     * Although constructors are different from other methods, we can use
+     * {@link MethodKey} easily.
+     */
+    public MethodKey createKey()
+    {
+        String name = "<init>"; // do not use _constructor.getName() to allow for 'mix-ins'
+        Class<?>[] argTypes = _constructor.getParameterTypes();  // return of Constructor#getParameterTypes will never be null
+        return new MethodKey(name, argTypes);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public Constructor<?> getRawMember() {
+        return _constructor;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public int hashCode()
+    {
+        return _hashCode;
+    }
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        RawConstructor other = (RawConstructor) o;
+        return (other._constructor == _constructor);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/RawField.java

@@ -0,0 +1,58 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.ResolvedType;
+
+public final class RawField extends RawMember
+{
+    protected final Field _field;
+
+    private final int _hashCode;
+
+    public RawField(ResolvedType context, Field field)
+    {
+        super(context);
+        _field = field;
+        _hashCode = (_field == null ? 0 : _field.hashCode());
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public Field getRawMember() {
+        return _field;
+    }
+
+    public boolean isTransient() {
+        return Modifier.isTransient(getModifiers());
+    }
+
+    public boolean isVolatile() {
+        return Modifier.isVolatile(getModifiers());
+    }
+
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        RawField other = (RawField) o;
+        return (other._field == _field);
+    }
+
+    @Override public int hashCode()
+    {
+        return _hashCode;
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/RawMember.java

@@ -0,0 +1,98 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.ResolvedType;
+
+/**
+ * Base class for all "raw" member (field, method, constructor) types; raw means that
+ * actual types are not yet resolved, but relationship to declaring type is
+ * retained for eventual resolution.
+ * Instances are typically created by {@link com.fasterxml.classmate.ResolvedType}
+ * when requested, and form the input to eventual full flattening of type members.
+ */
+public abstract class RawMember
+{
+    /**
+     * {@link ResolvedType} (class with generic type parameters) that declared
+     * this member
+     */
+    protected final ResolvedType _declaringType;
+
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    protected RawMember(ResolvedType context)
+    {
+        _declaringType = context;
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    public final ResolvedType getDeclaringType() {
+        return _declaringType;
+    }
+    
+    public abstract Member getRawMember();
+
+    public String getName() {
+        return getRawMember().getName();
+    }
+
+    public boolean isStatic() {
+        return Modifier.isStatic(getModifiers());
+    }
+
+    public boolean isFinal() {
+        return Modifier.isFinal(getModifiers());
+    }
+
+    public boolean isPrivate() {
+        return Modifier.isPrivate(getModifiers());
+    }
+
+    public boolean isProtected() {
+        return Modifier.isProtected(getModifiers());
+    }
+
+    public boolean isPublic() {
+        return Modifier.isPublic(getModifiers());
+    }
+
+    public Annotation[] getAnnotations() {
+        return ((AnnotatedElement) getRawMember()).getAnnotations();
+    }
+    
+    /*
+    /**********************************************************************
+    /* Standard method overrides
+    /**********************************************************************
+     */
+
+    // make abstract to force implementation by sub-class
+    @Override public abstract boolean equals(Object o);
+
+    @Override public abstract int hashCode();
+
+    @Override public String toString() {
+        return getName();
+    }
+    
+    /*
+    /**********************************************************************
+    /* Package methods
+    /**********************************************************************
+     */
+
+    protected final int getModifiers() { return getRawMember().getModifiers(); }
+}

fine-classmate/src/com/fasterxml/classmate/members/RawMethod.java

@@ -0,0 +1,74 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.util.MethodKey;
+
+public final class RawMethod extends RawMember
+{
+    protected final Method _method;
+
+    protected final int _hashCode;
+    
+    public RawMethod(ResolvedType context, Method method)
+    {
+        super(context);
+        _method = method;
+        _hashCode = (_method == null ? 0 : _method.hashCode());
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public Method getRawMember() {
+        return _method;
+    }
+
+    public boolean isAbstract() {
+        return Modifier.isAbstract(getModifiers());
+    }
+
+    public boolean isStrict() {
+        return Modifier.isStrict(getModifiers());
+    }
+
+    public boolean isNative() {
+        return Modifier.isNative(getModifiers());
+    }
+
+    public boolean isSynchronized() {
+        return Modifier.isSynchronized(getModifiers());
+    }
+
+    public MethodKey createKey()
+    {
+        String name = _method.getName();
+        Class<?>[] argTypes = _method.getParameterTypes(); // return of Method#getParameterTypes will never be null
+        return new MethodKey(name, argTypes);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public int hashCode()
+    {
+        return _hashCode;
+    }
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        RawMethod other = (RawMethod) o;
+        return (other._method == _method);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/ResolvedConstructor.java

@@ -0,0 +1,26 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Constructor;
+
+import com.fasterxml.classmate.Annotations;
+import com.fasterxml.classmate.ResolvedType;
+
+/**
+ * Class that represents a constructor that has fully resolved generic
+ * type information and annotation information.
+ */
+public final class ResolvedConstructor extends ResolvedParameterizedMember<Constructor<?>>
+{
+    public ResolvedConstructor(ResolvedType context, Annotations ann, Constructor<?> constructor,
+            ResolvedType[] argumentTypes)
+    {
+        super(context, ann, constructor, null, argumentTypes);
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+}

fine-classmate/src/com/fasterxml/classmate/members/ResolvedField.java

@@ -0,0 +1,36 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.Annotations;
+import com.fasterxml.classmate.ResolvedType;
+
+public final class ResolvedField extends ResolvedMember<Field>
+     implements Comparable<ResolvedField>
+{
+    public ResolvedField(ResolvedType context, Annotations ann,
+            Field field, ResolvedType type)
+    {
+        super(context, ann, field, type);
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    public boolean isTransient() {
+        return Modifier.isTransient(getModifiers());
+    }
+
+    public boolean isVolatile() {
+        return Modifier.isVolatile(getModifiers());
+    }
+
+    @Override
+    public int compareTo(ResolvedField other) {
+         return getName().compareTo(other.getName());
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/ResolvedMember.java

@@ -0,0 +1,156 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.Annotations;
+import com.fasterxml.classmate.ResolvedType;
+
+/**
+ * Fully type-resolved equivalent of {@link RawMember}. Only members "that matter" (ones not
+ * overridden, or filtered out) are resolved, since resolution process can add non-trivial
+ * overhead.
+ */
+public abstract class ResolvedMember<T extends Member>
+{
+    /**
+     * {@link ResolvedType} (class with generic type parameters) that declared
+     * this member
+     */
+    protected final ResolvedType _declaringType;
+
+    protected final Annotations _annotations;
+
+    protected final T _member;
+
+    protected final ResolvedType _type;
+
+    protected final int _hashCode;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    protected ResolvedMember(ResolvedType context, Annotations ann, T member, ResolvedType type)
+    {
+        _declaringType = context;
+        _annotations = ann;
+        _member = member;
+        _type = type;
+        _hashCode = (_member == null ? 0 : _member.hashCode());
+    }
+
+    public void applyOverride(Annotation override)
+    {
+        _annotations.add(override);
+    }
+
+    public void applyOverrides(Annotations overrides)
+    {
+        _annotations.addAll(overrides);
+    }
+
+    public void applyDefault(Annotation override)
+    {
+        _annotations.addAsDefault(override);
+    }
+
+    public <A extends Annotation> A get(Class<A> cls)
+    {
+        return _annotations.get(cls);
+    }
+
+    public Annotations getAnnotations()
+    {
+        return _annotations;
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors
+    /**********************************************************************
+     */
+
+    public final ResolvedType getDeclaringType() {
+        return _declaringType;
+    }
+
+    /**
+     * Returns type of this member; if it has one, for methods this is the
+     * return type, for fields field type, and for constructors null.
+     */
+    public ResolvedType getType() {
+        return _type;
+    }
+ 
+    /**
+     * Returns JDK object that represents member.
+     */
+    public T getRawMember() {
+        return _member;
+    }
+
+    public String getName() {
+        return getRawMember().getName();
+    }
+
+    public boolean isStatic() {
+        return Modifier.isStatic(getModifiers());
+    }
+
+    public boolean isFinal() {
+        return Modifier.isFinal(getModifiers());
+    }
+
+    public boolean isPrivate() {
+        return Modifier.isPrivate(getModifiers());
+    }
+
+    public boolean isProtected() {
+        return Modifier.isProtected(getModifiers());
+    }
+
+    public boolean isPublic() {
+        return Modifier.isPublic(getModifiers());
+    }
+    
+    /*
+    /**********************************************************************
+    /* Standard method overrides
+    /**********************************************************************
+     */
+    
+    @Override public String toString() {
+        return getName();
+    }
+    
+    /*
+    /**********************************************************************
+    /* Package methods
+    /**********************************************************************
+     */
+
+    protected final int getModifiers() { return getRawMember().getModifiers(); }
+
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override public int hashCode() {
+        return _hashCode;
+    }
+
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        ResolvedMember<?> other = (ResolvedMember<?>) o;
+        return (other._member == _member);
+    }
+    
+}

fine-classmate/src/com/fasterxml/classmate/members/ResolvedMethod.java

@@ -0,0 +1,65 @@
+package com.fasterxml.classmate.members;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import com.fasterxml.classmate.Annotations;
+import com.fasterxml.classmate.ResolvedType;
+
+public final class ResolvedMethod extends ResolvedParameterizedMember<Method>
+     implements Comparable<ResolvedMethod>
+{
+    public ResolvedMethod(ResolvedType context, Annotations ann, Method method,
+            ResolvedType returnType, ResolvedType[] argumentTypes)
+    {
+        super(context, ann, method, returnType, argumentTypes);
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple accessors from base class
+    /**********************************************************************
+     */
+
+    public boolean isAbstract() {
+        return Modifier.isAbstract(getModifiers());
+    }
+
+    public boolean isStrict() {
+        return Modifier.isStrict(getModifiers());
+    }
+
+    public boolean isNative() {
+        return Modifier.isNative(getModifiers());
+    }
+
+    public boolean isSynchronized() {
+        return Modifier.isSynchronized(getModifiers());
+    }
+
+    /*
+    /**********************************************************************
+    /* Extended API
+    /**********************************************************************
+     */
+
+    public ResolvedType getReturnType() { return getType(); }
+
+    /*
+    /**********************************************************************
+    /* Standard method override
+    /**********************************************************************
+     */
+
+    @Override
+    public int compareTo(ResolvedMethod other)
+    {
+         // primary sort by name (alphabetic); secondary by arg count (ascending)
+         int diff = getName().compareTo(other.getName());
+         if (diff == 0) {
+              // subtract fine, no fear of overflow here
+              diff = getArgumentCount() - other.getArgumentCount();
+         }
+         return diff;
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/ResolvedParameterizedMember.java

@@ -0,0 +1,81 @@
+package com.fasterxml.classmate.members;
+
+import com.fasterxml.classmate.Annotations;
+import com.fasterxml.classmate.ResolvedType;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
+
+/**
+ * Base type for resolved members that take some parameters (e.g. methods and constructors).
+ */
+public abstract class ResolvedParameterizedMember<T extends Member> extends ResolvedMember<T> {
+
+    protected final ResolvedType[] _paramTypes;
+
+    protected final Annotations[] _paramAnnotations;
+
+    protected ResolvedParameterizedMember(ResolvedType context, Annotations ann,
+                                          T member, ResolvedType type, ResolvedType[] argumentTypes) {
+        super(context, ann, member, type);
+        _paramTypes = argumentTypes == null ? ResolvedType.NO_TYPES : argumentTypes;
+        _paramAnnotations = new Annotations[_paramTypes.length];
+    }
+
+    public Annotations getParameterAnnotations(int index) {
+        if (index >= _paramTypes.length)
+            throw new IndexOutOfBoundsException("No parameter at index " + index + ", this is greater than the total number of parameters");
+
+        if (_paramAnnotations[index] == null) {
+            _paramAnnotations[index] = new Annotations();
+        }
+        return _paramAnnotations[index];
+    }
+
+    public void applyParamOverride(int index, Annotation override)
+    {
+        if (index >= _paramAnnotations.length)
+            return;
+
+        getParameterAnnotations(index).add(override);
+    }
+
+    public void applyParamOverrides(int index, Annotations overrides)
+    {
+        if (index >= _paramAnnotations.length)
+            return;
+
+        getParameterAnnotations(index).addAll(overrides);
+    }
+
+    public void applyParamDefault(int index, Annotation defaultValue)
+    {
+        if (index >= _paramAnnotations.length)
+            return;
+
+        getParameterAnnotations(index).addAsDefault(defaultValue);
+    }
+
+    public <A extends Annotation> A getParam(int index, Class<A> cls)
+    {
+        if (index >= _paramAnnotations.length)
+            return null;
+
+        return _paramAnnotations[index].get(cls);
+    }
+
+    /**
+     * Returns number of arguments method takes.
+     */
+    public int getArgumentCount() {
+        return _paramTypes.length;
+    }
+
+    public ResolvedType getArgumentType(int index)
+    {
+        if (index < 0 || index >= _paramTypes.length) {
+            return null;
+        }
+        return _paramTypes[index];
+    }
+}

fine-classmate/src/com/fasterxml/classmate/members/package-info.java

@@ -0,0 +1,5 @@
+/**
+ * Package that contains implementations of various member types
+ * (methods, fields, constructors)
+ */
+package com.fasterxml.classmate.members;

fine-classmate/src/com/fasterxml/classmate/package-info.java

@@ -0,0 +1,13 @@
+/**
+ * Package that contains main public interface of ClassMate
+ * package.
+ *<p>
+ * Most commonly resolution starts with {@link com.fasterxml.classmate.TypeResolver},
+ * using its <code>resolve()</code> method, which returns a
+ * {@link com.fasterxml.classmate.ResolvedType} instance.
+ * These type objects contain all necessary information about type itself;
+ * but if type information on members (fields, methods, constructors, static
+ * members) is needed, {@link com.fasterxml.classmate.MemberResolver} can
+ * resolve types for members: it takes {@link com.fasterxml.classmate.ResolvedType}s.
+ */
+package com.fasterxml.classmate;

fine-classmate/src/com/fasterxml/classmate/types/ResolvedArrayType.java

@@ -0,0 +1,108 @@
+package com.fasterxml.classmate.types;
+
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+
+public final class ResolvedArrayType extends ResolvedType
+{
+    protected final ResolvedType _elementType;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+
+    public ResolvedArrayType(Class<?> erased, TypeBindings bindings,
+            ResolvedType elementType)
+    {
+        super(erased, bindings);
+        _elementType = elementType;
+    }
+    
+    @Override
+    public boolean canCreateSubtypes() {
+        return false;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    @Override
+    public ResolvedType getParentClass() { return null; }
+    
+    @Override
+    public ResolvedType getSelfReferencedType() { return null; }
+    
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() {
+        return Collections.emptyList();
+    }
+    
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean isInterface() {
+        return false;
+    }
+
+    @Override
+    public boolean isAbstract() { return false; }
+
+    @Override
+    public ResolvedType getArrayElementType() { return _elementType; }
+
+    @Override
+    public boolean isArray() { return true; }
+
+    @Override
+    public boolean isPrimitive() { return false; }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+
+    // defaults are fine (nothing to access)
+    
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        sb.append('[');
+        return _elementType.appendSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        sb.append('[');
+        return _elementType.appendErasedSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb)
+    {
+        sb = _elementType.appendBriefDescription(sb);
+        sb.append("[]");
+        return sb;
+    }
+
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb) {
+        return appendBriefDescription(sb);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/types/ResolvedInterfaceType.java

@@ -0,0 +1,162 @@
+package com.fasterxml.classmate.types;
+
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+import com.fasterxml.classmate.members.RawField;
+import com.fasterxml.classmate.members.RawMethod;
+
+public class ResolvedInterfaceType extends ResolvedType
+{
+
+    /**
+     * List of interfaces this type implements; may be empty but never null
+     */
+    protected final ResolvedType[] _superInterfaces;
+
+    /**
+     * Interfaces can have static final (constant) fields.
+     */
+    protected RawField[] _constantFields;
+
+    /**
+     * Interface methods are all public and abstract.
+     */
+    protected RawMethod[] _memberMethods;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+
+    public ResolvedInterfaceType(Class<?> erased, TypeBindings bindings,
+            ResolvedType[] superInterfaces)
+    {
+        super(erased, bindings);
+        _superInterfaces = (superInterfaces == null ? NO_TYPES : superInterfaces);
+    }
+
+    @Override
+    public boolean canCreateSubtypes() {
+        return true;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    @Override
+    public ResolvedType getParentClass() {
+        // interfaces do not have parent class, just interfaces
+        return null;
+    }
+
+    @Override
+    public ResolvedType getSelfReferencedType() { return null; }
+    
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() {
+        return (_superInterfaces.length == 0) ?
+                Collections.<ResolvedType>emptyList() : Arrays.asList(_superInterfaces);
+    }
+    
+    @Override
+    public ResolvedType getArrayElementType() { // interfaces are never arrays, so:
+        return null;
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean isInterface() { return true; }
+
+    @Override
+    public boolean isAbstract() { return true; }
+
+    @Override
+    public boolean isArray() { return false; }
+
+    @Override
+    public boolean isPrimitive() { return false; }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+
+    @Override
+    public synchronized List<RawField> getStaticFields()
+    {
+        // Interfaces can have static fields, but only as static constants...
+        if (_constantFields == null) {
+            _constantFields = _getFields(true);
+        }
+        if (_constantFields.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_constantFields);
+    }
+
+    @Override
+    public synchronized List<RawMethod> getMemberMethods()
+    {
+        if (_memberMethods == null) {
+            _memberMethods = _getMethods(false);
+        }
+        if (_memberMethods.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_memberMethods);
+    }
+    
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        return _appendClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        return _appendErasedClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb) {
+        return _appendClassDescription(sb);
+    }
+
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb)
+    {
+        sb = _appendClassDescription(sb);
+        // interfaces 'extend' other interfaces...
+        int count = _superInterfaces.length;
+        if (count > 0) {
+            sb.append(" extends ");
+            for (int i = 0; i < count; ++i) {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                sb = _superInterfaces[i].appendBriefDescription(sb);
+            }
+        }
+        return sb;
+    }
+}
+
+
+

fine-classmate/src/com/fasterxml/classmate/types/ResolvedObjectType.java

@@ -0,0 +1,287 @@
+package com.fasterxml.classmate.types;
+
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+import com.fasterxml.classmate.members.RawConstructor;
+import com.fasterxml.classmate.members.RawField;
+import com.fasterxml.classmate.members.RawMethod;
+
+/**
+ * Type implementation for classes that do not represent interfaces,
+ * primitive or array types.
+ */
+public class ResolvedObjectType extends ResolvedType
+{
+    /**
+     * While fundamentally super class has to be {@link ResolvedObjectType}
+     * (or null for {@link java.lang.Object}), we may need to hold on to
+     * a {@link ResolvedRecursiveType} occasionally.
+     */
+    protected final ResolvedType _superClass;
+
+    /**
+     * List of interfaces this type implements; may be empty but never null
+     */
+    protected final ResolvedType[] _superInterfaces;
+
+    /**
+     * Modifiers of the underlying class.
+     */
+    protected final int _modifiers;
+
+    /**
+     * Constructors declared by the resolved Object class.
+     */
+    protected RawConstructor[] _constructors;
+
+    protected RawField[] _memberFields;
+    protected RawField[] _staticFields;
+
+    protected RawMethod[] _memberMethods;
+    protected RawMethod[] _staticMethods;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    public ResolvedObjectType(Class<?> erased, TypeBindings bindings,
+            ResolvedType superClass, List<ResolvedType> interfaces)
+    {
+        this(erased, bindings, superClass,
+                (interfaces == null || interfaces.isEmpty()) ? NO_TYPES :
+                interfaces.toArray(new ResolvedType[interfaces.size()]));
+    }
+
+    public ResolvedObjectType(Class<?> erased, TypeBindings bindings,
+            ResolvedType superClass, ResolvedType[] interfaces)
+    {
+        super(erased, bindings);
+        /* 19-Aug-2014, tatu: bit unclean, but has to do for now.
+         *   Problem is, there is no common super-type, nor can we yet
+         *   force or coerce recursive types. Rather, they may only get
+         *   resolved only slightly after construction. So... need to
+         *   keep a reference.
+         */
+        if (superClass != null) {
+            if (!(superClass instanceof ResolvedObjectType)
+                    && !(superClass instanceof ResolvedRecursiveType)
+                    ) {
+                throw new IllegalArgumentException("Unexpected parent type for "
+                        +erased.getName()+": "+superClass.getClass().getName());
+            }
+        }
+        
+        _superClass = superClass;
+        _superInterfaces = (interfaces == null) ? NO_TYPES : interfaces;
+        _modifiers = erased.getModifiers();
+    }
+
+    @Deprecated // since 1.1; removed from 1.2 -- kept for binary backwards compatibility
+    public ResolvedObjectType(Class<?> erased, TypeBindings bindings,
+            ResolvedObjectType superClass, List<ResolvedType> interfaces)
+    {
+        this(erased, bindings, (ResolvedType) superClass, interfaces);
+    }
+
+    @Deprecated // since 1.1; removed from 1.2 -- kept for binary backwards compatibility
+    public ResolvedObjectType(Class<?> erased, TypeBindings bindings,
+            ResolvedObjectType superClass, ResolvedType[] interfaces)
+    {
+        this(erased, bindings, (ResolvedType) superClass, interfaces);
+    }
+
+    public static ResolvedObjectType create(Class<?> erased, TypeBindings bindings,
+            ResolvedType superClass, List<ResolvedType> interfaces)
+    {
+        return new ResolvedObjectType(erased, bindings, superClass, interfaces);
+    }
+    
+    @Override
+    public boolean canCreateSubtypes() {
+        return true;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+
+    @Override
+    public ResolvedObjectType getParentClass() {
+        
+        /* 19-Aug-2014, tatu: Ugly does it... sigh.
+         *   But can't be helped because ResolvedRecursiveType is typically only
+         *   resolved after instances of this type have been constructed.
+         *   This means that resolution will need to be done somewhat dynamically.
+         */
+        if (_superClass == null) {
+            return null;
+        }
+        if (_superClass instanceof ResolvedObjectType) {
+            return (ResolvedObjectType) _superClass;
+        }
+        ResolvedType rt = ((ResolvedRecursiveType) _superClass).getSelfReferencedType();
+        if (!(rt instanceof ResolvedObjectType)) {
+            throw new IllegalStateException("Internal error: self-referential parent type ("
+                    +_superClass+") does not resolve into proper ResolvedObjectType, but instead to: "
+                    +rt);
+        }
+        return (ResolvedObjectType) rt;
+    }
+
+    @Override
+    public ResolvedType getSelfReferencedType() { return null; }
+    
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() {
+        return (_superInterfaces.length == 0) ?
+                Collections.<ResolvedType>emptyList() : Arrays.asList(_superInterfaces);
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    @Override
+    public final ResolvedType getArrayElementType() { return null; }
+    
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+    
+    @Override
+    public final boolean isInterface() { return false; }
+
+    @Override
+    public boolean isAbstract() {
+        return Modifier.isAbstract(_modifiers);
+    }
+
+    @Override
+    public final boolean isArray() { return false; }
+
+    @Override
+    public final boolean isPrimitive() { return false; }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+
+    @Override
+    public synchronized List<RawField> getMemberFields()
+    {
+        if (_memberFields == null) {
+            _memberFields = _getFields(false);
+        }
+        if (_memberFields.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_memberFields);
+    }
+
+    @Override
+    public synchronized List<RawField> getStaticFields()
+    {
+        if (_staticFields == null) {
+            _staticFields = _getFields(true);
+        }
+        if (_staticFields.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_staticFields);
+    }
+
+    @Override
+    public synchronized List<RawMethod> getMemberMethods()
+    {
+        if (_memberMethods == null) {
+            _memberMethods = _getMethods(false);
+        }
+        if (_memberMethods.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_memberMethods);
+    } 
+
+    @Override
+    public synchronized List<RawMethod> getStaticMethods()
+    {
+        if (_staticMethods == null) {
+            _staticMethods = _getMethods(true);
+        }
+        if (_staticMethods.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_staticMethods);
+    } 
+
+    @Override
+    public List<RawConstructor> getConstructors()
+    {
+        if (_constructors == null) {
+            _constructors = _getConstructors();
+        }
+        if (_constructors.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(_constructors);
+    }
+
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        return _appendClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        return _appendErasedClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb) {
+        return _appendClassDescription(sb);
+    }
+    
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb)
+    {
+        sb = _appendClassDescription(sb);
+        if (_superClass != null) {
+            sb.append(" extends ");
+            sb = _superClass.appendBriefDescription(sb);
+        }
+        // interfaces 'extend' other interfaces...
+        int count = _superInterfaces.length;
+        if (count > 0) {
+            sb.append(" implements ");
+            for (int i = 0; i < count; ++i) {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                sb = _superInterfaces[i].appendBriefDescription(sb);
+            }
+        }
+        return sb;
+    }
+}
+

fine-classmate/src/com/fasterxml/classmate/types/ResolvedPrimitiveType.java

@@ -0,0 +1,157 @@
+package com.fasterxml.classmate.types;
+
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+
+/**
+ * Type used for Java primitive types (which does not include arrays here).
+ *<p>
+ * Since set of primitive types is bounded, constructor is defined as protected,
+ * and class final; that is, new primitive types are not to be constructed
+ * by calling applications.
+ */
+public final class ResolvedPrimitiveType extends ResolvedType
+{
+    private final static ResolvedPrimitiveType VOID = new ResolvedPrimitiveType(Void.TYPE, 'V', "void");
+    
+    /**
+     * Primitive types have single-character Signature, easy and efficient
+     * to just store here
+     */
+    protected final String _signature;
+
+    /**
+     * Human-readable description should be simple as well
+     */
+    protected final String _description;
+    
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+
+    protected ResolvedPrimitiveType(Class<?> erased, char sig, String desc)
+    {
+        super(erased, TypeBindings.emptyBindings());
+        _signature = String.valueOf(sig);
+        _description = desc;
+    }
+    
+    public static List<ResolvedPrimitiveType> all()
+    {
+        ArrayList<ResolvedPrimitiveType> all = new ArrayList<ResolvedPrimitiveType>();
+        all.add(new ResolvedPrimitiveType(Boolean.TYPE, 'Z', "boolean"));
+        all.add(new ResolvedPrimitiveType(Byte.TYPE, 'B', "byte"));
+        all.add(new ResolvedPrimitiveType(Short.TYPE, 'S', "short"));
+        all.add(new ResolvedPrimitiveType(Character.TYPE, 'C', "char"));
+        all.add(new ResolvedPrimitiveType(Integer.TYPE, 'I', "int"));
+        all.add(new ResolvedPrimitiveType(Long.TYPE, 'J', "long"));
+        all.add(new ResolvedPrimitiveType(Float.TYPE, 'F', "float"));
+        all.add(new ResolvedPrimitiveType(Double.TYPE, 'D', "double"));
+        return all;
+    }
+
+    public static ResolvedPrimitiveType voidType()
+    {
+        return VOID;
+    }
+    
+    @Override
+    public boolean canCreateSubtypes() {
+        return false;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+
+    @Override
+    public ResolvedType getSelfReferencedType() { return null; }
+    
+    @Override
+    public ResolvedType getParentClass() { return null; }
+    
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean isInterface() { return false; }
+    
+    @Override
+    public boolean isAbstract() { return false; }
+
+    @Override
+    public ResolvedType getArrayElementType() { return null; }
+
+    @Override
+    public boolean isArray() { return false; }
+
+    @Override
+    public boolean isPrimitive() { return true; }
+
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() {
+        return Collections.emptyList();
+    }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+    
+    // Primitive types are simple; no fields, no methods, no constructors
+    
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public String getSignature() {
+        return _signature;
+    }
+
+    @Override
+    public String getErasedSignature() {
+        return _signature;
+    }
+
+    @Override
+    public String getFullDescription() {
+        return _description;
+    }
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        sb.append(_signature);
+        return sb;
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        sb.append(_signature);
+        return sb;
+    }
+    
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb) {
+        sb.append(_description);
+        return sb;
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb) {
+        sb.append(_description);
+        return sb;
+    }
+}

fine-classmate/src/com/fasterxml/classmate/types/ResolvedRecursiveType.java

@@ -0,0 +1,149 @@
+package com.fasterxml.classmate.types;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+import com.fasterxml.classmate.members.RawConstructor;
+import com.fasterxml.classmate.members.RawField;
+import com.fasterxml.classmate.members.RawMethod;
+
+/**
+ * Specialized type placeholder used in cases where type definition is
+ * recursive; to avoid infinite loop, reference that would be "back" in
+ * hierarchy is represented by an instance of this class.
+ * Underlying information is achievable (for full resolution), but
+ * not exposed using super type (parent) accessors; and has special
+ * handling when used for constructing descriptions.
+ */
+public class ResolvedRecursiveType extends ResolvedType
+{
+    /**
+     * Actual fully resolved type; assigned once resolution is complete
+     */
+    protected ResolvedType _referencedType;
+
+    /*
+    /**********************************************************************
+    /* Life cycle
+    /**********************************************************************
+     */
+    
+    public ResolvedRecursiveType(Class<?> erased, TypeBindings bindings)
+    {
+        super(erased, bindings);
+    }
+    
+    @Override
+    public boolean canCreateSubtypes() {
+        return _referencedType.canCreateSubtypes();
+    }
+    
+    public void setReference(ResolvedType ref)
+    {
+        // sanity check; should not be called multiple times
+        if (_referencedType != null) {
+            throw new IllegalStateException("Trying to re-set self reference; old value = "+_referencedType+", new = "+ref);
+        }
+        _referencedType = ref;
+    }
+    
+
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    /**
+     * To avoid infinite loops, will return null;
+     */
+    @Override
+    public ResolvedType getParentClass() {
+        return null;
+    }
+
+    @Override
+    public ResolvedType getSelfReferencedType() { return _referencedType; }
+    
+    /**
+     * To avoid infinite loops, will return empty list
+     */
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() {
+        return Collections.<ResolvedType>emptyList();
+    }
+    
+    /**
+     * To avoid infinite loops, will return null type
+     */
+    @Override
+    public ResolvedType getArrayElementType() { // interfaces are never arrays, so:
+        return null;
+    }
+
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean isInterface() { return _erasedType.isInterface(); }
+
+    @Override
+    public boolean isAbstract() { return Modifier.isAbstract(_erasedType.getModifiers()); }
+
+    @Override
+    public boolean isArray() { return _erasedType.isArray(); }
+
+    @Override
+    public boolean isPrimitive() { return false; }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+
+    @Override
+    public List<RawField> getMemberFields() { return _referencedType.getMemberFields(); }
+    @Override
+    public List<RawField> getStaticFields() { return _referencedType.getStaticFields(); }
+    @Override
+    public List<RawMethod> getStaticMethods() { return _referencedType.getStaticMethods(); }
+    @Override
+    public List<RawMethod> getMemberMethods() { return _referencedType.getMemberMethods(); }
+    @Override
+    public List<RawConstructor> getConstructors() { return _referencedType.getConstructors(); }
+    
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        // to avoid infinite recursion, only print type erased version
+        return appendErasedSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        return _appendErasedClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb) {
+        return _appendClassDescription(sb);
+    }
+
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb)
+    {
+        // should never get called, but just in case, only print brief description
+        return appendBriefDescription(sb);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/types/TypePlaceHolder.java

@@ -0,0 +1,101 @@
+package com.fasterxml.classmate.types;
+
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.TypeBindings;
+
+/**
+ * Placeholder used for resolving type assignments to figure out
+ * type parameters for subtypes.
+ */
+public class TypePlaceHolder extends ResolvedType
+{
+    protected final int _ordinal;
+
+    /**
+     * Type assigned during wildcard resolution
+     */
+    protected ResolvedType _actualType;
+    
+    public TypePlaceHolder(int ordinal)
+    {
+        super(Object.class, TypeBindings.emptyBindings());
+        _ordinal = ordinal;
+    }
+
+    @Override
+    public boolean canCreateSubtypes() { return false; }
+
+    public ResolvedType actualType() { return _actualType; }
+    public void actualType(ResolvedType t) { _actualType = t; }
+    
+    /*
+    /**********************************************************************
+    /* Accessors for related types
+    /**********************************************************************
+     */
+    
+    @Override
+    public ResolvedType getParentClass() { return null; }
+
+    @Override
+    public ResolvedType getSelfReferencedType() { return null; }
+    
+    @Override
+    public List<ResolvedType> getImplementedInterfaces() { return Collections.<ResolvedType>emptyList(); }
+    
+    @Override
+    public ResolvedType getArrayElementType() { return null; }
+
+    /*
+    /**********************************************************************
+    /* Simple property accessors
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean isInterface() { return false; }
+
+    @Override
+    public boolean isAbstract() { return true; }
+
+    @Override
+    public boolean isArray() { return false; }
+
+    @Override
+    public boolean isPrimitive() { return false; }
+
+    /*
+    /**********************************************************************
+    /* Accessors for raw (minimally procesed) members
+    /**********************************************************************
+     */
+    
+    /*
+    /**********************************************************************
+    /* String representations
+    /**********************************************************************
+     */
+
+    @Override
+    public StringBuilder appendSignature(StringBuilder sb) {
+        return _appendClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendErasedSignature(StringBuilder sb) {
+        return _appendErasedClassSignature(sb);
+    }
+
+    @Override
+    public StringBuilder appendBriefDescription(StringBuilder sb) {
+        sb.append('<').append(_ordinal).append('>');
+        return sb;
+    }
+
+    @Override
+    public StringBuilder appendFullDescription(StringBuilder sb) {
+        return appendBriefDescription(sb);
+    }
+}

fine-classmate/src/com/fasterxml/classmate/types/package-info.java

@@ -0,0 +1,5 @@
+/**
+ * Package that contains {@link com.fasterxml.classmate.ResolvedType}
+ * implementation classes.
+ */
+package com.fasterxml.classmate.types;

fine-classmate/src/com/fasterxml/classmate/util/ClassKey.java

@@ -0,0 +1,69 @@
+package com.fasterxml.classmate.util;
+
+import java.io.Serializable;
+
+/**
+ * Helper class used as key when we need efficient Class-to-value lookups.
+ */
+@SuppressWarnings("serial")
+public class ClassKey
+    implements Comparable<ClassKey>, Serializable
+{
+    private final String _className;
+
+    private final Class<?> _class;
+
+    /**
+     * Let's cache hash code straight away, since we are almost certain to need it.
+     */
+    private final int _hashCode;
+
+    public ClassKey(Class<?> clz)
+    {
+        _class = clz;
+        _className = clz.getName();
+        _hashCode = _className.hashCode();
+    }
+
+    /*
+    /**********************************************************************
+    /* Comparable
+    /**********************************************************************
+     */
+
+    @Override
+    public int compareTo(ClassKey other)
+    {
+        // Just need to sort by name, ok to collide (unless used in TreeMap/Set!)
+        return _className.compareTo(other._className);
+    }
+
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) return false;
+        ClassKey other = (ClassKey) o;
+
+        /* Is it possible to have different Class object for same name + class loader combo?
+         * Let's assume answer is no: if this is wrong, will need to uncomment following functionality
+         */
+        /*
+        return (other._className.equals(_className))
+            && (other._class.getClassLoader() == _class.getClassLoader());
+        */
+        return other._class == _class;
+    }
+
+    @Override public int hashCode() { return _hashCode; }
+
+    @Override public String toString() { return _className; }
+    
+}

fine-classmate/src/com/fasterxml/classmate/util/ClassStack.java

@@ -0,0 +1,72 @@
+package com.fasterxml.classmate.util;
+
+import java.util.ArrayList;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.classmate.types.ResolvedRecursiveType;
+
+/**
+ * Simple helper class used to keep track of 'call stack' for classes being referenced
+ * (as well as unbound variables)
+ */
+public final class ClassStack
+{
+    protected final ClassStack _parent;
+    protected final Class<?> _current;
+
+    private ArrayList<ResolvedRecursiveType> _selfRefs;
+
+    public ClassStack(Class<?> rootType) {
+        this(null, rootType);
+    }
+
+    private ClassStack(ClassStack parent, Class<?> curr) {
+        _parent = parent;
+        _current = curr;
+    }
+
+    /**
+     * @return New stack frame, if addition is ok; null if not
+     */
+    public ClassStack child(Class<?> cls)
+    {
+        return new ClassStack(this, cls);
+    }
+
+    /**
+     * Method called to indicate that there is a self-reference from
+     * deeper down in stack pointing into type this stack frame represents.
+     */
+    public void addSelfReference(ResolvedRecursiveType ref)
+    {
+        if (_selfRefs == null) {
+            _selfRefs = new ArrayList<ResolvedRecursiveType>();
+        }
+        _selfRefs.add(ref);
+    }
+
+    /**
+     * Method called when type that this stack frame represents is
+     * fully resolved, allowing self-references to be completed
+     * (if there are any)
+     */
+    public void resolveSelfReferences(ResolvedType resolved)
+    {
+        if (_selfRefs != null) {
+            for (ResolvedRecursiveType ref : _selfRefs) {
+                ref.setReference(resolved);
+            }
+        }
+    }
+
+    public ClassStack find(Class<?> cls)
+    {
+        if (_current == cls) return this;
+        for (ClassStack curr = _parent; curr != null; curr = curr._parent) {
+            if (curr._current == cls) {
+                return curr;
+            }
+        }
+        return null;
+    }
+}

fine-classmate/src/com/fasterxml/classmate/util/MethodKey.java

@@ -0,0 +1,71 @@
+package com.fasterxml.classmate.util;
+
+import java.io.Serializable;
+
+/**
+ * Helper class needed when storing methods in maps.
+ * Immutable.
+ */
+@SuppressWarnings("serial")
+public class MethodKey implements Serializable
+{
+    private static final Class<?>[] NO_CLASSES = new Class[0];
+
+    private final String _name;
+    
+    private final Class<?>[] _argumentTypes;
+
+    private final int _hashCode;
+    
+    public MethodKey(String name)
+    {
+        _name = name;
+        _argumentTypes = NO_CLASSES;
+        _hashCode = name.hashCode();
+    }
+
+    public MethodKey(String name, Class<?>[] argTypes)
+    {
+        _name = name;
+        _argumentTypes = argTypes;
+        _hashCode = name.hashCode() + argTypes.length;
+    }
+    
+    /*
+    /**********************************************************************
+    /* Standard methods
+    /**********************************************************************
+     */
+
+    /**
+     * Equality means name is the same and argument type erasures as well.
+     */
+    @Override public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null || o.getClass() != getClass()) return false;
+        MethodKey other = (MethodKey) o;
+        Class<?>[] otherArgs = other._argumentTypes;
+        int len = _argumentTypes.length;
+        if (otherArgs.length != len) return false;
+        for (int i = 0; i < len; ++i) {
+            if (otherArgs[i] != _argumentTypes[i]) return false;
+        }
+        return _name.equals(other._name);
+    }    
+
+    @Override public int hashCode() { return _hashCode; }
+
+    @Override public String toString()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(_name);
+        sb.append('(');
+        for (int i = 0, len = _argumentTypes.length; i < len; ++i) {
+            if (i > 0) sb.append(',');
+            sb.append(_argumentTypes[i].getName());
+        }
+        sb.append(')');
+        return sb.toString();
+    }
+}

fine-classmate/src/com/fasterxml/classmate/util/ResolvedTypeCache.java

@@ -0,0 +1,141 @@
+package com.fasterxml.classmate.util;
+
+import java.io.Serializable;
+import java.util.*;
+
+import com.fasterxml.classmate.ResolvedType;
+
+/**
+ * Simple LRU cache used for storing up to specified number of most recently accessed
+ * {@link ResolvedType} instances.
+ * Since usage pattern is such that caller needs synchronization, cache access methods
+ * are fully synchronized so that caller need not do explicit synchronization.
+ */
+@SuppressWarnings("serial")
+public class ResolvedTypeCache implements Serializable
+{
+    protected final CacheMap _map;
+    
+    public ResolvedTypeCache(int maxEntries) {
+        _map = new CacheMap(maxEntries);
+    }
+
+    /**
+     * Helper method for constructing reusable cache keys
+     */
+    public Key key(Class<?> simpleType) {
+        return new Key(simpleType);
+    }
+
+    /**
+     * Helper method for constructing reusable cache keys
+     */
+    public Key key(Class<?> simpleType, ResolvedType[] tp) {
+        return new Key(simpleType, tp);
+    }
+    
+    public synchronized ResolvedType find(Key key) {
+        return _map.get(key);
+    }
+
+    public synchronized int size() {
+        return _map.size();
+    }
+    
+    public synchronized void put(Key key, ResolvedType type) {
+        _map.put(key, type);
+    }
+
+    /*
+    /**********************************************************************
+    /* Methods for unit tests
+    /**********************************************************************
+     */
+    
+    public void add(ResolvedType type)
+    {
+        List<ResolvedType> tp = type.getTypeParameters();
+        ResolvedType[] tpa = tp.toArray(new ResolvedType[tp.size()]);
+        put(key(type.getErasedType(), tpa), type);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Helper classes
+    /**********************************************************************
+     */
+    
+    /**
+     * Key used for type entries.
+     */
+    public static class Key
+    {
+        private final Class<?> _erasedType;
+        
+        private final ResolvedType[] _typeParameters;
+        
+        private final int _hashCode;
+        
+        public Key(Class<?> simpleType) {
+            this(simpleType, null);
+        }
+        
+        public Key(Class<?> erasedType, ResolvedType[] tp)
+        {
+            // let's not hold on type empty arrays
+            if (tp != null && tp.length == 0) {
+                tp = null;
+            }
+            _erasedType = erasedType;
+            _typeParameters = tp;
+            int h = erasedType.getName().hashCode();
+            if (tp != null) {
+                h += tp.length;
+            }
+            _hashCode = h;
+        }
+        
+        @Override
+        public int hashCode() { return _hashCode; }
+
+        @Override
+        public boolean equals(Object o)
+        {
+            if (o == this) return true;
+            if (o == null || o.getClass() != getClass()) return false;
+            Key other = (Key) o;
+            if (other._erasedType != _erasedType) return false;
+            ResolvedType[] otherTP = other._typeParameters;
+            if (_typeParameters == null) {
+                return (otherTP == null);
+            }
+            if (otherTP == null || otherTP.length != _typeParameters.length) {
+                return false;
+            }
+            for (int i = 0, len = _typeParameters.length; i < len; ++i) {
+                if (!_typeParameters[i].equals(otherTP[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /**
+     * Simple sub-class to get LRU cache
+     */
+    private final static class CacheMap
+        extends LinkedHashMap<ResolvedTypeCache.Key, ResolvedType>
+    {
+        protected final int _maxEntries;
+        
+        public CacheMap(int maxEntries) {
+            _maxEntries = maxEntries;
+        }
+
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<Key, ResolvedType> eldest) {
+            return size() > _maxEntries;
+        }
+    }
+}

fine-classmate/src/com/fasterxml/classmate/util/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Various utility classes used by ClassMate.
+ */
+package com.fasterxml.classmate.util;

fine-druid/fine-druid.iml

@@ -8,5 +8,6 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="lib-druid" level="project" />
+    <orderEntry type="module" module-name="fine-hibernate" />
   </component>
 </module>

fine-druid/src/com/fr/third/alibaba/druid/support/hibernate/DruidConnectionProvider.java

@@ -19,9 +19,9 @@ import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.Map;
 
-import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
+import com.fr.third.org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
-import org.hibernate.service.spi.Configurable;
+import com.fr.third.org.hibernate.service.spi.Configurable;
-import org.hibernate.service.spi.Stoppable;
+import com.fr.third.org.hibernate.service.spi.Stoppable;
 
 import com.fr.third.alibaba.druid.pool.DruidDataSource;
 import com.fr.third.alibaba.druid.pool.DruidDataSourceFactory;

fine-hibernate/fine-hibernate.iml

@@ -10,5 +10,7 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="hibernate-build" level="project" />
     <orderEntry type="module" module-name="fine-jboss-logging" />
+    <orderEntry type="module" module-name="fine-classmate" />
+    <orderEntry type="module" module-name="fine-jpa" />
   </component>
 </module>

fine-hibernate/src/com/fr/third/org/hibernate/Criteria.java

@@ -492,7 +492,7 @@ public interface Criteria extends CriteriaSpecification {
 	
 	  
 	/**
-	 * Add a DB query hint to the SQL.  These differ from JPA's {@link javax.persistence.QueryHint}, which is specific
+	 * Add a DB query hint to the SQL.  These differ from JPA's {@link com.fr.third.javax.persistence.QueryHint}, which is specific
 	 * to the JPA implementation and ignores DB vendor-specific hints.  Instead, these are intended solely for the
 	 * vendor-specific hints, such as Oracle's optimizers.  Multiple query hints are supported; the Dialect will
 	 * determine concatenation and placement.

fine-hibernate/src/com/fr/third/org/hibernate/LockMode.java

@@ -76,7 +76,7 @@ public enum LockMode {
 	FORCE( 15, "force" ),
 
 	/**
-	 *  start of javax.persistence.LockModeType equivalent modes
+	 *  start of com.fr.third.javax.persistence.LockModeType equivalent modes
 	 */
 
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/Query.java

@@ -195,7 +195,7 @@ public interface Query extends BasicQueryContract {
 	public Query setComment(String comment);
 	
 	/**
-	 * Add a DB query hint to the SQL.  These differ from JPA's {@link javax.persistence.QueryHint}, which is specific
+	 * Add a DB query hint to the SQL.  These differ from JPA's {@link com.fr.third.javax.persistence.QueryHint}, which is specific
 	 * to the JPA implementation and ignores DB vendor-specific hints.  Instead, these are intended solely for the
 	 * vendor-specific hints, such as Oracle's optimizers.  Multiple query hints are supported; the Dialect will
 	 * determine concatenation and placement.

fine-hibernate/src/com/fr/third/org/hibernate/SQLQuery.java

@@ -55,7 +55,7 @@ public interface SQLQuery extends Query, SynchronizeableQuery {
 
 	/**
 	 * Use a predefined named result-set mapping.  This might be defined by a {@code <result-set/>} element in a
-	 * Hibernate <tt>hbm.xml</tt> file or through a {@link javax.persistence.SqlResultSetMapping} annotation.
+	 * Hibernate <tt>hbm.xml</tt> file or through a {@link com.fr.third.javax.persistence.SqlResultSetMapping} annotation.
 	 *
 	 * @param name The name of the mapping to use.
 	 *
@@ -80,7 +80,7 @@ public interface SQLQuery extends Query, SynchronizeableQuery {
 	/**
 	 * Declare a scalar query result. Hibernate will attempt to automatically detect the underlying type.
 	 * <p/>
-	 * Functions like {@code <return-scalar/>} in {@code hbm.xml} or {@link javax.persistence.ColumnResult}
+	 * Functions like {@code <return-scalar/>} in {@code hbm.xml} or {@link com.fr.third.javax.persistence.ColumnResult}
 	 *
 	 * @param columnAlias The column alias in the result-set to be processed as a scalar result
 	 *
@@ -91,7 +91,7 @@ public interface SQLQuery extends Query, SynchronizeableQuery {
 	/**
 	 * Declare a scalar query result.
 	 * <p/>
-	 * Functions like {@code <return-scalar/>} in {@code hbm.xml} or {@link javax.persistence.ColumnResult}
+	 * Functions like {@code <return-scalar/>} in {@code hbm.xml} or {@link com.fr.third.javax.persistence.ColumnResult}
 	 *
 	 * @param columnAlias The column alias in the result-set to be processed as a scalar result
 	 * @param type The Hibernate type as which to treat the value.

fine-hibernate/src/com/fr/third/org/hibernate/SharedSessionContract.java

@@ -76,7 +76,7 @@ public interface SharedSessionContract extends Serializable {
 	 *
 	 * @return The ProcedureCall
 	 *
-	 * @see javax.persistence.NamedStoredProcedureQuery
+	 * @see com.fr.third.javax.persistence.NamedStoredProcedureQuery
 	 */
 	public ProcedureCall getNamedProcedureCall(String name);
 

fine-hibernate/src/com/fr/third/org/hibernate/annotations/AccessType.java

@@ -15,13 +15,13 @@ import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Property Access type.  Prefer the standard {@link javax.persistence.Access} annotation; however,
+ * Property Access type.  Prefer the standard {@link com.fr.third.javax.persistence.Access} annotation; however,
  * {@code @Access} is limited to field/property access definitions.
  *
  * @author Emmanuel Bernard
  *
  * @deprecated Use {@link AttributeAccessor} instead; renamed to avoid confusion with the JPA
- * {@link javax.persistence.AccessType} enum.
+ * {@link com.fr.third.javax.persistence.AccessType} enum.
  */
 @Target({ TYPE, METHOD, FIELD })
 @Retention(RUNTIME)

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Any.java

@@ -6,8 +6,8 @@
  */
 package com.fr.third.org.hibernate.annotations;
 import java.lang.annotation.Retention;
-import javax.persistence.Column;
+import com.fr.third.javax.persistence.Column;
-import javax.persistence.FetchType;
+import com.fr.third.javax.persistence.FetchType;
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;

fine-hibernate/src/com/fr/third/org/hibernate/annotations/AttributeAccessor.java

@@ -27,10 +27,10 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  * </ul>
  *
  * Should only be used to name custom {@link com.fr.third.org.hibernate.property.access.spi.PropertyAccessStrategy}.  For
- * {@code property/field} access, the JPA {@link javax.persistence.Access} annotation should be preferred
+ * {@code property/field} access, the JPA {@link com.fr.third.javax.persistence.Access} annotation should be preferred
- * using the appropriate {@link javax.persistence.AccessType}.  However, if this annotation is used with
+ * using the appropriate {@link com.fr.third.javax.persistence.AccessType}.  However, if this annotation is used with
  * either {@code value="property"} or {@code value="field"}, it will act just as the corresponding usage
- * of {@link javax.persistence.Access}.
+ * of {@link com.fr.third.javax.persistence.Access}.
  *
  * @see com.fr.third.org.hibernate.property.access.spi.PropertyAccessStrategy
  * @see com.fr.third.org.hibernate.property.access.spi.PropertyAccessStrategyResolver

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Cascade.java

@@ -14,8 +14,8 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * Apply a cascade strategy on an association.  Used to apply Hibernate specific cascades.  For JPA cascading, prefer
- * using {@link javax.persistence.CascadeType} on {@link javax.persistence.OneToOne},
+ * using {@link com.fr.third.javax.persistence.CascadeType} on {@link com.fr.third.javax.persistence.OneToOne},
- * {@link javax.persistence.OneToMany}, etc.  Hibernate will merge together both sets of cascades.
+ * {@link com.fr.third.javax.persistence.OneToMany}, etc.  Hibernate will merge together both sets of cascades.
  *
  * @author Emmanuel Bernard
  * @author Steve Ebersole

fine-hibernate/src/com/fr/third/org/hibernate/annotations/CascadeType.java

@@ -15,19 +15,19 @@ public enum CascadeType {
 	 */
 	ALL,
 	/**
-	 * Corresponds to {@link javax.persistence.CascadeType#PERSIST}.
+	 * Corresponds to {@link com.fr.third.javax.persistence.CascadeType#PERSIST}.
 	 */
 	PERSIST,
 	/**
-	 * Corresponds to {@link javax.persistence.CascadeType#MERGE}.
+	 * Corresponds to {@link com.fr.third.javax.persistence.CascadeType#MERGE}.
 	 */
 	MERGE,
 	/**
-	 * Corresponds to {@link javax.persistence.CascadeType#REMOVE}.
+	 * Corresponds to {@link com.fr.third.javax.persistence.CascadeType#REMOVE}.
 	 */
 	REMOVE,
 	/**
-	 * Corresponds to {@link javax.persistence.CascadeType#REFRESH}.
+	 * Corresponds to {@link com.fr.third.javax.persistence.CascadeType#REFRESH}.
 	 */
 	REFRESH,
 	/**
@@ -56,12 +56,12 @@ public enum CascadeType {
 	/**
 	 * JPA originally planned on calling DETACH EVICT.
 	 *
-	 * @deprecated use javax.persistence.CascadeType.DETACH
+	 * @deprecated use com.fr.third.javax.persistence.CascadeType.DETACH
 	 */
 	@Deprecated
 	EVICT,
 	/**
-	 * Corresponds to {@link javax.persistence.CascadeType#REFRESH}.
+	 * Corresponds to {@link com.fr.third.javax.persistence.CascadeType#REFRESH}.
 	 */
 	DETACH
 }

fine-hibernate/src/com/fr/third/org/hibernate/annotations/CollectionId.java

@@ -8,7 +8,7 @@ package com.fr.third.org.hibernate.annotations;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import javax.persistence.Column;
+import com.fr.third.javax.persistence.Column;
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Columns.java

@@ -8,7 +8,7 @@ package com.fr.third.org.hibernate.annotations;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import javax.persistence.Column;
+import com.fr.third.javax.persistence.Column;
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;

fine-hibernate/src/com/fr/third/org/hibernate/annotations/DiscriminatorFormula.java

@@ -14,7 +14,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * Used to apply a Hibernate formula (derived value) as the inheritance discriminator "column".  Used in place of
- * the JPA {@link javax.persistence.DiscriminatorColumn} when a formula is wanted.
+ * the JPA {@link com.fr.third.javax.persistence.DiscriminatorColumn} when a formula is wanted.
  *
  * To be placed on the root entity.
  *

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Entity.java

@@ -13,7 +13,7 @@ import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Extends {@link javax.persistence.Entity} with Hibernate features.
+ * Extends {@link com.fr.third.javax.persistence.Entity} with Hibernate features.
  *
  * @author Emmanuel Bernard
  *

fine-hibernate/src/com/fr/third/org/hibernate/annotations/FetchMode.java

@@ -7,7 +7,7 @@
 package com.fr.third.org.hibernate.annotations;
 
 /**
- * Fetch options on associations.  Defines more of the "how" of fetching, whereas JPA {@link javax.persistence.FetchType}
+ * Fetch options on associations.  Defines more of the "how" of fetching, whereas JPA {@link com.fr.third.javax.persistence.FetchType}
  * focuses on the "when".
  *
  * @author Emmanuel Bernard

fine-hibernate/src/com/fr/third/org/hibernate/annotations/FlushModeType.java

@@ -7,7 +7,7 @@
 package com.fr.third.org.hibernate.annotations;
 
 /**
- * Enumeration extending javax.persistence flush modes.
+ * Enumeration extending com.fr.third.javax.persistence flush modes.
  *
  * @author Carlos Gonz<EFBFBD>lez-Cadenas
  */

fine-hibernate/src/com/fr/third/org/hibernate/annotations/ForeignKey.java

@@ -17,7 +17,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 /**
  * Define the foreign key name.
  *
- * @deprecated Prefer the JPA 2.1 introduced {@link javax.persistence.ForeignKey} instead.
+ * @deprecated Prefer the JPA 2.1 introduced {@link com.fr.third.javax.persistence.ForeignKey} instead.
  */
 @Target({FIELD, METHOD, TYPE})
 @Retention(RUNTIME)

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Index.java

@@ -17,7 +17,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  *
  * @author Emmanuel Bernard
  *
- * @deprecated Using {@link javax.persistence.Index} instead.
+ * @deprecated Using {@link com.fr.third.javax.persistence.Index} instead.
  */
 @Target({FIELD, METHOD})
 @Retention(RUNTIME)

fine-hibernate/src/com/fr/third/org/hibernate/annotations/IndexColumn.java

@@ -18,7 +18,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  *
  * @author Matthew Inger
  *
- * @deprecated Prefer the standard JPA {@link javax.persistence.OrderColumn} annotation and the Hibernate specific
+ * @deprecated Prefer the standard JPA {@link com.fr.third.javax.persistence.OrderColumn} annotation and the Hibernate specific
  * {@link ListIndexBase} (for replacing {@link #base()}).
  */
 @Target({METHOD, FIELD})

fine-hibernate/src/com/fr/third/org/hibernate/annotations/JoinColumnOrFormula.java

@@ -8,7 +8,7 @@ package com.fr.third.org.hibernate.annotations;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import javax.persistence.JoinColumn;
+import com.fr.third.javax.persistence.JoinColumn;
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;

fine-hibernate/src/com/fr/third/org/hibernate/annotations/ListIndexBase.java

@@ -17,9 +17,9 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  *
  * By default list indexes are stored starting at zero.
  *
- * Generally used in conjunction with {@link javax.persistence.OrderColumn}.
+ * Generally used in conjunction with {@link com.fr.third.javax.persistence.OrderColumn}.
  *
- * @see javax.persistence.OrderColumn
+ * @see com.fr.third.javax.persistence.OrderColumn
  *
  * @author Steve Ebersole
  */

fine-hibernate/src/com/fr/third/org/hibernate/annotations/ManyToAny.java

@@ -7,8 +7,8 @@
 package com.fr.third.org.hibernate.annotations;
 
 import java.lang.annotation.Retention;
-import javax.persistence.Column;
+import com.fr.third.javax.persistence.Column;
-import javax.persistence.FetchType;
+import com.fr.third.javax.persistence.FetchType;
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;

fine-hibernate/src/com/fr/third/org/hibernate/annotations/NamedNativeQueries.java

@@ -14,7 +14,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * A grouping of Hibernate-specific {@link NamedNativeQuery} definitions.  Effectively extends the named native
- * query definitions made available through {@link javax.persistence.NamedNativeQueries}.
+ * query definitions made available through {@link com.fr.third.javax.persistence.NamedNativeQueries}.
  *
  * @author Emmanuel Bernard
  */

fine-hibernate/src/com/fr/third/org/hibernate/annotations/NamedNativeQuery.java

@@ -13,7 +13,7 @@ import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Extends {@link javax.persistence.NamedNativeQuery} with Hibernate features.
+ * Extends {@link com.fr.third.javax.persistence.NamedNativeQuery} with Hibernate features.
  *
  * @author Emmanuel Bernard
  *

fine-hibernate/src/com/fr/third/org/hibernate/annotations/NamedQueries.java

@@ -14,7 +14,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * A grouping of Hibernate-specific {@link NamedQuery} definitions.  Effectively extends the named query
- * definitions made available through {@link javax.persistence.NamedQueries}.
+ * definitions made available through {@link com.fr.third.javax.persistence.NamedQueries}.
  *
  * @author Emmanuel Bernard
  * @author Carlos Gonz<EFBFBD>lez-Cadenas

fine-hibernate/src/com/fr/third/org/hibernate/annotations/NamedQuery.java

@@ -14,7 +14,7 @@ import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Extends {@link javax.persistence.NamedQuery} with Hibernate features.
+ * Extends {@link com.fr.third.javax.persistence.NamedQuery} with Hibernate features.
  *
  * @author Carlos Gonzalez-Cadenas
  *

fine-hibernate/src/com/fr/third/org/hibernate/annotations/OptimisticLockType.java

@@ -19,7 +19,7 @@ public enum OptimisticLockType {
 	/**
 	 * Perform optimistic locking using a dedicated version column.
 	 *
-	 * @see javax.persistence.Version
+	 * @see com.fr.third.javax.persistence.Version
 	 */
 	VERSION,
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/annotations/OrderBy.java

@@ -15,13 +15,13 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 /**
  * Order a collection using SQL ordering (not HQL ordering).
  *
- * Different from {@link javax.persistence.OrderBy} in that this expects SQL fragment, JPA OrderBy expects a
+ * Different from {@link com.fr.third.javax.persistence.OrderBy} in that this expects SQL fragment, JPA OrderBy expects a
  * valid JPQL order-by fragment.
  *
  * @author Emmanuel Bernard
  * @author Steve Ebersole
  *
- * @see javax.persistence.OrderBy
+ * @see com.fr.third.javax.persistence.OrderBy
  * @see SortComparator
  * @see SortNatural
  */

fine-hibernate/src/com/fr/third/org/hibernate/annotations/QueryHints.java

@@ -91,13 +91,13 @@ public class QueryHints {
 	/**
 	 * Apply a JPA query timeout, which is defined in <b>milliseconds</b>.
 	 */
-	public static final String TIMEOUT_JPA = "javax.persistence.query.timeout";
+	public static final String TIMEOUT_JPA = "com.fr.third.javax.persistence.query.timeout";
 
 	/**
 	 * Available to apply lock mode to a native SQL query since JPA requires that
-	 * {@link javax.persistence.Query#setLockMode} throw an IllegalStateException if called for a native query.
+	 * {@link com.fr.third.javax.persistence.Query#setLockMode} throw an IllegalStateException if called for a native query.
 	 * <p/>
-	 * Accepts a {@link javax.persistence.LockModeType} or a {@link com.fr.third.org.hibernate.LockMode}
+	 * Accepts a {@link com.fr.third.javax.persistence.LockModeType} or a {@link com.fr.third.org.hibernate.LockMode}
 	 */
 	public static final String NATIVE_LOCKMODE = "com.fr.third.org.hibernate.lockMode";
 	
@@ -108,13 +108,13 @@ public class QueryHints {
 	 * Note: Currently, attributes that are not specified are treated as FetchType.LAZY or FetchType.EAGER depending
 	 * on the attribute's definition in metadata, rather than forcing FetchType.LAZY.
 	 */
-	public static final String FETCHGRAPH = "javax.persistence.fetchgraph";
+	public static final String FETCHGRAPH = "com.fr.third.javax.persistence.fetchgraph";
 	
 	/**
 	 * Hint providing a "loadgraph" EntityGraph.  Attributes explicitly specified as AttributeNodes are treated as
 	 * FetchType.EAGER (via join fetch or subsequent select).  Attributes that are not specified are treated as
 	 * FetchType.LAZY or FetchType.EAGER depending on the attribute's definition in metadata
 	 */
-	public static final String LOADGRAPH = "javax.persistence.loadgraph";
+	public static final String LOADGRAPH = "com.fr.third.javax.persistence.loadgraph";
 
 }

fine-hibernate/src/com/fr/third/org/hibernate/annotations/Source.java

@@ -14,7 +14,7 @@ import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Optional annotation in conjunction with {@link javax.persistence.Version} and timestamp version properties
+ * Optional annotation in conjunction with {@link com.fr.third.javax.persistence.Version} and timestamp version properties
  * indicating the source of the timestamp value.
  *
  * @author Hardy Ferentschik

fine-hibernate/src/com/fr/third/org/hibernate/annotations/common/annotationfactory/AnnotationFactory.java

@@ -39,8 +39,8 @@ public class AnnotationFactory {
 	 * Creates an Annotation proxy for the given annotation descriptor.
 	 * <p/>
 	 * NOTE: the proxy here is generated using the ClassLoader of the Annotation type's Class.  E.g.,
-	 * if asked to create an Annotation proxy for javax.persistence.Entity we would use the ClassLoader
+	 * if asked to create an Annotation proxy for com.fr.third.javax.persistence.Entity we would use the ClassLoader
-	 * of the javax.persistence.Entity Class for generating the proxy.
+	 * of the com.fr.third.javax.persistence.Entity Class for generating the proxy.
 	 *
 	 * @param descriptor The annotation descriptor
 	 *

fine-hibernate/src/com/fr/third/org/hibernate/annotations/common/util/impl/Log.java

@@ -21,10 +21,10 @@
 package com.fr.third.org.hibernate.annotations.common.util.impl;
 
 import com.fr.third.org.jboss.logging.BasicLogger;
-import org.jboss.logging.annotations.Cause;
+import com.fr.third.org.jboss.logging.annotations.Cause;
-import org.jboss.logging.annotations.LogMessage;
+import com.fr.third.org.jboss.logging.annotations.LogMessage;
-import org.jboss.logging.annotations.Message;
+import com.fr.third.org.jboss.logging.annotations.Message;
-import org.jboss.logging.annotations.MessageLogger;
+import com.fr.third.org.jboss.logging.annotations.MessageLogger;
 
 import static com.fr.third.org.jboss.logging.Logger.Level.ERROR;
 import static com.fr.third.org.jboss.logging.Logger.Level.INFO;

fine-hibernate/src/com/fr/third/org/hibernate/boot/MetadataBuilder.java

@@ -6,8 +6,8 @@
  */
 package com.fr.third.org.hibernate.boot;
 
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
-import javax.persistence.SharedCacheMode;
+import com.fr.third.javax.persistence.SharedCacheMode;
 
 import com.fr.third.org.hibernate.annotations.common.reflection.ReflectionManager;
 import com.fr.third.org.hibernate.boot.archive.scan.spi.ScanEnvironment;
@@ -112,7 +112,7 @@ public interface MetadataBuilder {
 	 * Specify the second-level cache mode to be used.  This is the cache mode in terms of whether or
 	 * not to cache.
 	 * <p/>
-	 * Its default is defined by the {@coce javax.persistence.sharedCache.mode} setting if using
+	 * Its default is defined by the {@coce com.fr.third.javax.persistence.sharedCache.mode} setting if using
 	 * property-based configuration.
 	 *
 	 * @param cacheMode The cache mode.
@@ -135,7 +135,7 @@ public interface MetadataBuilder {
 	 * @return {@code this}, for method chaining
 	 *
 	 * @see com.fr.third.org.hibernate.cfg.AvailableSettings#DEFAULT_CACHE_CONCURRENCY_STRATEGY
-	 * @see #applySharedCacheMode(javax.persistence.SharedCacheMode)
+	 * @see #applySharedCacheMode(com.fr.third.javax.persistence.SharedCacheMode)
 	 */
 	MetadataBuilder applyAccessType(AccessType accessType);
 
@@ -205,10 +205,10 @@ public interface MetadataBuilder {
 	/**
 	 * Should we enable support for the "new" (since 3.2) identifier generator mappings for
 	 * handling:<ul>
-	 *     <li>{@link javax.persistence.GenerationType#SEQUENCE}</li>
+	 *     <li>{@link com.fr.third.javax.persistence.GenerationType#SEQUENCE}</li>
-	 *     <li>{@link javax.persistence.GenerationType#IDENTITY}</li>
+	 *     <li>{@link com.fr.third.javax.persistence.GenerationType#IDENTITY}</li>
-	 *     <li>{@link javax.persistence.GenerationType#TABLE}</li>
+	 *     <li>{@link com.fr.third.javax.persistence.GenerationType#TABLE}</li>
-	 *     <li>{@link javax.persistence.GenerationType#AUTO}</li>
+	 *     <li>{@link com.fr.third.javax.persistence.GenerationType#AUTO}</li>
 	 * </ul>
 	 * <p/>
 	 * Its default is defined by the {@link com.fr.third.org.hibernate.cfg.AvailableSettings#USE_NEW_ID_GENERATOR_MAPPINGS}
@@ -364,7 +364,7 @@ public interface MetadataBuilder {
 	 * Ideally we should avoid accessing ClassLoaders when perform 1st phase of bootstrap.  This
 	 * is a ClassLoader that can be used in cases when we have to.  IN EE managed environments, this
 	 * is the ClassLoader mandated by
-	 * {@link javax.persistence.spi.PersistenceUnitInfo#getNewTempClassLoader()}.  This ClassLoader
+	 * {@link com.fr.third.javax.persistence.spi.PersistenceUnitInfo#getNewTempClassLoader()}.  This ClassLoader
 	 * is thrown away by the container afterwards.  The idea being that the Class can still be enhanced
 	 * in the application ClassLoader.  In other environments, pass a ClassLoader that performs the
 	 * same function if desired.

fine-hibernate/src/com/fr/third/org/hibernate/boot/archive/scan/spi/ClassFileArchiveEntryHandler.java

@@ -9,10 +9,10 @@ package com.fr.third.org.hibernate.boot.archive.scan.spi;
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import javax.persistence.Converter;
+import com.fr.third.javax.persistence.Converter;
-import javax.persistence.Embeddable;
+import com.fr.third.javax.persistence.Embeddable;
-import javax.persistence.Entity;
+import com.fr.third.javax.persistence.Entity;
-import javax.persistence.MappedSuperclass;
+import com.fr.third.javax.persistence.MappedSuperclass;
 
 import javassist.bytecode.AnnotationsAttribute;
 import javassist.bytecode.ClassFile;

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/AttributeConverterDescriptorImpl.java

@@ -12,7 +12,7 @@ import java.lang.reflect.Method;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
 
 import com.fr.third.org.hibernate.AnnotationException;
 import com.fr.third.org.hibernate.HibernateException;

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/AttributeConverterDescriptorNonAutoApplicableImpl.java

@@ -12,7 +12,7 @@ import java.lang.reflect.TypeVariable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
 
 import com.fr.third.org.hibernate.AnnotationException;
 import com.fr.third.org.hibernate.AssertionFailure;

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/IdGeneratorInterpreterImpl.java

@@ -8,9 +8,9 @@ package com.fr.third.org.hibernate.boot.internal;
 
 import java.util.ArrayList;
 import java.util.UUID;
-import javax.persistence.GenerationType;
+import com.fr.third.javax.persistence.GenerationType;
-import javax.persistence.SequenceGenerator;
+import com.fr.third.javax.persistence.SequenceGenerator;
-import javax.persistence.TableGenerator;
+import com.fr.third.javax.persistence.TableGenerator;
 
 import com.fr.third.org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
 import com.fr.third.org.hibernate.boot.model.IdentifierGeneratorDefinition;

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java

@@ -18,10 +18,10 @@ import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
-import javax.persistence.Embeddable;
+import com.fr.third.javax.persistence.Embeddable;
-import javax.persistence.Entity;
+import com.fr.third.javax.persistence.Entity;
-import javax.persistence.MapsId;
+import com.fr.third.javax.persistence.MapsId;
 
 import com.fr.third.org.hibernate.AnnotationException;
 import com.fr.third.org.hibernate.AssertionFailure;
@@ -1031,7 +1031,7 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector
 		else if ( clazz.isAnnotationPresent( Embeddable.class ) ) {
 			type = AnnotatedClassType.EMBEDDABLE;
 		}
-		else if ( clazz.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) {
+		else if ( clazz.isAnnotationPresent( com.fr.third.javax.persistence.MappedSuperclass.class ) ) {
 			type = AnnotatedClassType.EMBEDDABLE_SUPERCLASS;
 		}
 		else {

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/MetadataBuilderImpl.java

@@ -13,8 +13,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Callable;
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
-import javax.persistence.SharedCacheMode;
+import com.fr.third.javax.persistence.SharedCacheMode;
 
 import com.fr.third.org.hibernate.AssertionFailure;
 import com.fr.third.org.hibernate.HibernateException;
@@ -620,7 +620,7 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
 			);
 
 			this.sharedCacheMode = configService.getSetting(
-					"javax.persistence.sharedCache.mode",
+					"com.fr.third.javax.persistence.sharedCache.mode",
 					new ConfigurationService.Converter<SharedCacheMode>() {
 						@Override
 						public SharedCacheMode convert(Object value) {

fine-hibernate/src/com/fr/third/org/hibernate/boot/internal/SessionFactoryBuilderImpl.java

@@ -526,8 +526,8 @@ public class SessionFactoryBuilderImpl implements SessionFactoryBuilderImplement
 			cfgService = new ConfigurationServiceImpl( configurationSettings );
 			( (ConfigurationServiceImpl) cfgService ).injectServices( (ServiceRegistryImplementor) serviceRegistry );
 
-			this.beanManagerReference = configurationSettings.get( "javax.persistence.bean.manager" );
+			this.beanManagerReference = configurationSettings.get( "com.fr.third.javax.persistence.bean.manager" );
-			this.validatorFactoryReference = configurationSettings.get( "javax.persistence.validation.factory" );
+			this.validatorFactoryReference = configurationSettings.get( "com.fr.third.javax.persistence.validation.factory" );
 
 			this.sessionFactoryName = (String) configurationSettings.get( SESSION_FACTORY_NAME );
 			this.sessionFactoryNameAlsoJndiName = cfgService.getSetting(

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/IdGeneratorStrategyInterpreter.java

@@ -6,9 +6,9 @@
  */
 package com.fr.third.org.hibernate.boot.model;
 
-import javax.persistence.GenerationType;
+import com.fr.third.javax.persistence.GenerationType;
-import javax.persistence.SequenceGenerator;
+import com.fr.third.javax.persistence.SequenceGenerator;
-import javax.persistence.TableGenerator;
+import com.fr.third.javax.persistence.TableGenerator;
 
 /**
  * Strategy for interpreting identifier generator related information.
@@ -25,7 +25,7 @@ public interface IdGeneratorStrategyInterpreter {
 	 * GenerationType, returning {@code null} to indicate that this interpreter
 	 * did not have a match and that any additional resolutions should be performed.
 	 *
-	 * @param generationType The {@link javax.persistence.GeneratedValue#strategy} value
+	 * @param generationType The {@link com.fr.third.javax.persistence.GeneratedValue#strategy} value
 	 * @param context The context for resolution (method parameter object)
 	 */
 	String determineGeneratorName(GenerationType generationType, GeneratorNameDeterminationContext context);

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/EntityNaming.java

@@ -31,7 +31,7 @@ public interface EntityNaming {
 	public String getEntityName();
 
 	/**
-	 * The JPA-specific entity name.  See {@link javax.persistence.Entity#name()} for details.
+	 * The JPA-specific entity name.  See {@link com.fr.third.javax.persistence.Entity#name()} for details.
 	 *
 	 * @return The JPA entity name, if one was specified.  May return {@code null} if one
 	 * was not explicitly specified.

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitBasicColumnNameSource.java

@@ -13,7 +13,7 @@ import com.fr.third.org.hibernate.boot.model.source.spi.AttributePath;
  *
  * @author Steve Ebersole
  *
- * @see javax.persistence.Column
+ * @see com.fr.third.javax.persistence.Column
  */
 public interface ImplicitBasicColumnNameSource extends ImplicitNameSource {
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitCollectionTableNameSource.java

@@ -13,7 +13,7 @@ import com.fr.third.org.hibernate.boot.model.source.spi.AttributePath;
  *
  * @author Steve Ebersole
  *
- * @see javax.persistence.CollectionTable
+ * @see com.fr.third.javax.persistence.CollectionTable
  */
 public interface ImplicitCollectionTableNameSource extends ImplicitNameSource {
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitJoinColumnNameSource.java

@@ -10,11 +10,11 @@ import com.fr.third.org.hibernate.boot.model.source.spi.AttributePath;
 
 /**
  * Context for determining the implicit name of a "join column" (think
- * {@link javax.persistence.JoinColumn}).
+ * {@link com.fr.third.javax.persistence.JoinColumn}).
  *
  * @author Steve Ebersole
  *
- * @see javax.persistence.JoinColumn
+ * @see com.fr.third.javax.persistence.JoinColumn
  */
 public interface ImplicitJoinColumnNameSource extends ImplicitNameSource {
 	public static enum Nature {

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitJoinTableNameSource.java

@@ -13,7 +13,7 @@ import com.fr.third.org.hibernate.boot.model.source.spi.AttributePath;
  *
  * @author Steve Ebersole
  *
- * @see javax.persistence.JoinTable
+ * @see com.fr.third.javax.persistence.JoinTable
  */
 public interface ImplicitJoinTableNameSource extends ImplicitNameSource {
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitMapKeyColumnNameSource.java

@@ -11,13 +11,13 @@ import com.fr.third.org.hibernate.boot.model.source.spi.AttributePath;
 /**
  * Context for determining the implicit name of a column used to back the key
  * of a {@link java.util.Map}.  This is used for both
- * {@link javax.persistence.MapKeyColumn} and
+ * {@link com.fr.third.javax.persistence.MapKeyColumn} and
- * {@link javax.persistence.MapKeyJoinColumn} cases.
+ * {@link com.fr.third.javax.persistence.MapKeyJoinColumn} cases.
  *
  * @author Steve Ebersole
  *
- * @see javax.persistence.MapKeyColumn
+ * @see com.fr.third.javax.persistence.MapKeyColumn
- * @see javax.persistence.MapKeyJoinColumn
+ * @see com.fr.third.javax.persistence.MapKeyJoinColumn
  */
 public interface ImplicitMapKeyColumnNameSource extends ImplicitNameSource {
 	/**

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ImplicitNamingStrategy.java

@@ -18,10 +18,10 @@ package com.fr.third.org.hibernate.boot.model.naming;
  *             <li>
  *                 Entity primary table - {@link #determinePrimaryTableName}.  Used when the
  *                 primary table for an entity is not explicitly named in the metadata.  See
- *                 {@link javax.persistence.Table} for details.
+ *                 {@link com.fr.third.javax.persistence.Table} for details.
  *             </li>
  *             <li>
- *                 Join table - {@link #determineJoinTableName}.  See {@link javax.persistence.JoinTable}
+ *                 Join table - {@link #determineJoinTableName}.  See {@link com.fr.third.javax.persistence.JoinTable}
  *                 for details.  Join table covers basically any entity association whether in the form
  *                 of a collection of entities (one-to-many, many-to-many) or a singular entity association
  *                 (many-to-one, and occasionally one-to-one).
@@ -29,7 +29,7 @@ package com.fr.third.org.hibernate.boot.model.naming;
  *             <li>
  *                 Collection table - {@link #determineCollectionTableName} - Collection table
  *                 refers to any non-entity collection (basic, component/embeddable, any).  See
- *                 {@link javax.persistence.CollectionTable} for details.
+ *                 {@link com.fr.third.javax.persistence.CollectionTable} for details.
  *             </li>
  *             <li>
  *                 <i>Notice that secondary tables are not mentioned, since they must always be explicitly named</i>
@@ -114,7 +114,7 @@ public interface ImplicitNamingStrategy {
 	public Identifier determineBasicColumnName(ImplicitBasicColumnNameSource source);
 
 	/**
-	 * Determine the column name related to {@link javax.persistence.JoinColumn}.  In
+	 * Determine the column name related to {@link com.fr.third.javax.persistence.JoinColumn}.  In
 	 * {@code hbm.xml} terms, this would be a {@code <key/>} defined for a collection
 	 * or the column associated with a many-to-one.
 	 *
@@ -125,7 +125,7 @@ public interface ImplicitNamingStrategy {
 	public Identifier determineJoinColumnName(ImplicitJoinColumnNameSource source);
 
 	/**
-	 * Determine the column name related to {@link javax.persistence.PrimaryKeyJoinColumn}.  In
+	 * Determine the column name related to {@link com.fr.third.javax.persistence.PrimaryKeyJoinColumn}.  In
 	 * {@code hbm.xml} terms, this would be a {@code <key/>} defined for a {@code <join/>}
 	 * or a {@code <joined-subclass/>} (others?)
 	 *

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/naming/ObjectNameNormalizer.java

@@ -95,8 +95,8 @@ public abstract class ObjectNameNormalizer {
 
 	/**
 	 * Intended only for use in handling quoting requirements for {@code column-definition}
-	 * as defined by {@link javax.persistence.Column#columnDefinition()},
+	 * as defined by {@link com.fr.third.javax.persistence.Column#columnDefinition()},
-	 *  {@link javax.persistence.JoinColumn#columnDefinition}, etc.  This method should not
+	 *  {@link com.fr.third.javax.persistence.JoinColumn#columnDefinition}, etc.  This method should not
 	 * be called in any other scenario.
 	 *
 	 * @param text The specified column definition

fine-hibernate/src/com/fr/third/org/hibernate/boot/model/process/internal/ScanningCoordinator.java

@@ -12,7 +12,7 @@ import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import javax.persistence.AttributeConverter;
+import com.fr.third.javax.persistence.AttributeConverter;
 
 import com.fr.third.org.hibernate.boot.MappingException;
 import com.fr.third.org.hibernate.boot.archive.internal.StandardArchiveDescriptorFactory;