incubator-deltaspike-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gpetra...@apache.org
Subject [3/4] git commit: DELTASPIKE-85 renamed util classes
Date Wed, 21 Mar 2012 13:49:09 GMT
DELTASPIKE-85 renamed util classes


Project: http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/commit/ccb8cb01
Tree: http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/tree/ccb8cb01
Diff: http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/diff/ccb8cb01

Branch: refs/heads/master
Commit: ccb8cb01830bb895f3d7f98cf0af8d1308a3a73e
Parents: 73c8359
Author: gpetracek <gpetracek@apache.org>
Authored: Wed Mar 21 14:32:29 2012 +0100
Committer: gpetracek <gpetracek@apache.org>
Committed: Wed Mar 21 14:32:29 2012 +0100

----------------------------------------------------------------------
 .../api/metadata/builder/AnnotatedTypeBuilder.java |   10 +-
 .../api/metadata/builder/AnnotationBuilder.java    |    4 +-
 .../metadata/builder/ImmutableInjectionPoint.java  |    6 +-
 .../api/metadata/builder/InjectableMethod.java     |    8 +-
 .../org/apache/deltaspike/core/util/BeanUtils.java |  198 ++
 .../org/apache/deltaspike/core/util/Beans.java     |  198 --
 .../deltaspike/core/util/ReflectionUtils.java      | 1419 +++++++++++++++
 .../apache/deltaspike/core/util/Reflections.java   | 1419 ---------------
 8 files changed, 1631 insertions(+), 1631 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotatedTypeBuilder.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotatedTypeBuilder.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotatedTypeBuilder.java
index f0f9f90..53ae3f9 100644
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotatedTypeBuilder.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotatedTypeBuilder.java
@@ -19,7 +19,7 @@
 
 package org.apache.deltaspike.core.api.metadata.builder;
 
-import org.apache.deltaspike.core.util.Reflections;
+import org.apache.deltaspike.core.util.ReflectionUtils;
 
 import javax.enterprise.inject.spi.Annotated;
 import javax.enterprise.inject.spi.AnnotatedConstructor;
@@ -649,7 +649,7 @@ public class AnnotatedTypeBuilder<X>
             }
         }
 
-        for (Field field : Reflections.getAllDeclaredFields(type))
+        for (Field field : ReflectionUtils.getAllDeclaredFields(type))
         {
             AnnotationBuilder annotationBuilder = fields.get(field);
             if (annotationBuilder == null)
@@ -657,7 +657,7 @@ public class AnnotatedTypeBuilder<X>
                 annotationBuilder = new AnnotationBuilder();
                 fields.put(field, annotationBuilder);
             }
-            Reflections.setAccessible(field);
+            ReflectionUtils.setAccessible(field);
 
             for (Annotation annotation : field.getAnnotations())
             {
@@ -668,7 +668,7 @@ public class AnnotatedTypeBuilder<X>
             }
         }
 
-        for (Method method : Reflections.getAllDeclaredMethods(type))
+        for (Method method : ReflectionUtils.getAllDeclaredMethods(type))
         {
             AnnotationBuilder annotationBuilder = methods.get(method);
             if (annotationBuilder == null)
@@ -676,7 +676,7 @@ public class AnnotatedTypeBuilder<X>
                 annotationBuilder = new AnnotationBuilder();
                 methods.put(method, annotationBuilder);
             }
-            Reflections.setAccessible(method);
+            ReflectionUtils.setAccessible(method);
 
             for (Annotation annotation : method.getAnnotations())
             {

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotationBuilder.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotationBuilder.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotationBuilder.java
index ad7d43b..f30ce7e 100644
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotationBuilder.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/AnnotationBuilder.java
@@ -19,7 +19,7 @@
 
 package org.apache.deltaspike.core.api.metadata.builder;
 
-import org.apache.deltaspike.core.util.Reflections;
+import org.apache.deltaspike.core.util.ReflectionUtils;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
@@ -151,7 +151,7 @@ public class AnnotationBuilder
      */
     public <T extends Annotation> T getAnnotation(Class<T> anType)
     {
-        return Reflections.<T>cast(annotationMap.get(anType));
+        return ReflectionUtils.<T>cast(annotationMap.get(anType));
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/ImmutableInjectionPoint.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/ImmutableInjectionPoint.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/ImmutableInjectionPoint.java
index 5da00cf..ebd9281 100644
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/ImmutableInjectionPoint.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/ImmutableInjectionPoint.java
@@ -31,7 +31,7 @@ import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.InjectionPoint;
 
-import org.apache.deltaspike.core.util.Beans;
+import org.apache.deltaspike.core.util.BeanUtils;
 
 import static java.util.Collections.unmodifiableSet;
 
@@ -94,7 +94,7 @@ public class ImmutableInjectionPoint implements InjectionPoint
     {
         this.annotated = field;
         this.member = field.getJavaMember();
-        this.qualifiers = Beans.getQualifiers(beanManager, field.getAnnotations());
+        this.qualifiers = BeanUtils.getQualifiers(beanManager, field.getAnnotations());
         this.type = field.getJavaMember().getGenericType();
         this.isTransient = isTransient;
         this.delegate = delegate;
@@ -140,7 +140,7 @@ public class ImmutableInjectionPoint implements InjectionPoint
     {
         this.annotated = parameter;
         this.member = parameter.getDeclaringCallable().getJavaMember();
-        this.qualifiers = Beans.getQualifiers(beanManager, parameter.getAnnotations());
+        this.qualifiers = BeanUtils.getQualifiers(beanManager, parameter.getAnnotations());
         this.isTransient = isTransient;
         this.delegate = delegate;
         this.declaringBean = declaringBean;

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/InjectableMethod.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/InjectableMethod.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/InjectableMethod.java
index abc870c..e5be6a9 100644
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/InjectableMethod.java
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/api/metadata/builder/InjectableMethod.java
@@ -30,9 +30,9 @@ import javax.enterprise.inject.spi.InjectionPoint;
 
 import org.apache.deltaspike.core.api.metadata.builder.ParameterValueRedefiner.ParameterValue;
 
-import static org.apache.deltaspike.core.util.Beans.createInjectionPoints;
-import static org.apache.deltaspike.core.util.Reflections.EMPTY_OBJECT_ARRAY;
-import static org.apache.deltaspike.core.util.Reflections.invokeMethod;
+import static org.apache.deltaspike.core.util.BeanUtils.createInjectionPoints;
+import static org.apache.deltaspike.core.util.ReflectionUtils.EMPTY_OBJECT_ARRAY;
+import static org.apache.deltaspike.core.util.ReflectionUtils.invokeMethod;
 
 /**
  * <p>
@@ -195,7 +195,7 @@ public class InjectableMethod<X>
         {
             //X TODO check if it is compatible with Weld
             //workaround for OWB which wraps InvocationTargetException the original exception
-            //see Reflections#invokeMethod
+            //see ReflectionUtils#invokeMethod
             if (RuntimeException.class.getName().equals(e.getClass().getName()) &&
                     e.getCause() instanceof RuntimeException)
             {

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/BeanUtils.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/BeanUtils.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/BeanUtils.java
new file mode 100644
index 0000000..b2bc597
--- /dev/null
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/BeanUtils.java
@@ -0,0 +1,198 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.deltaspike.core.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.enterprise.context.Dependent;
+import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedParameter;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.inject.Inject;
+
+import org.apache.deltaspike.core.api.metadata.builder.ImmutableInjectionPoint;
+
+import static org.apache.deltaspike.core.util.ReflectionUtils.isSerializable;
+
+/**
+ * A set of utility methods for working with beans.
+ *
+ * @author Pete Muir
+ */
+public class BeanUtils
+{
+
+    private BeanUtils()
+    {
+    }
+
+    /**
+     * Extract the qualifiers from a set of annotations.
+     *
+     * @param beanManager the beanManager to use to determine if an annotation is
+     *                    a qualifier
+     * @param annotations the annotations to check
+     * @return any qualifiers present in <code>annotations</code>
+     */
+    public static Set<Annotation> getQualifiers(BeanManager beanManager, Iterable<Annotation>... annotations)
+    {
+        Set<Annotation> qualifiers = new HashSet<Annotation>();
+        for (Iterable<Annotation> annotationSet : annotations)
+        {
+            for (Annotation annotation : annotationSet)
+            {
+                if (beanManager.isQualifier(annotation.annotationType()))
+                {
+                    qualifiers.add(annotation);
+                }
+            }
+        }
+        return qualifiers;
+    }
+
+    /**
+     * Extract the qualifiers from a set of annotations.
+     *
+     * @param beanManager the beanManager to use to determine if an annotation is
+     *                    a qualifier
+     * @param annotations the annotations to check
+     * @return any qualifiers present in <code>annotations</code>
+     */
+    @SuppressWarnings("unchecked")
+    public static Set<Annotation> getQualifiers(BeanManager beanManager, Iterable<Annotation> annotations)
+    {
+        return getQualifiers(beanManager, new Iterable[]{annotations});
+    }
+
+    /**
+     * Extract the qualifiers from a set of annotations.
+     *
+     * @param beanManager the beanManager to use to determine if an annotation is
+     *                    a qualifier
+     * @param annotations the annotations to check
+     * @return any qualifiers present in <code>annotations</code>
+     */
+    public static Set<Annotation> getQualifiers(BeanManager beanManager, Annotation[]... annotations)
+    {
+        Set<Annotation> qualifiers = new HashSet<Annotation>();
+        for (Annotation[] annotationArray : annotations)
+        {
+            for (Annotation annotation : annotationArray)
+            {
+                if (beanManager.isQualifier(annotation.annotationType()))
+                {
+                    qualifiers.add(annotation);
+                }
+            }
+        }
+        return qualifiers;
+    }
+
+    public static void checkReturnValue(Object instance, Bean<?> bean, InjectionPoint injectionPoint,
+                                        BeanManager beanManager)
+    {
+        if (instance == null && !Dependent.class.equals(bean.getScope()))
+        {
+            throw new IllegalStateException("Cannot return null from a non-dependent producer method: " + bean);
+        }
+        else if (instance != null)
+        {
+            boolean passivating = beanManager.isPassivatingScope(bean.getScope());
+            boolean instanceSerializable = isSerializable(instance.getClass());
+            if (passivating && !instanceSerializable)
+            {
+                throw new IllegalStateException(
+                        "Producers cannot declare passivating scope and return a non-serializable class: " + bean);
+            }
+            if (injectionPoint != null && injectionPoint.getBean() != null)
+            {
+                if (!instanceSerializable && beanManager.isPassivatingScope(injectionPoint.getBean().getScope()))
+                {
+                    if (injectionPoint.getMember() instanceof Field)
+                    {
+                        if (!injectionPoint.isTransient() && instance != null && !instanceSerializable)
+                        {
+                            throw new IllegalStateException(
+                                    "Producers cannot produce non-serializable instances for injection into " +
+                                            "non-transient fields of passivating beans. Producer " +
+                                            bean + "at injection point " + injectionPoint);
+                        }
+                    }
+                    else if (injectionPoint.getMember() instanceof Method)
+                    {
+                        Method method = (Method) injectionPoint.getMember();
+                        if (method.isAnnotationPresent(Inject.class))
+                        {
+                            throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
+                                    "injection into parameters of initializers of beans declaring passivating scope. " +
+                                    "Producer " + bean + "at injection point " + injectionPoint);
+                        }
+                        if (method.isAnnotationPresent(Produces.class))
+                        {
+                            throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
+                                    "injection into parameters of producer methods declaring passivating scope. " +
+                                    "Producer " + bean + "at injection point " + injectionPoint);
+                        }
+                    }
+                    else if (injectionPoint.getMember() instanceof Constructor<?>)
+                    {
+                        throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
+                                "injection into parameters of constructors of beans declaring passivating scope. " +
+                                "Producer " + bean + "at injection point " + injectionPoint);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Given a method, and the bean on which the method is declared, create a
+     * collection of injection points representing the parameters of the method.
+     *
+     * @param <X>           the type declaring the method
+     * @param method        the method
+     * @param declaringBean the bean on which the method is declared
+     * @param beanManager   the bean manager to use to create the injection points
+     * @return the injection points
+     */
+    public static <X> List<InjectionPoint> createInjectionPoints(AnnotatedMethod<X> method, Bean<?> declaringBean,
+                                                                 BeanManager beanManager)
+    {
+        List<InjectionPoint> injectionPoints = new ArrayList<InjectionPoint>();
+        for (AnnotatedParameter<X> parameter : method.getParameters())
+        {
+            InjectionPoint injectionPoint =
+                    new ImmutableInjectionPoint(parameter, beanManager, declaringBean, false, false);
+
+            injectionPoints.add(injectionPoint);
+        }
+        return injectionPoints;
+    }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/Beans.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/Beans.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/Beans.java
deleted file mode 100644
index b140fb3..0000000
--- a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/Beans.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.deltaspike.core.util;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import javax.enterprise.context.Dependent;
-import javax.enterprise.inject.Produces;
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.AnnotatedParameter;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.InjectionPoint;
-import javax.inject.Inject;
-
-import org.apache.deltaspike.core.api.metadata.builder.ImmutableInjectionPoint;
-
-import static org.apache.deltaspike.core.util.Reflections.isSerializable;
-
-/**
- * A set of utility methods for working with beans.
- *
- * @author Pete Muir
- */
-public class Beans
-{
-
-    private Beans()
-    {
-    }
-
-    /**
-     * Extract the qualifiers from a set of annotations.
-     *
-     * @param beanManager the beanManager to use to determine if an annotation is
-     *                    a qualifier
-     * @param annotations the annotations to check
-     * @return any qualifiers present in <code>annotations</code>
-     */
-    public static Set<Annotation> getQualifiers(BeanManager beanManager, Iterable<Annotation>... annotations)
-    {
-        Set<Annotation> qualifiers = new HashSet<Annotation>();
-        for (Iterable<Annotation> annotationSet : annotations)
-        {
-            for (Annotation annotation : annotationSet)
-            {
-                if (beanManager.isQualifier(annotation.annotationType()))
-                {
-                    qualifiers.add(annotation);
-                }
-            }
-        }
-        return qualifiers;
-    }
-
-    /**
-     * Extract the qualifiers from a set of annotations.
-     *
-     * @param beanManager the beanManager to use to determine if an annotation is
-     *                    a qualifier
-     * @param annotations the annotations to check
-     * @return any qualifiers present in <code>annotations</code>
-     */
-    @SuppressWarnings("unchecked")
-    public static Set<Annotation> getQualifiers(BeanManager beanManager, Iterable<Annotation> annotations)
-    {
-        return getQualifiers(beanManager, new Iterable[]{annotations});
-    }
-
-    /**
-     * Extract the qualifiers from a set of annotations.
-     *
-     * @param beanManager the beanManager to use to determine if an annotation is
-     *                    a qualifier
-     * @param annotations the annotations to check
-     * @return any qualifiers present in <code>annotations</code>
-     */
-    public static Set<Annotation> getQualifiers(BeanManager beanManager, Annotation[]... annotations)
-    {
-        Set<Annotation> qualifiers = new HashSet<Annotation>();
-        for (Annotation[] annotationArray : annotations)
-        {
-            for (Annotation annotation : annotationArray)
-            {
-                if (beanManager.isQualifier(annotation.annotationType()))
-                {
-                    qualifiers.add(annotation);
-                }
-            }
-        }
-        return qualifiers;
-    }
-
-    public static void checkReturnValue(Object instance, Bean<?> bean, InjectionPoint injectionPoint,
-                                        BeanManager beanManager)
-    {
-        if (instance == null && !Dependent.class.equals(bean.getScope()))
-        {
-            throw new IllegalStateException("Cannot return null from a non-dependent producer method: " + bean);
-        }
-        else if (instance != null)
-        {
-            boolean passivating = beanManager.isPassivatingScope(bean.getScope());
-            boolean instanceSerializable = isSerializable(instance.getClass());
-            if (passivating && !instanceSerializable)
-            {
-                throw new IllegalStateException(
-                        "Producers cannot declare passivating scope and return a non-serializable class: " + bean);
-            }
-            if (injectionPoint != null && injectionPoint.getBean() != null)
-            {
-                if (!instanceSerializable && beanManager.isPassivatingScope(injectionPoint.getBean().getScope()))
-                {
-                    if (injectionPoint.getMember() instanceof Field)
-                    {
-                        if (!injectionPoint.isTransient() && instance != null && !instanceSerializable)
-                        {
-                            throw new IllegalStateException(
-                                    "Producers cannot produce non-serializable instances for injection into " +
-                                            "non-transient fields of passivating beans. Producer " +
-                                            bean + "at injection point " + injectionPoint);
-                        }
-                    }
-                    else if (injectionPoint.getMember() instanceof Method)
-                    {
-                        Method method = (Method) injectionPoint.getMember();
-                        if (method.isAnnotationPresent(Inject.class))
-                        {
-                            throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
-                                    "injection into parameters of initializers of beans declaring passivating scope. " +
-                                    "Producer " + bean + "at injection point " + injectionPoint);
-                        }
-                        if (method.isAnnotationPresent(Produces.class))
-                        {
-                            throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
-                                    "injection into parameters of producer methods declaring passivating scope. " +
-                                    "Producer " + bean + "at injection point " + injectionPoint);
-                        }
-                    }
-                    else if (injectionPoint.getMember() instanceof Constructor<?>)
-                    {
-                        throw new IllegalStateException("Producers cannot produce non-serializable instances for " +
-                                "injection into parameters of constructors of beans declaring passivating scope. " +
-                                "Producer " + bean + "at injection point " + injectionPoint);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Given a method, and the bean on which the method is declared, create a
-     * collection of injection points representing the parameters of the method.
-     *
-     * @param <X>           the type declaring the method
-     * @param method        the method
-     * @param declaringBean the bean on which the method is declared
-     * @param beanManager   the bean manager to use to create the injection points
-     * @return the injection points
-     */
-    public static <X> List<InjectionPoint> createInjectionPoints(AnnotatedMethod<X> method, Bean<?> declaringBean,
-                                                                 BeanManager beanManager)
-    {
-        List<InjectionPoint> injectionPoints = new ArrayList<InjectionPoint>();
-        for (AnnotatedParameter<X> parameter : method.getParameters())
-        {
-            InjectionPoint injectionPoint =
-                    new ImmutableInjectionPoint(parameter, beanManager, declaringBean, false, false);
-
-            injectionPoints.add(injectionPoint);
-        }
-        return injectionPoints;
-    }
-
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-deltaspike/blob/ccb8cb01/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/ReflectionUtils.java
----------------------------------------------------------------------
diff --git a/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/ReflectionUtils.java b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/ReflectionUtils.java
new file mode 100644
index 0000000..24c0a83
--- /dev/null
+++ b/deltaspike/core/api/src/main/java/org/apache/deltaspike/core/util/ReflectionUtils.java
@@ -0,0 +1,1419 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.deltaspike.core.util;
+
+import javax.enterprise.inject.Typed;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.inject.Qualifier;
+import java.beans.Introspector;
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.security.AccessController;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+//import java.util.Arrays;
+
+/**
+ * Utilities for common reflection based actions. Some are basic Java Reflection based, others are CDI based.
+ */
+//X TODO: Look at merging this with some of the other classes from CODI, or if they're really needed
+//X TODO: Also some methods need JavaDoc
+@Typed()
+public abstract class ReflectionUtils
+{
+    /**
+     * An empty array of type {@link Annotation}, useful converting lists to
+     * arrays.
+     */
+    public static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
+
+    /**
+     * An empty array of type {@link Object}, useful for converting lists to
+     * arrays.
+     */
+    public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+
+    public static final Type[] EMPTY_TYPES = {};
+
+    public static final Class<?>[] EMPTY_CLASSES = new Class<?>[0];
+
+    private ReflectionUtils()
+    {
+        // prevent instantiation
+    }
+
+    /**
+     * <p>
+     * Perform a runtime cast. Similar to {@link Class#cast(Object)}, but useful
+     * when you do not have a {@link Class} object for type you wish to cast to.
+     * </p>
+     * <p/>
+     * <p>
+     * {@link Class#cast(Object)} should be used if possible
+     * </p>
+     *
+     * @param <T> the type to cast to
+     * @param obj the object to perform the cast on
+     * @return the casted object
+     * @throws ClassCastException if the type T is not a subtype of the object
+     * @see Class#cast(Object)
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T cast(Object obj)
+    {
+        return (T) obj;
+    }
+
+    /**
+     * Get all the declared fields on the class hierarchy. This <b>will</b>
+     * return overridden fields.
+     *
+     * @param clazz The class to search
+     * @return the set of all declared fields or an empty set if there are none
+     */
+    public static Set<Field> getAllDeclaredFields(Class<?> clazz)
+    {
+        HashSet<Field> fields = new HashSet<Field>();
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            for (Field a : c.getDeclaredFields())
+            {
+                fields.add(a);
+            }
+        }
+        return fields;
+    }
+
+    /**
+     * Search the class hierarchy for a field with the given name. Will return
+     * the nearest match, starting with the class specified and searching up the
+     * hierarchy.
+     *
+     * @param clazz The class to search
+     * @param name  The name of the field to search for
+     * @return The field found, or null if no field is found
+     */
+    public static Field findDeclaredField(Class<?> clazz, String name)
+    {
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            try
+            {
+                return c.getDeclaredField(name);
+            }
+            catch (NoSuchFieldException e)
+            {
+                // No-op, we continue looking up the class hierarchy
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Search the annotatedType for the field, returning the
+     * {@link AnnotatedField}
+     *
+     * @param annotatedType The annotatedType to search
+     * @param field         the field to search for
+     * @return The {@link AnnotatedField} found, or null if no field is found
+     */
+    public static <X> AnnotatedField<? super X> getField(AnnotatedType<X> annotatedType, Field field)
+    {
+        for (AnnotatedField<? super X> annotatedField : annotatedType.getFields())
+        {
+            if (annotatedField.getDeclaringType().getJavaClass().equals(field.getDeclaringClass()) &&
+                    annotatedField.getJavaMember().getName().equals(field.getName()))
+            {
+                return annotatedField;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Search for annotations with the specified meta annotation type
+     *
+     * @param annotations        The annotation set to search
+     * @param metaAnnotationType The type of the meta annotation to search for
+     * @return The set of annotations with the specified meta annotation, or an
+     *         empty set if none are found
+     */
+    public static Set<Annotation> getAnnotationsWithMetaAnnotation(Set<Annotation> annotations,
+                                                                   Class<? extends Annotation> metaAnnotationType)
+    {
+        Set<Annotation> set = new HashSet<Annotation>();
+        for (Annotation annotation : annotations)
+        {
+            if (annotation.annotationType().isAnnotationPresent(metaAnnotationType))
+            {
+                set.add(annotation);
+            }
+        }
+        return set;
+    }
+
+    /**
+     * Extract any qualifiers from the set of annotations
+     *
+     * @param annotations The set of annotations to search
+     * @param beanManager The beanManager to use to establish if an annotation is
+     *                    a qualifier
+     * @return The qualifiers present in the set, or an empty set if there are
+     *         none
+     */
+    public static Set<Annotation> getQualifiers(Set<Annotation> annotations, BeanManager beanManager)
+    {
+        Set<Annotation> set = new HashSet<Annotation>();
+        for (Annotation annotation : annotations)
+        {
+            if (beanManager.isQualifier(annotation.annotationType()))
+            {
+                set.add(annotation);
+            }
+        }
+        return set;
+    }
+
+    /**
+     * Determine if a method exists in a specified class hierarchy
+     *
+     * @param clazz The class to search
+     * @param name  The name of the method
+     * @return true if a method is found, otherwise false
+     */
+    public static boolean methodExists(Class<?> clazz, String name)
+    {
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            for (Method m : c.getDeclaredMethods())
+            {
+                if (m.getName().equals(name))
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Get all the declared methods on the class hierarchy. This <b>will</b>
+     * return overridden methods.
+     *
+     * @param clazz The class to search
+     * @return the set of all declared methods or an empty set if there are none
+     */
+    public static Set<Method> getAllDeclaredMethods(Class<?> clazz)
+    {
+        HashSet<Method> methods = new HashSet<Method>();
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            for (Method a : c.getDeclaredMethods())
+            {
+                methods.add(a);
+            }
+        }
+        return methods;
+    }
+
+    /**
+     * Search the class hierarchy for a method with the given name and arguments.
+     * Will return the nearest match, starting with the class specified and
+     * searching up the hierarchy.
+     *
+     * @param clazz The class to search
+     * @param name  The name of the method to search for
+     * @param args  The arguments of the method to search for
+     * @return The method found, or null if no method is found
+     */
+    public static Method findDeclaredMethod(Class<?> clazz, String name, Class<?>... args)
+    {
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            try
+            {
+                return c.getDeclaredMethod(name, args);
+            }
+            catch (NoSuchMethodException e)
+            {
+                // No-op, continue the search
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Search the class hierarchy for a constructor with the given arguments.
+     * Will return the nearest match, starting with the class specified and
+     * searching up the hierarchy.
+     *
+     * @param clazz The class to search
+     * @param args  The arguments of the constructor to search for
+     * @return The constructor found, or null if no constructor is found
+     */
+    public static Constructor<?> findDeclaredConstructor(Class<?> clazz, Class<?>... args)
+    {
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            try
+            {
+                return c.getDeclaredConstructor(args);
+            }
+            catch (NoSuchMethodException e)
+            {
+                // No-op, continue the search
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Get all the declared constructors on the class hierarchy. This <b>will</b>
+     * return overridden constructors.
+     *
+     * @param clazz The class to search
+     * @return the set of all declared constructors or an empty set if there are
+     *         none
+     */
+    public static Set<Constructor<?>> getAllDeclaredConstructors(Class<?> clazz)
+    {
+        HashSet<Constructor<?>> constructors = new HashSet<Constructor<?>>();
+        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass())
+        {
+            for (Constructor<?> constructor : c.getDeclaredConstructors())
+            {
+                constructors.add(constructor);
+            }
+        }
+        return constructors;
+    }
+
+    /**
+     * Get the type of the member
+     *
+     * @param member The member
+     * @return The type of the member
+     * @throws UnsupportedOperationException if the member is not a field,
+     *                                       method, or constructor
+     */
+    public static Class<?> getMemberType(Member member)
+    {
+        if (member instanceof Field)
+        {
+            return ((Field) member).getType();
+        }
+        else if (member instanceof Method)
+        {
+            return ((Method) member).getReturnType();
+        }
+        else if (member instanceof Constructor<?>)
+        {
+            return ((Constructor<?>) member).getDeclaringClass();
+        }
+        else
+        {
+            throw new UnsupportedOperationException("Cannot operate on a member of type " + member.getClass());
+        }
+    }
+
+    /**
+     * <p>
+     * Loads and initializes a class for the given name.
+     * </p>
+     * <p/>
+     * <p>
+     * If the Thread Context Class Loader is available, it will be used,
+     * otherwise the classloader used to load {@link ReflectionUtils} will be used
+     * </p>
+     * <p/>
+     * <p>
+     * It is also possible to specify additional classloaders to attempt to load
+     * the class with. If the first attempt fails, then these additional loaders
+     * are tried in order.
+     * </p>
+     *
+     * @param name    the name of the class to load
+     * @param loaders additional classloaders to use to attempt to load the class
+     * @return the class object
+     * @throws ClassNotFoundException if the class cannot be found
+     * @deprecated move/merge with ClassUtils
+     */
+    public static Class<?> classForName(String name, ClassLoader... loaders) throws ClassNotFoundException
+    {
+        try
+        {
+            if (Thread.currentThread().getContextClassLoader() != null)
+            {
+                return Class.forName(name, true, Thread.currentThread().getContextClassLoader());
+            }
+            else
+            {
+                return Class.forName(name);
+            }
+        }
+        catch (ClassNotFoundException e)
+        {
+            for (ClassLoader l : loaders)
+            {
+                try
+                {
+                    return Class.forName(name, true, l);
+                }
+                catch (ClassNotFoundException ex)
+                {
+
+                }
+            }
+        }
+        if (Thread.currentThread().getContextClassLoader() != null)
+        {
+            throw new ClassNotFoundException(String.format(
+                "Could not load class %s with the context class loader %s or any of the additional ClassLoaders: %s",
+                name, Thread.currentThread().getContextClassLoader(), loaders));
+        }
+        else
+        {
+            throw new ClassNotFoundException("Could not load class " + name +
+                    " using Class.forName or using any of the additional ClassLoaders: " + Arrays.toString(loaders));
+        }
+    }
+
+    private static String buildInvokeMethodErrorMessage(Method method, Object obj, Object... args)
+    {
+        StringBuilder message = new StringBuilder(String.format(
+                "Exception invoking method [%s] on object [%s], using arguments [", method.getName(), obj));
+        if (args != null)
+        {
+            for (int i = 0; i < args.length; i++)
+            {
+                message.append(i > 0 ? "," : "")
+                       .append(args[i]);
+            }
+        }
+        message.append("]");
+        return message.toString();
+    }
+
+    /**
+     * Set the accessibility flag on the {@link AccessibleObject} as described in
+     * {@link AccessibleObject#setAccessible(boolean)} within the context of
+     * a {@link java.security.PrivilegedAction}.
+     *
+     * @param <A>    member the accessible object type
+     * @param member the accessible object
+     * @return the accessible object after the accessible flag has been altered
+     */
+    public static <A extends AccessibleObject> A setAccessible(A member)
+    {
+        AccessController.doPrivileged(new SetAccessiblePrivilegedAction(member));
+        return member;
+    }
+
+    /**
+     * <p>
+     * Invoke the specified method on the provided instance, passing any additional
+     * arguments included in this method as arguments to the specified method.
+     * </p>
+     * <p/>
+     * <p>This method provides the same functionality and throws the same exceptions as
+     * {@link ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)}, with the
+     * expected return type set to {@link Object} and no change to the method's accessibility.</p>
+     *
+     * @see ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)
+     * @see Method#invoke(Object, Object...)
+     */
+    public static Object invokeMethod(Method method, Object instance, Object... args)
+    {
+        return invokeMethod(false, method, Object.class, instance, args);
+    }
+
+    /**
+     * <p>
+     * Invoke the specified method on the provided instance, passing any additional
+     * arguments included in this method as arguments to the specified method.
+     * </p>
+     * <p/>
+     * <p>
+     * This method attempts to set the accessible flag of the method in a
+     * {@link java.security.PrivilegedAction} before invoking the method if the first argument
+     * is true.
+     * </p>
+     * <p/>
+     * <p>This method provides the same functionality and throws the same exceptions as
+     * {@link ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)}, with the
+     * expected return type set to {@link Object}.</p>
+     *
+     * @see ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)
+     * @see Method#invoke(Object, Object...)
+     */
+    public static Object invokeMethod(boolean setAccessible, Method method, Object instance, Object... args)
+    {
+        return invokeMethod(setAccessible, method, Object.class, instance, args);
+    }
+
+    /**
+     * <p>
+     * Invoke the specified method on the provided instance, passing any additional
+     * arguments included in this method as arguments to the specified method.
+     * </p>
+     * <p/>
+     * <p>This method provides the same functionality and throws the same exceptions as
+     * {@link ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)}, with the
+     * expected return type set to {@link Object} and honoring the accessibility of
+     * the method.</p>
+     *
+     * @see ReflectionUtils#invokeMethod(boolean, Method, Class, Object, Object...)
+     * @see Method#invoke(Object, Object...)
+     */
+    public static <T> T invokeMethod(Method method, Class<T> expectedReturnType, Object instance, Object... args)
+    {
+        return invokeMethod(false, method, expectedReturnType, instance, args);
+    }
+
+    /**
+     * <p>
+     * Invoke the method on the instance, with any arguments specified, casting
+     * the result of invoking the method to the expected return type.
+     * </p>
+     * <p/>
+     * <p>
+     * This method wraps {@link Method#invoke(Object, Object...)}, converting the
+     * checked exceptions that {@link Method#invoke(Object, Object...)} specifies
+     * to runtime exceptions.
+     * </p>
+     * <p/>
+     * <p>
+     * If instructed, this method attempts to set the accessible flag of the method in a
+     * {@link java.security.PrivilegedAction} before invoking the method.
+     * </p>
+     *
+     * @param setAccessible flag indicating whether method should first be set as
+     *                      accessible
+     * @param method        the method to invoke
+     * @param instance      the instance to invoke the method
+     * @param args          the arguments to the method
+     * @return the result of invoking the method, or null if the method's return
+     *         type is void
+     * @throws RuntimeException            if this <code>Method</code> object enforces Java
+     *                                     language access control and the underlying method is
+     *                                     inaccessible or if the underlying method throws an exception or
+     *                                     if the initialization provoked by this method fails.
+     * @throws IllegalArgumentException    if the method is an instance method and
+     *                                     the specified <code>instance</code> argument is not an instance
+     *                                     of the class or interface declaring the underlying method (or
+     *                                     of a subclass or implementor thereof); if the number of actual
+     *                                     and formal parameters differ; if an unwrapping conversion for
+     *                                     primitive arguments fails; or if, after possible unwrapping, a
+     *                                     parameter value cannot be converted to the corresponding formal
+     *                                     parameter type by a method invocation conversion.
+     * @throws NullPointerException        if the specified <code>instance</code> is
+     *                                     null and the method is an instance method.
+     * @throws ClassCastException          if the result of invoking the method cannot be
+     *                                     cast to the expectedReturnType
+     * @throws ExceptionInInitializerError if the initialization provoked by this
+     *                                     method fails.
+     * @see Method#invoke(Object, Object...)
+     */
+    public static <T> T invokeMethod(boolean setAccessible,
+                                     Method method, Class<T> expectedReturnType,
+                                     Object instance, Object... args)
+    {
+        if (setAccessible && !method.isAccessible())
+        {
+            setAccessible(method);
+        }
+
+        try
+        {
+            return expectedReturnType.cast(method.invoke(instance, args));
+        }
+        catch (IllegalAccessException ex)
+        {
+            throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex);
+        }
+        catch (IllegalArgumentException ex)
+        {
+            throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, instance, args), ex);
+        }
+        catch (InvocationTargetException ex)
+        {
+            throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex.getCause());
+        }
+        catch (NullPointerException ex)
+        {
+            NullPointerException ex2 = new NullPointerException(buildInvokeMethodErrorMessage(method, instance, args));
+            ex2.initCause(ex.getCause());
+            throw ex2;
+        }
+        catch (ExceptionInInitializerError e)
+        {
+            ExceptionInInitializerError e2 =
+                    new ExceptionInInitializerError(buildInvokeMethodErrorMessage(method, instance, args));
+            e2.initCause(e.getCause());
+            throw e2;
+        }
+    }
+
+    /**
+     * <p>
+     * Set the value of a field on the instance to the specified value.
+     * </p>
+     * <p/>
+     * <p>This method provides the same functionality and throws the same exceptions as
+     * {@link ReflectionUtils#setFieldValue(boolean, Field, Object, Object)}, honoring
+     * the accessibility of the field.</p>
+     */
+    public static void setFieldValue(Field field, Object instance, Object value)
+    {
+        setFieldValue(false, field, instance, value);
+    }
+
+    /**
+     * <p>
+     * Sets the value of a field on the instance to the specified value.
+     * </p>
+     * <p/>
+     * <p>
+     * This method wraps {@link Field#set(Object, Object)}, converting the
+     * checked exceptions that {@link Field#set(Object, Object)} specifies to
+     * runtime exceptions.
+     * </p>
+     * <p/>
+     * <p>
+     * If instructed, this method attempts to set the accessible flag of the method in a
+     * {@link java.security.PrivilegedAction} before invoking the method.
+     * </p>
+     *
+     * @param field    the field on which to operate, or null if the field is static
+     * @param instance the instance on which the field value should be set upon
+     * @param value    the value to set the field to
+     * @throws RuntimeException            if the underlying field is inaccessible.
+     * @throws IllegalArgumentException    if the specified <code>instance</code> is not an
+     *                                     instance of the class or interface declaring the underlying
+     *                                     field (or a subclass or implementor thereof), or if an
+     *                                     unwrapping conversion fails.
+     * @throws NullPointerException        if the specified <code>instance</code> is null and the field
+     *                                     is an instance field.
+     * @throws ExceptionInInitializerError if the initialization provoked by this
+     *                                     method fails.
+     * @see Field#set(Object, Object)
+     */
+    public static void setFieldValue(boolean setAccessible, Field field, Object instance, Object value)
+    {
+        if (setAccessible && !field.isAccessible())
+        {
+            setAccessible(field);
+        }
+
+        try
+        {
+            field.set(instance, value);
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new RuntimeException(buildSetFieldValueErrorMessage(field, instance, value), e);
+        }
+        catch (NullPointerException ex)
+        {
+            NullPointerException ex2 = new NullPointerException(buildSetFieldValueErrorMessage(field, instance, value));
+            ex2.initCause(ex.getCause());
+            throw ex2;
+        }
+        catch (ExceptionInInitializerError e)
+        {
+            ExceptionInInitializerError e2 =
+                    new ExceptionInInitializerError(buildSetFieldValueErrorMessage(field, instance, value));
+            e2.initCause(e.getCause());
+            throw e2;
+        }
+    }
+
+    private static String buildSetFieldValueErrorMessage(Field field, Object obj, Object value)
+    {
+        return String.format("Exception setting [%s] field on object [%s] to value [%s]", field.getName(), obj, value);
+    }
+
+    private static String buildGetFieldValueErrorMessage(Field field, Object obj)
+    {
+        return String.format("Exception reading [%s] field from object [%s].", field.getName(), obj);
+    }
+
+    public static Object getFieldValue(Field field, Object instance)
+    {
+        return getFieldValue(field, instance, Object.class);
+    }
+
+    /**
+     * <p>
+     * Get the value of the field, on the specified instance, casting the value
+     * of the field to the expected type.
+     * </p>
+     * <p/>
+     * <p>
+     * This method wraps {@link Field#get(Object)}, converting the checked
+     * exceptions that {@link Field#get(Object)} specifies to runtime exceptions.
+     * </p>
+     *
+     * @param <T>          the type of the field's value
+     * @param field        the field to operate on
+     * @param instance     the instance from which to retrieve the value
+     * @param expectedType the expected type of the field's value
+     * @return the value of the field
+     * @throws RuntimeException            if the underlying field is inaccessible.
+     * @throws IllegalArgumentException    if the specified <code>instance</code> is not an
+     *                                     instance of the class or interface declaring the underlying
+     *                                     field (or a subclass or implementor thereof).
+     * @throws NullPointerException        if the specified <code>instance</code> is null and the field
+     *                                     is an instance field.
+     * @throws ExceptionInInitializerError if the initialization provoked by this
+     *                                     method fails.
+     */
+    public static <T> T getFieldValue(Field field, Object instance, Class<T> expectedType)
+    {
+        try
+        {
+            //<T> needed to bypass an issue with old jdk versions
+            return ReflectionUtils.<T>cast(field.get(instance));
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new RuntimeException(buildGetFieldValueErrorMessage(field, instance), e);
+        }
+        catch (NullPointerException ex)
+        {
+            NullPointerException ex2 = new NullPointerException(buildGetFieldValueErrorMessage(field, instance));
+            ex2.initCause(ex.getCause());
+            throw ex2;
+        }
+        catch (ExceptionInInitializerError e)
+        {
+            ExceptionInInitializerError e2 =
+                    new ExceptionInInitializerError(buildGetFieldValueErrorMessage(field, instance));
+            e2.initCause(e.getCause());
+            throw e2;
+        }
+    }
+
+    /**
+     * Extract the raw type, given a type.
+     *
+     * @param <T>  the type
+     * @param type the type to extract the raw type from
+     * @return the raw type, or null if the raw type cannot be determined.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> Class<T> getRawType(Type type)
+    {
+        if (type instanceof Class<?>)
+        {
+            return (Class<T>) type;
+        }
+        else if (type instanceof ParameterizedType && ((ParameterizedType) type).getRawType() instanceof Class<?>)
+        {
+            return (Class<T>) ((ParameterizedType) type).getRawType();
+        }
+        return null;
+    }
+
+    /**
+     * Check if a class is serializable.
+     *
+     * @param clazz The class to check
+     * @return true if the class implements serializable or is a primitive
+     */
+    public static boolean isSerializable(Class<?> clazz)
+    {
+        return clazz.isPrimitive() || Serializable.class.isAssignableFrom(clazz);
+    }
+
+
+    public static Map<Class<?>, Type> buildTypeMap(Set<Type> types)
+    {
+        Map<Class<?>, Type> map = new HashMap<Class<?>, Type>();
+        for (Type type : types)
+        {
+            if (type instanceof Class<?>)
+            {
+                map.put((Class<?>) type, type);
+            }
+            else if (type instanceof ParameterizedType)
+            {
+                if (((ParameterizedType) type).getRawType() instanceof Class<?>)
+                {
+                    map.put((Class<?>) ((ParameterizedType) type).getRawType(), type);
+                }
+            }
+        }
+        return map;
+    }
+
+    public static boolean isCacheable(Set<Annotation> annotations)
+    {
+        for (Annotation qualifier : annotations)
+        {
+            Class<?> clazz = qualifier.getClass();
+            if (clazz.isAnonymousClass() || (clazz.isMemberClass() && isStatic(clazz)))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean isCacheable(Annotation[] annotations)
+    {
+        for (Annotation qualifier : annotations)
+        {
+            Class<?> clazz = qualifier.getClass();
+            if (clazz.isAnonymousClass() || (clazz.isMemberClass() && isStatic(clazz)))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Gets the property name from a getter method.
+     * <p/>
+     * We extend JavaBean conventions, allowing the getter method to have parameters
+     *
+     * @param method The getter method
+     * @return The name of the property. Returns null if method wasn't JavaBean
+     *         getter-styled
+     */
+    public static String getPropertyName(Method method)
+    {
+        String methodName = method.getName();
+        if (methodName.matches("^(get).*"))
+        {
+            return Introspector.decapitalize(methodName.substring(3));
+        }
+        else if (methodName.matches("^(is).*"))
+        {
+            return Introspector.decapitalize(methodName.substring(2));
+        }
+        else
+        {
+            return null;
+        }
+
+    }
+
+    /**
+     * Checks if class is final
+     *
+     * @param clazz The class to check
+     * @return True if final, false otherwise
+     */
+    public static boolean isFinal(Class<?> clazz)
+    {
+        return Modifier.isFinal(clazz.getModifiers());
+    }
+
+    public static int getNesting(Class<?> clazz)
+    {
+        if (clazz.isMemberClass() && !isStatic(clazz))
+        {
+            return 1 + getNesting(clazz.getDeclaringClass());
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    /**
+     * Checks if member is final
+     *
+     * @param member The member to check
+     * @return True if final, false otherwise
+     */
+    public static boolean isFinal(Member member)
+    {
+        return Modifier.isFinal(member.getModifiers());
+    }
+
+    /**
+     * Checks if member is private
+     *
+     * @param member The member to check
+     * @return True if final, false otherwise
+     */
+    public static boolean isPrivate(Member member)
+    {
+        return Modifier.isPrivate(member.getModifiers());
+    }
+
+    /**
+     * Checks if type or member is final
+     *
+     * @param type Type or member
+     * @return True if final, false otherwise
+     */
+    public static boolean isTypeOrAnyMethodFinal(Class<?> type)
+    {
+        return getNonPrivateFinalMethodOrType(type) != null;
+    }
+
+    public static Object getNonPrivateFinalMethodOrType(Class<?> type)
+    {
+        if (isFinal(type))
+        {
+            return type;
+        }
+        for (Method method : type.getDeclaredMethods())
+        {
+            if (isFinal(method) && !isPrivate(method))
+            {
+                return method;
+            }
+        }
+        return null;
+    }
+
+    public static boolean isPackagePrivate(int mod)
+    {
+        return !(Modifier.isPrivate(mod) || Modifier.isProtected(mod) || Modifier.isPublic(mod));
+    }
+
+    /**
+     * Checks if type is static
+     *
+     * @param type Type to check
+     * @return True if static, false otherwise
+     */
+    public static boolean isStatic(Class<?> type)
+    {
+        return Modifier.isStatic(type.getModifiers());
+    }
+
+    /**
+     * Checks if member is static
+     *
+     * @param member Member to check
+     * @return True if static, false otherwise
+     */
+    public static boolean isStatic(Member member)
+    {
+        return Modifier.isStatic(member.getModifiers());
+    }
+
+    public static boolean isTransient(Member member)
+    {
+        return Modifier.isTransient(member.getModifiers());
+    }
+
+    /**
+     * Checks if a method is abstract
+     *
+     * @param method
+     * @return
+     */
+    public static boolean isAbstract(Method method)
+    {
+        return Modifier.isAbstract(method.getModifiers());
+    }
+
+    /**
+     * Gets the actual type arguments of a class
+     *
+     * @param clazz The class to examine
+     * @return The type arguments
+     */
+    public static Type[] getActualTypeArguments(Class<?> clazz)
+    {
+        Type type = new HierarchyDiscovery(clazz).getResolvedType();
+        if (type instanceof ParameterizedType)
+        {
+            return ((ParameterizedType) type).getActualTypeArguments();
+        }
+        else
+        {
+            return EMPTY_TYPES;
+        }
+    }
+
+    /**
+     * Gets the actual type arguments of a Type
+     *
+     * @param type The type to examine
+     * @return The type arguments
+     */
+    public static Type[] getActualTypeArguments(Type type)
+    {
+        Type resolvedType = new HierarchyDiscovery(type).getResolvedType();
+        if (resolvedType instanceof ParameterizedType)
+        {
+            return ((ParameterizedType) resolvedType).getActualTypeArguments();
+        }
+        else
+        {
+            return EMPTY_TYPES;
+        }
+    }
+
+    /**
+     * Checks if raw type is array type
+     *
+     * @param rawType The raw type to check
+     * @return True if array, false otherwise
+     */
+    public static boolean isArrayType(Class<?> rawType)
+    {
+        return rawType.isArray();
+    }
+
+    /**
+     * Checks if type is parameterized type
+     *
+     * @param type The type to check
+     * @return True if parameterized, false otherwise
+     */
+    public static boolean isParameterizedType(Class<?> type)
+    {
+        return type.getTypeParameters().length > 0;
+    }
+
+    public static boolean isParamerterizedTypeWithWildcard(Class<?> type)
+    {
+        if (isParameterizedType(type))
+        {
+            return containsWildcards(type.getTypeParameters());
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public static boolean containsWildcards(Type[] types)
+    {
+        for (Type type : types)
+        {
+            if (type instanceof WildcardType)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Checks the bindingType to make sure the annotation was declared properly
+     * as a binding type (annotated with @BindingType) and that it has a runtime
+     * retention policy.
+     *
+     * @param binding The binding type to check
+     * @return true only if the annotation is really a binding type
+     */
+    @Deprecated
+    // TODO Replace usage of this with metadatacache
+    public static boolean isBindings(Annotation binding)
+    {
+        boolean isBindingAnnotation = false;
+        if (binding.annotationType().isAnnotationPresent(Qualifier.class)
+                && binding.annotationType().isAnnotationPresent(Retention.class)
+                && binding.annotationType().getAnnotation(Retention.class).value().equals(RetentionPolicy.RUNTIME))
+        {
+            isBindingAnnotation = true;
+        }
+        return isBindingAnnotation;
+    }
+
+    /**
+     * Check the assignability of one type to another, taking into account the
+     * actual type arguements
+     *
+     * @param rawType1             the raw type of the class to check
+     * @param actualTypeArguments1 the actual type arguements to check, or an
+     *                             empty array if not a parameterized type
+     * @param rawType2             the raw type of the class to check
+     * @param actualTypeArguments2 the actual type arguements to check, or an
+     *                             empty array if not a parameterized type
+     * @return
+     */
+    public static boolean isAssignableFrom(Class<?> rawType1,
+                                           Type[] actualTypeArguments1,
+                                           Class<?> rawType2,
+                                           Type[] actualTypeArguments2)
+    {
+        return Types.boxedClass(rawType1).isAssignableFrom(Types.boxedClass(rawType2)) &&
+                isAssignableFrom(actualTypeArguments1, actualTypeArguments2);
+    }
+
+    public static boolean matches(Class<?> rawType1,
+                                  Type[] actualTypeArguments1,
+                                  Class<?> rawType2,
+                                  Type[] actualTypeArguments2)
+    {
+        return Types.boxedClass(rawType1).equals(Types.boxedClass(rawType2)) &&
+                isAssignableFrom(actualTypeArguments1, actualTypeArguments2);
+    }
+
+    public static boolean isAssignableFrom(Type[] actualTypeArguments1, Type[] actualTypeArguments2)
+    {
+        for (int i = 0; i < actualTypeArguments1.length; i++)
+        {
+            Type type1 = actualTypeArguments1[i];
+            Type type2 = Object.class;
+            if (actualTypeArguments2.length > i)
+            {
+                type2 = actualTypeArguments2[i];
+            }
+            if (!isAssignableFrom(type1, type2))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean isAssignableFrom(Type type1, Set<? extends Type> types2)
+    {
+        for (Type type2 : types2)
+        {
+            if (isAssignableFrom(type1, type2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean matches(Type type1, Set<? extends Type> types2)
+    {
+        for (Type type2 : types2)
+        {
+            if (matches(type1, type2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isAssignableFrom(Type type1, Type[] types2)
+    {
+        for (Type type2 : types2)
+        {
+            if (isAssignableFrom(type1, type2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isAssignableFrom(Type type1, Type type2)
+    {
+        if (type1 instanceof Class<?>)
+        {
+            Class<?> clazz = (Class<?>) type1;
+            if (isAssignableFrom(clazz, EMPTY_TYPES, type2))
+            {
+                return true;
+            }
+        }
+        if (type1 instanceof ParameterizedType)
+        {
+            ParameterizedType parameterizedType1 = (ParameterizedType) type1;
+            if (parameterizedType1.getRawType() instanceof Class<?>)
+            {
+                if (isAssignableFrom((Class<?>) parameterizedType1.getRawType(),
+                                     parameterizedType1.getActualTypeArguments(),
+                                     type2))
+                {
+                    return true;
+                }
+            }
+        }
+        if (type1 instanceof WildcardType)
+        {
+            WildcardType wildcardType = (WildcardType) type1;
+            if (isTypeBounded(type2, wildcardType.getLowerBounds(), wildcardType.getUpperBounds()))
+            {
+                return true;
+            }
+        }
+        if (type2 instanceof WildcardType)
+        {
+            WildcardType wildcardType = (WildcardType) type2;
+            if (isTypeBounded(type1, wildcardType.getUpperBounds(), wildcardType.getLowerBounds()))
+            {
+                return true;
+            }
+        }
+        if (type1 instanceof TypeVariable<?>)
+        {
+            TypeVariable<?> typeVariable = (TypeVariable<?>) type1;
+            if (isTypeBounded(type2, EMPTY_TYPES, typeVariable.getBounds()))
+            {
+                return true;
+            }
+        }
+        if (type2 instanceof TypeVariable<?>)
+        {
+            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
+            if (isTypeBounded(type1, typeVariable.getBounds(), EMPTY_TYPES))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean matches(Type type1, Type type2)
+    {
+        if (type1 instanceof Class<?>)
+        {
+            Class<?> clazz = (Class<?>) type1;
+            if (matches(clazz, EMPTY_TYPES, type2))
+            {
+                return true;
+            }
+        }
+        if (type1 instanceof ParameterizedType)
+        {
+            ParameterizedType parameterizedType1 = (ParameterizedType) type1;
+            if (parameterizedType1.getRawType() instanceof Class<?>)
+            {
+                if (matches((Class<?>) parameterizedType1.getRawType(),
+                        parameterizedType1.getActualTypeArguments(),
+                        type2))
+                {
+                    return true;
+                }
+            }
+        }
+        if (type1 instanceof WildcardType)
+        {
+            WildcardType wildcardType = (WildcardType) type1;
+            if (isTypeBounded(type2, wildcardType.getLowerBounds(), wildcardType.getUpperBounds()))
+            {
+                return true;
+            }
+        }
+        if (type2 instanceof WildcardType)
+        {
+            WildcardType wildcardType = (WildcardType) type2;
+            if (isTypeBounded(type1, wildcardType.getUpperBounds(), wildcardType.getLowerBounds()))
+            {
+                return true;
+            }
+        }
+        if (type1 instanceof TypeVariable<?>)
+        {
+            TypeVariable<?> typeVariable = (TypeVariable<?>) type1;
+            if (isTypeBounded(type2, EMPTY_TYPES, typeVariable.getBounds()))
+            {
+                return true;
+            }
+        }
+        if (type2 instanceof TypeVariable<?>)
+        {
+            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
+            if (isTypeBounded(type1, typeVariable.getBounds(), EMPTY_TYPES))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isTypeBounded(Type type, Type[] lowerBounds, Type[] upperBounds)
+    {
+        if (lowerBounds.length > 0)
+        {
+            if (!isAssignableFrom(type, lowerBounds))
+            {
+                return false;
+            }
+        }
+        if (upperBounds.length > 0)
+        {
+            if (!isAssignableFrom(upperBounds, type))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean isAssignableFrom(Class<?> rawType1, Type[] actualTypeArguments1, Type type2)
+    {
+        if (type2 instanceof ParameterizedType)
+        {
+            ParameterizedType parameterizedType = (ParameterizedType) type2;
+            if (parameterizedType.getRawType() instanceof Class<?>)
+            {
+                if (isAssignableFrom(
+                        rawType1,
+                        actualTypeArguments1,
+                        (Class<?>) parameterizedType.getRawType(),
+                        parameterizedType.getActualTypeArguments()))
+                {
+                    return true;
+                }
+            }
+        }
+        else if (type2 instanceof Class<?>)
+        {
+            Class<?> clazz = (Class<?>) type2;
+            if (isAssignableFrom(rawType1, actualTypeArguments1, clazz, EMPTY_TYPES))
+            {
+                return true;
+            }
+        }
+        else if (type2 instanceof TypeVariable<?>)
+        {
+            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
+            if (isTypeBounded(rawType1, actualTypeArguments1, typeVariable.getBounds()))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean matches(Class<?> rawType1, Type[] actualTypeArguments1, Type type2)
+    {
+        if (type2 instanceof ParameterizedType)
+        {
+            ParameterizedType parameterizedType = (ParameterizedType) type2;
+            if (parameterizedType.getRawType() instanceof Class<?>)
+            {
+                if (matches(
+                        rawType1,
+                        actualTypeArguments1,
+                        (Class<?>) parameterizedType.getRawType(),
+                        parameterizedType.getActualTypeArguments()))
+                {
+                    return true;
+                }
+            }
+        }
+        else if (type2 instanceof Class<?>)
+        {
+            Class<?> clazz = (Class<?>) type2;
+            if (matches(rawType1, actualTypeArguments1, clazz, EMPTY_TYPES))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check the assiginability of a set of <b>flattened</b> types. This
+     * algorithm will check whether any of the types1 matches a type in types2
+     *
+     * @param types1
+     * @param types2
+     * @return
+     */
+    public static boolean isAssignableFrom(Set<Type> types1, Set<Type> types2)
+    {
+        for (Type type : types1)
+        {
+            if (isAssignableFrom(type, types2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check whether whether any of the types1 matches a type in types2
+     *
+     * @param types1
+     * @param types2
+     * @return
+     */
+    public static boolean matches(Set<Type> types1, Set<Type> types2)
+    {
+        for (Type type : types1)
+        {
+            if (matches(type, types2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check the assiginability of a set of <b>flattened</b> types. This
+     * algorithm will check whether any of the types1 matches a type in types2
+     *
+     * @param types1
+     * @param type2
+     * @return
+     */
+    public static boolean isAssignableFrom(Set<Type> types1, Type type2)
+    {
+        for (Type type : types1)
+        {
+            if (isAssignableFrom(type, type2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isAssignableFrom(Type[] types1, Type type2)
+    {
+        for (Type type : types1)
+        {
+            if (isAssignableFrom(type, type2))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPrimitive(Type type)
+    {
+        Class<?> rawType = getRawType(type);
+        return rawType != null && rawType.isPrimitive();
+    }
+}


Mime
View raw message