November 2008 - weld-commits - Jboss List Archives

[webbeans-commits] Webbeans SVN: r372 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-27 09:19:40 -0500 (Thu, 27 Nov 2008) New Revision: 372 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedConstructorImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedFieldImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedParameterImpl.java Log: some javadocs/comments Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-27 14:19:40 UTC (rev 372) @@ -80,7 +80,7 @@ * annotations * */ - public static class MetaAnnotationMap extends ForwardingMap<Class<? extends Annotation>, Set<Annotation>> + private static class MetaAnnotationMap extends ForwardingMap<Class<? extends Annotation>, Set<Annotation>> { private Map<Class<? extends Annotation>, Set<Annotation>> delegate; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -48,7 +48,10 @@ public class AnnotatedClassImpl<T> extends AbstractAnnotatedType<T> implements AnnotatedClass<T> { - protected static class AnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> + /** + * A (annotation type -> set of field abstractions with annotation) map + */ + private static class AnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> { private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate; @@ -64,7 +67,10 @@ } } - protected static class MetaAnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> + /** + * A (annotation type -> set of field abstractions with meta-annotation) map + */ + private static class MetaAnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> { private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate; @@ -80,7 +86,10 @@ } } - protected class AnnotatedMethods extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> + /** + * A (annotation type -> set of method abstractions with annotation) map + */ + private class AnnotatedMethods extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> { private Map<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> delegate; @@ -96,7 +105,10 @@ } } - protected class AnnotatedConstructors extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> + /** + * A (annotation type -> set of constructor abstractions with annotation) map + */ + private class AnnotatedConstructors extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> { private Map<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> delegate; @@ -112,7 +124,10 @@ } } - protected class ConstructorsByArgument extends ForwardingMap<List<Class<?>>, AnnotatedConstructor<T>> + /** + * A (class list -> set of constructor abstractions with matching parameters) map + */ + private class ConstructorsByArgument extends ForwardingMap<List<Class<?>>, AnnotatedConstructor<T>> { private Map<List<Class<?>>, AnnotatedConstructor<T>> delegate; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedConstructorImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedConstructorImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedConstructorImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; @@ -16,18 +33,58 @@ import org.jboss.webbeans.introspector.AnnotatedParameter; import org.jboss.webbeans.introspector.AnnotatedType; +import com.google.common.collect.ForwardingMap; + +/** + * Represents an annotated constructor + * + * @author Pete Muir + * + * @param <T> + */ public class AnnotatedConstructorImpl<T> extends AbstractAnnotatedMember<T, Constructor<T>> implements AnnotatedConstructor<T> { + /** + * An annotation type -> list of annotations map + */ + private class AnnotatedParameters extends ForwardingMap<Class<? extends Annotation>, List<AnnotatedParameter<Object>>> + { + private Map<Class<? extends Annotation>, List<AnnotatedParameter<Object>>> delegate; + + public AnnotatedParameters() + { + delegate = new HashMap<Class<? extends Annotation>, List<AnnotatedParameter<Object>>>(); + } + + @Override + protected Map<Class<? extends Annotation>, List<AnnotatedParameter<Object>>> delegate() + { + return delegate; + } + } + + // The type arguments private static final Type[] actualTypeArguments = new Type[0]; - + // The underlying constructor private Constructor<T> constructor; - + + // The list of parameter abstractions private List<AnnotatedParameter<Object>> parameters; - private Map<Class<? extends Annotation>, List<AnnotatedParameter<Object>>> annotatedParameters; - + // The mapping of annotation -> parameter abstraction + private AnnotatedParameters annotatedParameters; + + // The declaring class abstraction private AnnotatedType<T> declaringClass; - + + /** + * Constructor + * + * Initializes the superclass with the build annotations map + * + * @param constructor The constructor method + * @param declaringClass The declaring class + */ public AnnotatedConstructorImpl(Constructor<T> constructor, AnnotatedType<T> declaringClass) { super(buildAnnotationMap(constructor)); @@ -35,26 +92,53 @@ this.declaringClass = declaringClass; } + /** + * Gets the constructor + * + * @return The constructor + */ public Constructor<T> getAnnotatedConstructor() { return constructor; } + /** + * Gets the delegate (constructor) + * + * @return The delegate + */ public Constructor<T> getDelegate() { return constructor; } - + + /** + * Gets the type of the constructor + * + * @return The type of the constructor + */ public Class<T> getType() { return constructor.getDeclaringClass(); } - + + /** + * Gets the actual type arguments + * + * @return The type arguments + */ public Type[] getActualTypeArguments() { return actualTypeArguments; } - + + /** + * Gets the abstracted parameters + * + * If the parameters are null, initalize them first + * + * @return A list of annotated parameter abstractions + */ public List<AnnotatedParameter<Object>> getParameters() { if (parameters == null) @@ -63,10 +147,17 @@ } return parameters; } - + + /** + * Initializes the parameter abstractions + * + * Iterates over the constructor parameters, adding the parameter abstraction + * to the parameters list. + */ + @SuppressWarnings("unchecked") private void initParameters() { - this.parameters = new ArrayList<AnnotatedParameter<Object>>(); + parameters = new ArrayList<AnnotatedParameter<Object>>(); for (int i = 0; i < constructor.getParameterTypes().length; i++) { if (constructor.getParameterAnnotations()[i].length > 0) @@ -83,14 +174,23 @@ } } } - + + /** + * Gets the parameter abstractions with a given annotation type + * + * if the annotated parameters map is null, it is initialized first. + * + * @param annotationType The annotation type to match + * @return The list of parameter abstractions with given annotation type. An + * empty list is returned if there are no matches. + */ public List<AnnotatedParameter<Object>> getAnnotatedMethods(Class<? extends Annotation> annotationType) { if (annotatedParameters == null) { initAnnotatedParameters(); } - + if (!annotatedParameters.containsKey(annotationType)) { return new ArrayList<AnnotatedParameter<Object>>(); @@ -101,13 +201,20 @@ } } + /** + * Initializes the annotated parameters + * + * If the parameters are null, they are initialized first. Iterate over the + * parameters and for each parameter annotation map it under the annotation + * type. + */ private void initAnnotatedParameters() { if (parameters == null) { initParameters(); } - annotatedParameters = new HashMap<Class<? extends Annotation>, List<AnnotatedParameter<Object>>>(); + annotatedParameters = new AnnotatedParameters(); for (AnnotatedParameter<Object> parameter : parameters) { for (Annotation annotation : parameter.getAnnotations()) @@ -121,6 +228,15 @@ } } + /** + * Gets parameter abstractions with a given annotation type. + * + * If the parameters are null, they are initializes first. + * + * @param annotationType The annotation type to match + * @return A list of matching parameter abstractions. An empty list is + * returned if there are no matches. + */ public List<AnnotatedParameter<Object>> getAnnotatedParameters(Class<? extends Annotation> annotationType) { if (annotatedParameters == null) @@ -133,11 +249,18 @@ } return annotatedParameters.get(annotationType); } - + + /** + * Creates a new instance + * + * @param manager The Web Beans manager + * @return An instance + */ public T newInstance(ManagerImpl manager) { try { + // TODO: more details in the exceptions return getDelegate().newInstance(getParameterValues(parameters, manager)); } catch (IllegalArgumentException e) @@ -157,11 +280,17 @@ throw new ExecutionException(e); } } - + + /** + * The overridden equals operation + * + * @param other The instance to compare to + * @return True if equal, false otherwise + */ @Override public boolean equals(Object other) { - + if (super.equals(other) && other instanceof AnnotatedConstructor) { AnnotatedConstructor<?> that = (AnnotatedConstructor<?>) other; @@ -169,13 +298,25 @@ } return false; } - + + /** + * The overridden hashcode + * + * Gets the hash code from the delegate + * + * @return The hash code + */ @Override public int hashCode() { return getDelegate().hashCode(); } - + + /** + * Gets the declaring class + * + * @return The declaring class + */ public AnnotatedType<T> getDeclaringClass() { return declaringClass; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedFieldImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedFieldImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedFieldImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.reflect.Field; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedParameterImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedParameterImpl.java 2008-11-27 13:33:35 UTC (rev 371) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedParameterImpl.java 2008-11-27 14:19:40 UTC (rev 372) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation;

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r371 - in ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector: jlr and 1 other directory.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-27 08:33:35 -0500 (Thu, 27 Nov 2008) New Revision: 371 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java Log: some javadocs/comments Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-27 11:00:34 UTC (rev 370) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-27 13:33:35 UTC (rev 371) @@ -115,7 +115,7 @@ /** * Checks if any of the types provided are assignable to this, using - * the extended assingablity algorithm provided by AnnotatedItem. + * the extended assignability algorithm provided by AnnotatedItem. * * The types are assumed to contain their own actual type parameterization. * Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-27 11:00:34 UTC (rev 370) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-27 13:33:35 UTC (rev 371) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; @@ -19,29 +36,132 @@ import org.jboss.webbeans.introspector.AnnotatedField; import org.jboss.webbeans.introspector.AnnotatedMethod; +import com.google.common.collect.ForwardingMap; + /** - * Base class for implementing AnnotatedItem. + * Represents an annotated class * - * @author pmuir + * @author Pete Muir * + * @param <T> */ public class AnnotatedClassImpl<T> extends AbstractAnnotatedType<T> implements AnnotatedClass<T> { + protected static class AnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> + { + private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate; + + public AnnotatedFields() + { + delegate = new HashMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>>(); + } + + @Override + protected Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate() + { + return delegate; + } + } + + protected static class MetaAnnotatedFields extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>> + { + private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate; + + public MetaAnnotatedFields() + { + delegate = new HashMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>>(); + } + + @Override + protected Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> delegate() + { + return delegate; + } + } + + protected class AnnotatedMethods extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> + { + private Map<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> delegate; + + public AnnotatedMethods() + { + delegate = new HashMap<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>>(); + } + + @Override + protected Map<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> delegate() + { + return delegate; + } + } + + protected class AnnotatedConstructors extends ForwardingMap<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> + { + private Map<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> delegate; + + public AnnotatedConstructors() + { + delegate = new HashMap<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>>(); + } + + @Override + protected Map<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> delegate() + { + return delegate; + } + } + + protected class ConstructorsByArgument extends ForwardingMap<List<Class<?>>, AnnotatedConstructor<T>> + { + private Map<List<Class<?>>, AnnotatedConstructor<T>> delegate; + + public ConstructorsByArgument() + { + delegate = new HashMap<List<Class<?>>, AnnotatedConstructor<T>>(); + } + + @Override + protected Map<List<Class<?>>, AnnotatedConstructor<T>> delegate() + { + return delegate; + } + } + + // The implementing class private Class<T> clazz; + // The type arguments private Type[] actualTypeArguments; + // The set of abstracted fields private Set<AnnotatedField<Object>> fields; - private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> annotatedFields; - private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> metaAnnotatedFields; + // The map from annotation type to abstracted field with annotation + private AnnotatedFields annotatedFields; + // The map from annotation type to abstracted field with meta-annotation + private MetaAnnotatedFields metaAnnotatedFields; + // The set of abstracted methods private Set<AnnotatedMethod<Object>> methods; - private Map<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> annotatedMethods; + // The map from annotation type to abstracted method with annotation + private AnnotatedMethods annotatedMethods; + // The set of abstracted constructors private Set<AnnotatedConstructor<T>> constructors; - private Map<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> annotatedConstructors; - private Map<List<Class<?>>, AnnotatedConstructor<T>> constructorsByArgumentMap; + // The map from annotation type to abstracted constructor with annotation + private AnnotatedConstructors annotatedConstructors; + // The map from class list to abstracted constructor + private ConstructorsByArgument constructorsByArgumentMap; + /** + * Constructor + * + * Initializes superclass with built annotation map, sets the raw type and + * determines the actual type arguments + * + * @param rawType The raw type of the class + * @param type The type of the class + * @param annotations The array of annotations on the class + */ public AnnotatedClassImpl(Class<T> rawType, Type type, Annotation[] annotations) { super(buildAnnotationMap(annotations)); @@ -56,21 +176,45 @@ } } + /** + * Constructor + * + * Calls another constructor with the class annotations array + * + * @param clazz The implementing class + */ public AnnotatedClassImpl(Class<T> clazz) { this(clazz, clazz, clazz.getAnnotations()); } + /** + * Gets the implementing class + * + * @return The class + */ public Class<? extends T> getAnnotatedClass() { return clazz; } + /** + * Gets the delegate (class) + * + * @return The class + */ public Class<T> getDelegate() { return clazz; } + /** + * Gets the abstracted fields of the class + * + * Initializes the fields if they are null + * + * @return The set of abstracted fields + */ public Set<AnnotatedField<Object>> getFields() { if (fields == null) @@ -80,6 +224,13 @@ return fields; } + /** + * Gets the abstracted constructors of the class + * + * Initializes the constructors if they are null + * + * @return The set of abstracted constructors + */ public Set<AnnotatedConstructor<T>> getConstructors() { if (constructors == null) @@ -89,25 +240,46 @@ return constructors; } + /** + * Initializes the fields + * + * Iterates through the type hierarchy and adds the abstracted fields to the + * fields list + * + */ private void initFields() { this.fields = new HashSet<AnnotatedField<Object>>(); - for (Class c = clazz; c != Object.class; c = c.getSuperclass()) + for (Class<?> c = clazz; c != Object.class; c = c.getSuperclass()) { for (Field field : clazz.getDeclaredFields()) { if (!field.isAccessible()) + { field.setAccessible(true); + } fields.add(new AnnotatedFieldImpl<Object>(field, this)); } } } + /** + * Gets abstracted fields with requested meta-annotation type present + * + * If the meta-annotations map is null, it is initializes. If the annotated + * fields are null, it is initialized The meta-annotated field map is then + * populated for the requested meta-annotation type and the result is + * returned + * + * @param metaAnnotationType The meta-annotation type to match + * @return The set of abstracted fields with meta-annotation present. Returns + * an empty set if no matches are found. + */ public Set<AnnotatedField<Object>> getMetaAnnotatedFields(Class<? extends Annotation> metaAnnotationType) { if (metaAnnotatedFields == null) { - metaAnnotatedFields = new HashMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>>(); + metaAnnotatedFields = new MetaAnnotatedFields(); } if (annotatedFields == null) { @@ -117,7 +289,16 @@ return metaAnnotatedFields.get(metaAnnotationType); } - protected static <T extends Annotation> Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> populateMetaAnnotatedFieldMap(Class<T> metaAnnotationType, Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> annotatedFields, Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> metaAnnotatedFields) + /** + * Populates the meta annotated fields map for a meta-annotation type + * + * @param <T> + * @param metaAnnotationType The meta-annotation to examine + * @param annotatedFields The annotated fields + * @param metaAnnotatedFields The meta-annotated fields + * @return The meta-annotated fields map + */ + protected static <T extends Annotation> MetaAnnotatedFields populateMetaAnnotatedFieldMap(Class<T> metaAnnotationType, AnnotatedFields annotatedFields, MetaAnnotatedFields metaAnnotatedFields) { if (!metaAnnotatedFields.containsKey(metaAnnotationType)) { @@ -134,6 +315,15 @@ return metaAnnotatedFields; } + /** + * Gets the abstracted field annotated with a specific annotation type + * + * If the fields map is null, initialize it first + * + * @param annotationType The annotation type to match + * @return A set of matching abstracted fields, null if none are found. + * + */ public Set<AnnotatedField<Object>> getAnnotatedFields(Class<? extends Annotation> annotationType) { if (annotatedFields == null) @@ -143,13 +333,20 @@ return annotatedFields.get(annotationType); } + /** + * Initializes the annotated fields map + * + * If the fields set if empty, populate it first. Iterate through the fields, + * for each field, iterate over the annotations and map the field abstraction + * under the annotation type key. + */ private void initAnnotatedFields() { if (fields == null) { initFields(); } - annotatedFields = new HashMap<Class<? extends Annotation>, Set<AnnotatedField<Object>>>(); + annotatedFields = new AnnotatedFields(); for (AnnotatedField<Object> field : fields) { for (Annotation annotation : field.getAnnotations()) @@ -163,30 +360,57 @@ } } + /** + * Gets the type of the class + * + * @return The type + */ public Class<T> getType() { return clazz; } + /** + * Gets the actual type arguments + * + * @return The type arguments + */ public Type[] getActualTypeArguments() { return actualTypeArguments; } + /** + * Initializes the methods + * + * Iterate over the class hierarchy and for each type, add all methods + * abstracted to the methods list + */ private void initMethods() { this.methods = new HashSet<AnnotatedMethod<Object>>(); - for (Class c = clazz; c != Object.class; c = c.getSuperclass()) + for (Class<?> c = clazz; c != Object.class; c = c.getSuperclass()) { for (Method method : clazz.getDeclaredMethods()) { if (!method.isAccessible()) + { method.setAccessible(true); + } methods.add(new AnnotatedMethodImpl<Object>(method, this)); } } } + /** + * Gets the abstracted methods that have a certain annotation type present + * + * If the annotated methods map is null, initialize it first + * + * @param annotationType The annotation type to match + * @return A set of matching method abstractions. Returns an empty set if no + * matches are found. + */ public Set<AnnotatedMethod<Object>> getAnnotatedMethods(Class<? extends Annotation> annotationType) { if (annotatedMethods == null) @@ -204,13 +428,20 @@ } } + /** + * Initializes the annotated methods + * + * If the methods set is null, initialize it first. Iterate over all method + * abstractions and for each annotation, map the method abstraction under the + * annotation type key. + */ private void initAnnotatedMethods() { if (methods == null) { initMethods(); } - annotatedMethods = new HashMap<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>>(); + annotatedMethods = new AnnotatedMethods(); for (AnnotatedMethod<Object> member : methods) { for (Annotation annotation : member.getAnnotations()) @@ -224,20 +455,38 @@ } } + /** + * Initializes the constructors set and constructors-by-argument map + * + * Iterate over the constructors and for each constructor, add an abstracted + * constructor to the constructors set and the same constructor abstraction + * to the constructors-by-argument map under the argument-list-key. + */ + @SuppressWarnings("unchecked") private void initConstructors() { this.constructors = new HashSet<AnnotatedConstructor<T>>(); - this.constructorsByArgumentMap = new HashMap<List<Class<?>>, AnnotatedConstructor<T>>(); + this.constructorsByArgumentMap = new ConstructorsByArgument(); for (Constructor<?> constructor : clazz.getDeclaredConstructors()) { AnnotatedConstructor<T> annotatedConstructor = new AnnotatedConstructorImpl<T>((Constructor<T>) constructor, this); if (!constructor.isAccessible()) + { constructor.setAccessible(true); + } constructors.add(annotatedConstructor); constructorsByArgumentMap.put(Arrays.asList(constructor.getParameterTypes()), annotatedConstructor); } } + /** + * Gets constructors with given annotation type + * + * @param annotationType The annotation type to match + * @return A set of abstracted constructors with given annotation type. If + * the constructors set is empty, initialize it first .Returns an + * empty set if there are no matches. + */ public Set<AnnotatedConstructor<T>> getAnnotatedConstructors(Class<? extends Annotation> annotationType) { if (annotatedConstructors == null) @@ -255,13 +504,20 @@ } } + /** + * Initializes the annotated constructors. + * + * If the constructors set is empty, initialize it first. Iterate over all + * constructor abstractions and for each annotation on the constructor, map + * the constructor abstraction under the annotation key. + */ private void initAnnotatedConstructors() { if (constructors == null) { initConstructors(); } - annotatedConstructors = new HashMap<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>>(); + annotatedConstructors = new AnnotatedConstructors(); for (AnnotatedConstructor<T> constructor : constructors) { for (Annotation annotation : constructor.getAnnotations())

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r370 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-27 06:00:34 -0500 (Thu, 27 Nov 2008) New Revision: 370 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedAnnotationImpl.java Log: Some javadocs/comments Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-27 07:52:23 UTC (rev 369) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-27 11:00:34 UTC (rev 370) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; @@ -11,9 +28,7 @@ import java.util.Map; import java.util.Set; -import javax.webbeans.AnnotationLiteral; import javax.webbeans.BindingType; -import javax.webbeans.Stereotype; import org.jboss.webbeans.ManagerImpl; import org.jboss.webbeans.bindings.CurrentAnnotationLiteral; @@ -24,9 +39,25 @@ import com.google.common.collect.ForwardingMap; +/** + * Represents functionality common for all annotated items, mainly different + * mappings of the annotations and meta-annotations + * + * @author Pete Muir + * @author Nicklas Karlsson + * + * @param <T> + * @param <S> + * + * @see org.jboss.webbeans.introspector.AnnotatedItem + */ public abstract class AbstractAnnotatedItem<T, S> implements AnnotatedItem<T, S> { + /** + * Represents a mapping from a annotation type to an annotation + * implementation + */ public static class AnnotationMap extends ForwardingMap<Class<? extends Annotation>, Annotation> { private Map<Class<? extends Annotation>, Annotation> delegate; @@ -44,6 +75,11 @@ } + /** + * Represents a mapping from a annotation (meta-annotation) to a set of + * annotations + * + */ public static class MetaAnnotationMap extends ForwardingMap<Class<? extends Annotation>, Set<Annotation>> { private Map<Class<? extends Annotation>, Set<Annotation>> delegate; @@ -59,6 +95,16 @@ return delegate; } + /** + * Gets the set of annotations matching the given annotation type + * + * If the key is not found, an empty set is created and placed in the map + * before returned + * + * @param key The meta-annotation to match + * @returns The set of matching annotations containing this + * meta-annotation + */ @SuppressWarnings("unchecked") @Override public Set<Annotation> get(Object key) @@ -74,16 +120,33 @@ } + // The array of default binding types private static final Annotation[] DEFAULT_BINDING_ARRAY = { new CurrentAnnotationLiteral() }; + // The set of default binding types private static final Set<Annotation> DEFAULT_BINDING = new HashSet<Annotation>(Arrays.asList(DEFAULT_BINDING_ARRAY)); + // The array of meta-annotations to map private static final Annotation[] MAPPED_METAANNOTATIONS_ARRAY = {}; + // The set of meta-annotations to map private static final Set<Annotation> MAPPED_METAANNOTATIONS = new HashSet<Annotation>(Arrays.asList(MAPPED_METAANNOTATIONS_ARRAY)); + // The annotation map (annotation type -> annotation) of the item private AnnotationMap annotationMap; + // The meta-annotation map (annotation type -> set of annotations containing meta-annotation) of the item private MetaAnnotationMap metaAnnotationMap; + // The set of all annotations on the item private Set<Annotation> annotationSet; + // The array of all annotations on the item private Annotation[] annotationArray; + /** + * Constructor + * + * Also builds the meta-annotation map. Throws a NullPointerException if + * trying to register a null map + * + * @param annotationMap A map of annotation to register + * + */ public AbstractAnnotatedItem(AnnotationMap annotationMap) { if (annotationMap == null) @@ -94,6 +157,15 @@ buildMetaAnnotationMap(annotationMap); } + /** + * Build the meta-annotation map + * + * Iterates through the annotationMap values (annotations) and for each + * meta-annotation on the annotation register the annotation in the set under + * they key of the meta-annotation type. + * + * @param annotationMap The annotation map to parse + */ private void buildMetaAnnotationMap(AnnotationMap annotationMap) { metaAnnotationMap = new MetaAnnotationMap(); @@ -101,20 +173,33 @@ { for (Annotation metaAnnotation : annotation.annotationType().getAnnotations()) { -// TODO: Check with Pete how to fill the array. Make annotation literals for all? -// if (MAPPED_METAANNOTATIONS.contains(metaAnnotation)) -// { - metaAnnotationMap.get(metaAnnotation.annotationType()).add(annotation); -// } + // TODO: Check with Pete how to fill the array. Make annotation + // literals for all? + // if (MAPPED_METAANNOTATIONS.contains(metaAnnotation)) + // { + metaAnnotationMap.get(metaAnnotation.annotationType()).add(annotation); + // } } } } + /** + * Static helper method for building annotation map from an annotated element + * + * @param element The element to examine + * @return The annotation map + */ protected static AnnotationMap buildAnnotationMap(AnnotatedElement element) { return buildAnnotationMap(element.getAnnotations()); } + /** + * Builds the annotation map (annotation type -> annotation) + * + * @param annotations The array of annotations to map + * @return The annotation map + */ protected static AnnotationMap buildAnnotationMap(Annotation[] annotations) { AnnotationMap annotationMap = new AnnotationMap(); @@ -125,6 +210,14 @@ return annotationMap; } + /** + * Static helper method for getting the current parameter values from a list + * of annotated parameters. + * + * @param parameters The list of annotated parameter to look up + * @param manager The Web Beans manager + * @return The object array of looked up values + */ protected static Object[] getParameterValues(List<AnnotatedParameter<Object>> parameters, ManagerImpl manager) { Object[] parameterValues = new Object[parameters.size()]; @@ -136,17 +229,40 @@ return parameterValues; } + /** + * Gets the annotation for a given annotation type. + * + * @param annotationType the annotation type to match + * @return The annotation if found, null if no match was found + */ @SuppressWarnings("unchecked") public <A extends Annotation> A getAnnotation(Class<? extends A> annotationType) { return (A) annotationMap.get(annotationType); } + /** + * Gets the set of annotations that contain a given annotation type + * + * @param metaAnnotationType The meta-annotation type to match + * @return The set of annotations containing this meta-annotation. An empty + * set is returned if no match is found. + */ public Set<Annotation> getMetaAnnotations(Class<? extends Annotation> metaAnnotationType) { return metaAnnotationMap.get(metaAnnotationType); } + /** + * Gets (as an array) the set of annotations that contain a given annotation + * type. + * + * Populates the annotationArray if it was null + * + * @param metaAnnotationType meta-annotation type to match + * @return The array of annotations to match. An empty array is returned if + * no match is found. + */ public Annotation[] getMetaAnnotationsAsArray(Class<? extends Annotation> metaAnnotationType) { if (annotationArray == null) @@ -157,6 +273,13 @@ return annotationArray; } + /** + * Gets all annotations on this item + * + * Populates the annotationSet if it was empty + * + * @return The set of annotations on this item. + */ public Set<Annotation> getAnnotations() { if (annotationSet == null) @@ -167,16 +290,33 @@ return annotationSet; } + /** + * Checks if an annotation is present on the item + * + * @param annotatedType The annotation type to check for + * @return True if present, false otherwise. + */ public boolean isAnnotationPresent(Class<? extends Annotation> annotatedType) { return annotationMap.containsKey(annotatedType); } + /** + * Gets the annotation map + * + * @return The annotation map + */ protected AnnotationMap getAnnotationMap() { return annotationMap; } + /** + * Compares two AbstractAnnotatedItems + * + * @param other The other item + * @return True if equals, false otherwise + */ @Override public boolean equals(Object other) { @@ -188,11 +328,24 @@ return false; } + /** + * Checks if this item is assignable from another annotated item (through + * type and actual type arguments) + * + * @param that The other annotated item to check against + * @return True if assignable, false otherwise + */ public boolean isAssignableFrom(AnnotatedItem<?, ?> that) { return isAssignableFrom(that.getType(), that.getActualTypeArguments()); } + /** + * Checks if this item is assignable from any one a set of types + * + * @param types The set of types to check against + * @return True if assignable, false otherwise + */ public boolean isAssignableFrom(Set<Class<?>> types) { for (Class<?> type : types) @@ -205,17 +358,34 @@ return false; } + /** + * Helper method for doing actual assignability check + * + * @param type The type to compare against + * @param actualTypeArguments The type arguments + * @return True is assignable, false otherwise + */ private boolean isAssignableFrom(Class<?> type, Type[] actualTypeArguments) { return Types.boxedType(getType()).isAssignableFrom(Types.boxedType(type)) && Arrays.equals(getActualTypeArguments(), actualTypeArguments); } + /** + * Gets the hash code of the actual type + * + * @return The hash code + */ @Override public int hashCode() { return getType().hashCode(); } + /** + * Gets a string representation of the item + * + * @return A string representation + */ @Override public String toString() { @@ -237,6 +407,14 @@ return string; } + /** + * Gets the binding types of the item + * + * Looks at the meta-annotations map for annotations with binding type + * meta-annotation. Returns default binding (current) if none specified. + * + * @return A set of (binding type) annotations + */ public Set<Annotation> getBindingTypes() { if (getMetaAnnotations(BindingType.class).size() > 0) @@ -249,6 +427,14 @@ } } + /** + * Gets (as array) the binding types of the item + * + * Looks at the meta-annotations map for annotations with binding type + * meta-annotation. Returns default binding (current) if none specified. + * + * @return An array of (binding type) annotations + */ public Annotation[] getBindingTypesAsArray() { if (getMetaAnnotationsAsArray(BindingType.class).length > 0) @@ -261,6 +447,11 @@ } } + /** + * Indicates if the type is proxyable to a set of pre-defined rules + * + * @return True if proxyable, false otherwise. + */ public boolean isProxyable() { if (Reflections.getConstructor(getType()) == null) Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java 2008-11-27 07:52:23 UTC (rev 369) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java 2008-11-27 11:00:34 UTC (rev 370) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.reflect.Member; @@ -7,31 +24,65 @@ import org.jboss.webbeans.ManagerImpl; import org.jboss.webbeans.util.Reflections; +/** + * Represents an abstract annotated memeber (field, method or constructor) + * + * @author Pete Muir + * + * @param <T> + * @param <S> + */ public abstract class AbstractAnnotatedMember<T, S extends Member> extends AbstractAnnotatedItem<T, S> { - + // The name of the member private String name; + /** + * Constructor + * + * @param annotationMap The annotation map + */ public AbstractAnnotatedMember(AnnotationMap annotationMap) { super(annotationMap); } - + + /** + * Indicates if the member is static (through the delegate) + * + * @return True if static, false otherwise + */ public boolean isStatic() { return Reflections.isStatic(getDelegate()); } - + + /** + * Indicates if the member if final (through the delegate) + * + * @return True if final, false otherwise + */ public boolean isFinal() { return Reflections.isFinal(getDelegate()); } - + + /** + * Gets the current value of the member + * + * @param manager The Web Beans manager + * @return The current value + */ public T getValue(ManagerImpl manager) { return manager.getInstanceByType(getType(), getMetaAnnotationsAsArray(BindingType.class)); } - + + /** + * Gets the name of the member + * + * @returns The name (or the name of the delegate if none is defined) + */ public String getName() { if (name == null) @@ -40,5 +91,5 @@ } return name; } - + } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java 2008-11-27 07:52:23 UTC (rev 369) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java 2008-11-27 11:00:34 UTC (rev 370) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import org.jboss.webbeans.introspector.AnnotatedClass; @@ -3,29 +20,61 @@ import org.jboss.webbeans.util.Reflections; +/** + * Represents an abstract annotated type + * + * @author Pete Muir + * + * @param <T> + */ public abstract class AbstractAnnotatedType<T> extends AbstractAnnotatedItem<T, Class<T>> { - + // The superclass abstraction of the type private AnnotatedClass<Object> superclass; + /** + * Constructor + * + * @param annotationMap The annotation map + */ public AbstractAnnotatedType(AnnotationMap annotationMap) { super(annotationMap); } + /** + * Indicates if the type is static (through the delegate) + * + * @return True if static, false otherwise + */ public boolean isStatic() { return Reflections.isStatic(getDelegate()); } + /** + * Indicates if the type if final (through the delegate) + * + * @return True if final, false otherwise + */ public boolean isFinal() { return Reflections.isFinal(getDelegate()); } + /** + * Gets the name of the type + * + * @returns The name (through the delegate) + */ public String getName() { return getDelegate().getName(); } + /** + * Gets the superclass abstraction of the type + * + * @return The superclass abstraction + */ @SuppressWarnings("unchecked") // TODO Fix this Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedAnnotationImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedAnnotationImpl.java 2008-11-27 07:52:23 UTC (rev 369) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedAnnotationImpl.java 2008-11-27 11:00:34 UTC (rev 370) @@ -1,3 +1,20 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed 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.jboss.webbeans.introspector.jlr; import java.lang.annotation.Annotation; @@ -11,26 +28,52 @@ import org.jboss.webbeans.introspector.AnnotatedAnnotation; import org.jboss.webbeans.introspector.AnnotatedMethod; +/** + * Represents an annotated annotation + * + * @author Pete Muir + * + * @param <T> + */ public class AnnotatedAnnotationImpl<T extends Annotation> extends AbstractAnnotatedType<T> implements AnnotatedAnnotation<T> { - + // The annotated members map (annotation -> member with annotation) private Map<Class<? extends Annotation>, Set<AnnotatedMethod<?>>> annotatedMembers; - + // The implementation class of the annotation private Class<T> clazz; - + // The set of abstracted members private Set<AnnotatedMethod<?>> members; - + + /** + * Constructor + * + * Initializes the superclass with the built annotation map + * + * @param annotationType The annotation type + */ public AnnotatedAnnotationImpl(Class<T> annotationType) { super(buildAnnotationMap(annotationType)); this.clazz = annotationType; } - + + /** + * Gets the actual type arguments + * + * @return The type arguments + */ public Type[] getActualTypeArguments() { return new Type[0]; } + /** + * Gets all members of the annotation + * + * Initializes the members first if they are null + * + * @return The set of abstracted members + */ public Set<AnnotatedMethod<?>> getMembers() { if (members == null) @@ -40,32 +83,55 @@ return members; } + /** + * Gets the delegate + * + * @return The delegate + */ public Class<T> getDelegate() { return clazz; } + /** + * Gets the type of the annotation + */ public Class<T> getType() { return clazz; } - + + /** + * Initializes the members + * + * Iterates through the declared members, creates abstractions of them and + * adds them to the members set + */ private void initMembers() { - this.members = new HashSet<AnnotatedMethod<?>>(); + members = new HashSet<AnnotatedMethod<?>>(); for (Method member : clazz.getDeclaredMethods()) { members.add(new AnnotatedMethodImpl<Object>(member, this)); } } + /** + * Returns the annotated members with a given annotation type + * + * If the annotated members are null, they are initialized first. + * + * @param annotationType The annotation type to match + * @return The set of abstracted members with the given annotation type + * present. An empty set is returned if no matches are found + */ public Set<AnnotatedMethod<?>> getAnnotatedMembers(Class<? extends Annotation> annotationType) { if (annotatedMembers == null) { initAnnotatedMembers(); } - + if (!annotatedMembers.containsKey(annotationType)) { return new HashSet<AnnotatedMethod<?>>(); @@ -76,6 +142,15 @@ } } + /** + * Initializes the annotated members + * + * If the members are null, the are initialized first. + * + * Iterates over the members and for each member, iterate over the + * annotations present, creating member abstractions and mapping them under + * the annotation in the annotatedMembers map. + */ private void initAnnotatedMembers() { if (members == null) @@ -95,5 +170,5 @@ } } } - + }

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r369 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-27 02:52:23 -0500 (Thu, 27 Nov 2008) New Revision: 369 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java Log: Parse meta-annotation when setting annotation map (remove lazy-loading). Still not filtering, though. Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 22:51:40 UTC (rev 368) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-27 07:52:23 UTC (rev 369) @@ -10,9 +10,10 @@ import java.util.List; import java.util.Map; import java.util.Set; -import java.util.Map.Entry; +import javax.webbeans.AnnotationLiteral; import javax.webbeans.BindingType; +import javax.webbeans.Stereotype; import org.jboss.webbeans.ManagerImpl; import org.jboss.webbeans.bindings.CurrentAnnotationLiteral; @@ -58,10 +59,25 @@ return delegate; } + @SuppressWarnings("unchecked") + @Override + public Set<Annotation> get(Object key) + { + Set<Annotation> annotations = super.get(key); + if (annotations == null) + { + annotations = new HashSet<Annotation>(); + super.put((Class<? extends Annotation>) key, annotations); + } + return annotations; + } + } private static final Annotation[] DEFAULT_BINDING_ARRAY = { new CurrentAnnotationLiteral() }; private static final Set<Annotation> DEFAULT_BINDING = new HashSet<Annotation>(Arrays.asList(DEFAULT_BINDING_ARRAY)); + private static final Annotation[] MAPPED_METAANNOTATIONS_ARRAY = {}; + private static final Set<Annotation> MAPPED_METAANNOTATIONS = new HashSet<Annotation>(Arrays.asList(MAPPED_METAANNOTATIONS_ARRAY)); private AnnotationMap annotationMap; private MetaAnnotationMap metaAnnotationMap; @@ -75,8 +91,25 @@ throw new NullPointerException("annotationMap cannot be null"); } this.annotationMap = annotationMap; + buildMetaAnnotationMap(annotationMap); } + private void buildMetaAnnotationMap(AnnotationMap annotationMap) + { + metaAnnotationMap = new MetaAnnotationMap(); + for (Annotation annotation : annotationMap.values()) + { + for (Annotation metaAnnotation : annotation.annotationType().getAnnotations()) + { +// TODO: Check with Pete how to fill the array. Make annotation literals for all? +// if (MAPPED_METAANNOTATIONS.contains(metaAnnotation)) +// { + metaAnnotationMap.get(metaAnnotation.annotationType()).add(annotation); +// } + } + } + } + protected static AnnotationMap buildAnnotationMap(AnnotatedElement element) { return buildAnnotationMap(element.getAnnotations()); @@ -111,11 +144,6 @@ public Set<Annotation> getMetaAnnotations(Class<? extends Annotation> metaAnnotationType) { - if (metaAnnotationMap == null) - { - metaAnnotationMap = new MetaAnnotationMap(); - } - metaAnnotationMap = populateMetaAnnotationMap(metaAnnotationType, metaAnnotationMap, annotationMap); return metaAnnotationMap.get(metaAnnotationType); } @@ -144,23 +172,6 @@ return annotationMap.containsKey(annotatedType); } - protected static <A extends Annotation> MetaAnnotationMap populateMetaAnnotationMap(Class<A> metaAnnotationType, MetaAnnotationMap metaAnnotationMap, AnnotationMap annotationMap) - { - if (!metaAnnotationMap.containsKey(metaAnnotationType)) - { - Set<Annotation> annotations = new HashSet<Annotation>(); - for (Entry<Class<? extends Annotation>, Annotation> entry : annotationMap.entrySet()) - { - if (entry.getKey().isAnnotationPresent(metaAnnotationType)) - { - annotations.add(entry.getValue()); - } - } - metaAnnotationMap.put(metaAnnotationType, annotations); - } - return metaAnnotationMap; - } - protected AnnotationMap getAnnotationMap() { return annotationMap;

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r368 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 17:51:40 -0500 (Wed, 26 Nov 2008) New Revision: 368 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java Log: Minor cosmetic stuff Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 22:23:32 UTC (rev 367) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 22:51:40 UTC (rev 368) @@ -148,15 +148,15 @@ { if (!metaAnnotationMap.containsKey(metaAnnotationType)) { - Set<Annotation> s = new HashSet<Annotation>(); + Set<Annotation> annotations = new HashSet<Annotation>(); for (Entry<Class<? extends Annotation>, Annotation> entry : annotationMap.entrySet()) { if (entry.getKey().isAnnotationPresent(metaAnnotationType)) { - s.add(entry.getValue()); + annotations.add(entry.getValue()); } } - metaAnnotationMap.put(metaAnnotationType, s); + metaAnnotationMap.put(metaAnnotationType, annotations); } return metaAnnotationMap; } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-26 22:23:32 UTC (rev 367) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedClassImpl.java 2008-11-26 22:51:40 UTC (rev 368) @@ -12,6 +12,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.Map.Entry; import org.jboss.webbeans.introspector.AnnotatedClass; import org.jboss.webbeans.introspector.AnnotatedConstructor; @@ -22,25 +23,25 @@ * Base class for implementing AnnotatedItem. * * @author pmuir - * + * */ public class AnnotatedClassImpl<T> extends AbstractAnnotatedType<T> implements AnnotatedClass<T> { - + private Class<T> clazz; private Type[] actualTypeArguments; - + private Set<AnnotatedField<Object>> fields; private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> annotatedFields; private Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> metaAnnotatedFields; - + private Set<AnnotatedMethod<Object>> methods; private Map<Class<? extends Annotation>, Set<AnnotatedMethod<Object>>> annotatedMethods; - + private Set<AnnotatedConstructor<T>> constructors; private Map<Class<? extends Annotation>, Set<AnnotatedConstructor<T>>> annotatedConstructors; private Map<List<Class<?>>, AnnotatedConstructor<T>> constructorsByArgumentMap; - + public AnnotatedClassImpl(Class<T> rawType, Type type, Annotation[] annotations) { super(buildAnnotationMap(annotations)); @@ -54,22 +55,22 @@ actualTypeArguments = new Type[0]; } } - + public AnnotatedClassImpl(Class<T> clazz) { this(clazz, clazz, clazz.getAnnotations()); } - + public Class<? extends T> getAnnotatedClass() { return clazz; } - + public Class<T> getDelegate() { return clazz; } - + public Set<AnnotatedField<Object>> getFields() { if (fields == null) @@ -78,7 +79,7 @@ } return fields; } - + public Set<AnnotatedConstructor<T>> getConstructors() { if (constructors == null) @@ -87,22 +88,22 @@ } return constructors; } - + private void initFields() { this.fields = new HashSet<AnnotatedField<Object>>(); - for(Class c=clazz;c!=Object.class;c=c.getSuperclass()) + for (Class c = clazz; c != Object.class; c = c.getSuperclass()) { - for(Field field : clazz.getDeclaredFields()) + for (Field field : clazz.getDeclaredFields()) { - if ( !field.isAccessible() ) field.setAccessible(true); + if (!field.isAccessible()) + field.setAccessible(true); fields.add(new AnnotatedFieldImpl<Object>(field, this)); } } } - public Set<AnnotatedField<Object>> getMetaAnnotatedFields( - Class<? extends Annotation> metaAnnotationType) + public Set<AnnotatedField<Object>> getMetaAnnotatedFields(Class<? extends Annotation> metaAnnotationType) { if (metaAnnotatedFields == null) { @@ -115,29 +116,25 @@ populateMetaAnnotatedFieldMap(metaAnnotationType, annotatedFields, metaAnnotatedFields); return metaAnnotatedFields.get(metaAnnotationType); } - - protected static <T extends Annotation> Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> populateMetaAnnotatedFieldMap( - Class<T> metaAnnotationType, - Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> annotatedFields, - Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> metaAnnotatedFields) + + protected static <T extends Annotation> Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> populateMetaAnnotatedFieldMap(Class<T> metaAnnotationType, Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> annotatedFields, Map<Class<? extends Annotation>, Set<AnnotatedField<Object>>> metaAnnotatedFields) { if (!metaAnnotatedFields.containsKey(metaAnnotationType)) { - Set<AnnotatedField<Object>> s = new HashSet<AnnotatedField<Object>>(); - for (Class<? extends Annotation> annotationType: annotatedFields.keySet()) + Set<AnnotatedField<Object>> fields = new HashSet<AnnotatedField<Object>>(); + for (Entry<Class<? extends Annotation>, Set<AnnotatedField<Object>>> entry : annotatedFields.entrySet()) { - if (annotationType.isAnnotationPresent(metaAnnotationType)) + if (entry.getKey().isAnnotationPresent(metaAnnotationType)) { - s.addAll(annotatedFields.get(annotationType)); + fields.addAll(entry.getValue()); } } - metaAnnotatedFields.put(metaAnnotationType, s); + metaAnnotatedFields.put(metaAnnotationType, fields); } return metaAnnotatedFields; } - public Set<AnnotatedField<Object>> getAnnotatedFields( - Class<? extends Annotation> annotationType) + public Set<AnnotatedField<Object>> getAnnotatedFields(Class<? extends Annotation> annotationType) { if (annotatedFields == null) { @@ -175,27 +172,28 @@ { return actualTypeArguments; } - + private void initMethods() { this.methods = new HashSet<AnnotatedMethod<Object>>(); - for(Class c=clazz;c!=Object.class;c=c.getSuperclass()) + for (Class c = clazz; c != Object.class; c = c.getSuperclass()) { for (Method method : clazz.getDeclaredMethods()) { - if (!method.isAccessible()) method.setAccessible(true); + if (!method.isAccessible()) + method.setAccessible(true); methods.add(new AnnotatedMethodImpl<Object>(method, this)); } } } - + public Set<AnnotatedMethod<Object>> getAnnotatedMethods(Class<? extends Annotation> annotationType) { if (annotatedMethods == null) { initAnnotatedMethods(); } - + if (!annotatedMethods.containsKey(annotationType)) { return new HashSet<AnnotatedMethod<Object>>(); @@ -225,7 +223,7 @@ } } } - + private void initConstructors() { this.constructors = new HashSet<AnnotatedConstructor<T>>(); @@ -233,19 +231,20 @@ for (Constructor<?> constructor : clazz.getDeclaredConstructors()) { AnnotatedConstructor<T> annotatedConstructor = new AnnotatedConstructorImpl<T>((Constructor<T>) constructor, this); - if (!constructor.isAccessible()) constructor.setAccessible(true); + if (!constructor.isAccessible()) + constructor.setAccessible(true); constructors.add(annotatedConstructor); constructorsByArgumentMap.put(Arrays.asList(constructor.getParameterTypes()), annotatedConstructor); } } - + public Set<AnnotatedConstructor<T>> getAnnotatedConstructors(Class<? extends Annotation> annotationType) { if (annotatedConstructors == null) { initAnnotatedConstructors(); } - + if (!annotatedConstructors.containsKey(annotationType)) { return new HashSet<AnnotatedConstructor<T>>(); @@ -275,7 +274,7 @@ } } } - + public AnnotatedConstructor<T> getConstructor(List<Class<?>> arguments) { return constructorsByArgumentMap.get(arguments);

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r367 - in ri/trunk/webbeans-ri: src/main/java/org/jboss/webbeans/bean and 2 other directories.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 17:23:32 -0500 (Wed, 26 Nov 2008) New Revision: 367 Modified: ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.core.prefs ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.ui.prefs ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ejb/EjbMetaData.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java Log: Minor stuff Modified: ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.core.prefs =================================================================== --- ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.core.prefs 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.core.prefs 2008-11-26 22:23:32 UTC (rev 367) @@ -1,5 +1,268 @@ -#Thu Nov 20 14:21:45 EST 2008 -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 -eclipse.preferences.version=1 -org.eclipse.jdt.core.compiler.source=1.5 -org.eclipse.jdt.core.compiler.compliance=1.5 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.5 +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=0 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=0 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block=next_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=next_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=next_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=next_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true +org.eclipse.jdt.core.formatter.comment.indent_root_tags=true +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false +org.eclipse.jdt.core.formatter.indentation.size=3 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.lineSplit=800 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=space +org.eclipse.jdt.core.formatter.tabulation.size=3 +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true Modified: ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.ui.prefs =================================================================== --- ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.ui.prefs 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/.settings/org.eclipse.jdt.ui.prefs 2008-11-26 22:23:32 UTC (rev 367) @@ -1,5 +1,5 @@ -#Tue Jun 24 10:21:10 BST 2008 -eclipse.preferences.version=1 -formatter_profile=_Web Beans -formatter_settings_version=11 -org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/> +#Thu Nov 20 10:11:13 EET 2008 +eclipse.preferences.version=1 +formatter_profile=_WebBeans +formatter_settings_version=11 +org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/> Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-26 22:23:32 UTC (rev 367) @@ -352,7 +352,7 @@ if (getAnnotatedItem().getMetaAnnotations(ScopeType.class).size() == 1) { this.scopeType = getAnnotatedItem().getMetaAnnotations(ScopeType.class).iterator().next().annotationType(); - log.trace("Scope " + scopeType + " specified b annotation"); + log.trace("Scope " + scopeType + " specified by annotation"); return; } } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ejb/EjbMetaData.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ejb/EjbMetaData.java 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/ejb/EjbMetaData.java 2008-11-26 22:23:32 UTC (rev 367) @@ -69,7 +69,7 @@ for (AnnotatedMethod<Object> removeMethod : type.getAnnotatedMethods(REMOVE_ANNOTATION)) { removeMethods.add(removeMethod); - if (removeMethod.getParameters().size() == 0) + if (removeMethod.getDelegate().getParameterTypes().length == 0) { noArgsRemoveMethods.add(removeMethod); } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 22:23:32 UTC (rev 367) @@ -92,15 +92,6 @@ return annotationMap; } - protected static Set<Annotation> populateAnnotationSet(Set<Annotation> annotationSet, AnnotationMap annotationMap) - { - for (Entry<Class<? extends Annotation>, Annotation> entry : annotationMap.entrySet()) - { - annotationSet.add(entry.getValue()); - } - return annotationSet; - } - protected static Object[] getParameterValues(List<AnnotatedParameter<Object>> parameters, ManagerImpl manager) { Object[] parameterValues = new Object[parameters.size()]; @@ -142,7 +133,8 @@ { if (annotationSet == null) { - annotationSet = populateAnnotationSet(new HashSet<Annotation>(), annotationMap); + annotationSet = new HashSet<Annotation>(); + annotationSet.addAll(annotationMap.values()); } return annotationSet; } @@ -159,7 +151,7 @@ Set<Annotation> s = new HashSet<Annotation>(); for (Entry<Class<? extends Annotation>, Annotation> entry : annotationMap.entrySet()) { - if (entry.getValue().annotationType().isAnnotationPresent(metaAnnotationType)) + if (entry.getKey().isAnnotationPresent(metaAnnotationType)) { s.add(entry.getValue()); } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java 2008-11-26 19:59:44 UTC (rev 366) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedMethodImpl.java 2008-11-26 22:23:32 UTC (rev 367) @@ -18,7 +18,7 @@ public class AnnotatedMethodImpl<T> extends AbstractAnnotatedMember<T, Method> implements AnnotatedMethod<T> { - private Type[] actualTypeArgements = new Type[0]; + private Type[] actualTypeArguments = new Type[0]; private Method method; @@ -36,7 +36,7 @@ this.declaringClass = declaringClass; if (method.getGenericReturnType() instanceof ParameterizedType) { - actualTypeArgements = ((ParameterizedType) method.getGenericReturnType()).getActualTypeArguments(); + actualTypeArguments = ((ParameterizedType) method.getGenericReturnType()).getActualTypeArguments(); } } @@ -57,7 +57,7 @@ public Type[] getActualTypeArguments() { - return actualTypeArgements; + return actualTypeArguments; } public List<AnnotatedParameter<Object>> getParameters()

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r366 - in ri/trunk/webbeans-ri/src: test/java/org/jboss/webbeans/test and 1 other directory.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 14:59:44 -0500 (Wed, 26 Nov 2008) New Revision: 366 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/TransactionObservationPhase.java ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewEventTest.java Log: Transactional observer only watches single phase Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java 2008-11-26 14:12:53 UTC (rev 365) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/ObserverImpl.java 2008-11-26 19:59:44 UTC (rev 366) @@ -1,13 +1,14 @@ package org.jboss.webbeans.event; import java.lang.annotation.Annotation; -import java.util.HashSet; -import java.util.Set; +import java.util.ArrayList; +import java.util.List; import javax.webbeans.AfterTransactionCompletion; import javax.webbeans.AfterTransactionFailure; import javax.webbeans.AfterTransactionSuccess; import javax.webbeans.BeforeTransactionCompletion; +import javax.webbeans.DefinitionException; import javax.webbeans.IfExists; import javax.webbeans.Observer; @@ -31,7 +32,7 @@ private EventBean<T> eventBean; private final AnnotatedMethod<Object> observerMethod; private final Class<T> eventType; - private Set<TransactionObservationPhase> transactionObservationPhases; + private TransactionObservationPhase transactionObservationPhase; private boolean conditional; private ManagerImpl manager; @@ -53,29 +54,41 @@ this.eventBean = eventBean; this.observerMethod = observer; this.eventType = eventType; - initTransactionObservationPhases(); + initTransactionObservationPhase(); conditional = !observerMethod.getAnnotatedParameters(IfExists.class).isEmpty(); } - private void initTransactionObservationPhases() + private void initTransactionObservationPhase() { - transactionObservationPhases = new HashSet<TransactionObservationPhase>(); + List<TransactionObservationPhase> observationPhases = new ArrayList<TransactionObservationPhase>(); if (observerMethod.getAnnotatedParameters(BeforeTransactionCompletion.class).isEmpty()) { - transactionObservationPhases.add(TransactionObservationPhase.BEFORE_COMPLETION); + observationPhases.add(TransactionObservationPhase.BEFORE_COMPLETION); } if (observerMethod.getAnnotatedParameters(AfterTransactionCompletion.class).isEmpty()) { - transactionObservationPhases.add(TransactionObservationPhase.AFTER_COMPLETION); + observationPhases.add(TransactionObservationPhase.AFTER_COMPLETION); } if (observerMethod.getAnnotatedParameters(AfterTransactionFailure.class).isEmpty()) { - transactionObservationPhases.add(TransactionObservationPhase.AFTER_FAILURE); + observationPhases.add(TransactionObservationPhase.AFTER_FAILURE); } if (observerMethod.getAnnotatedParameters(AfterTransactionSuccess.class).isEmpty()) { - transactionObservationPhases.add(TransactionObservationPhase.AFTER_SUCCESS); + observationPhases.add(TransactionObservationPhase.AFTER_SUCCESS); } + if (observationPhases.size() > 1) + { + throw new DefinitionException("Transactional observers can only observe on a single phase"); + } + else if (observationPhases.size() == 1) + { + transactionObservationPhase = observationPhases.iterator().next(); + } + else + { + transactionObservationPhase = TransactionObservationPhase.NONE; + } } /* @@ -122,7 +135,7 @@ public boolean isTransactional() { - return !transactionObservationPhases.isEmpty(); + return !TransactionObservationPhase.NONE.equals(transactionObservationPhase); } public boolean isConditional() @@ -130,9 +143,9 @@ return conditional; } - public boolean isInterestedInTransactionPhase(TransactionObservationPhase transactionObservationPhase) + public boolean isInterestedInTransactionPhase(TransactionObservationPhase currentPhase) { - return transactionObservationPhases.contains(transactionObservationPhase); + return transactionObservationPhase.equals(currentPhase); } } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/TransactionObservationPhase.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/TransactionObservationPhase.java 2008-11-26 14:12:53 UTC (rev 365) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/event/TransactionObservationPhase.java 2008-11-26 19:59:44 UTC (rev 366) @@ -2,5 +2,5 @@ public enum TransactionObservationPhase { - BEFORE_COMPLETION, AFTER_COMPLETION, AFTER_FAILURE, AFTER_SUCCESS + NONE, BEFORE_COMPLETION, AFTER_COMPLETION, AFTER_FAILURE, AFTER_SUCCESS } Modified: ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewEventTest.java =================================================================== --- ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewEventTest.java 2008-11-26 14:12:53 UTC (rev 365) +++ ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewEventTest.java 2008-11-26 19:59:44 UTC (rev 366) @@ -209,6 +209,13 @@ } @Test(groups={"stub", "events"}) + @SpecAssertion(section="7.1") + public void testTransactionalObserverCanOnlyObserveSinglePhase() + { + assert false; + } + + @Test(groups={"stub", "events"}) @SpecAssertion(section="7.5.6") public void testTransactionalObserverNotifiedImmediatelyWhenNoTransactionInProgress() {

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r365 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/transaction.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 09:12:53 -0500 (Wed, 26 Nov 2008) New Revision: 365 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/transaction/TransactionListener.java Log: minor: ArrayList -> CopyOnWriteArrayList in TransactionListener Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/transaction/TransactionListener.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/transaction/TransactionListener.java 2008-11-26 12:47:44 UTC (rev 364) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/transaction/TransactionListener.java 2008-11-26 14:12:53 UTC (rev 365) @@ -1,8 +1,8 @@ package org.jboss.webbeans.transaction; import java.rmi.RemoteException; -import java.util.ArrayList; import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; import javax.ejb.EJBException; import javax.ejb.Remove; @@ -20,7 +20,7 @@ public class TransactionListener implements LocalTransactionListener, SessionSynchronization { - private List<Synchronization> synchronizations = new ArrayList<Synchronization>(); + private List<Synchronization> synchronizations = new CopyOnWriteArrayList<Synchronization>(); public void afterBegin() throws EJBException, RemoteException {

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r364 - ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/servlet.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 07:47:44 -0500 (Wed, 26 Nov 2008) New Revision: 364 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/servlet/WebBeansFilter.java Log: minor: don't handle contexts directly Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/servlet/WebBeansFilter.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/servlet/WebBeansFilter.java 2008-11-26 07:10:49 UTC (rev 363) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/servlet/WebBeansFilter.java 2008-11-26 12:47:44 UTC (rev 364) @@ -8,45 +8,34 @@ import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; -import javax.webbeans.manager.Manager; +import javax.servlet.http.HttpServletRequest; -import org.jboss.webbeans.contexts.AbstractContext; -import org.jboss.webbeans.contexts.RequestContext; - - /** * * @author Shane Bryzak - * + * */ public class WebBeansFilter implements Filter { - private Manager container; - - public void init(FilterConfig filterConfig) throws ServletException + public void init(FilterConfig filterConfig) throws ServletException { - + } - public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) - throws IOException, ServletException + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { - AbstractContext requestContext = new RequestContext(); - try { - container.addContext(requestContext); - + ServletLifecycle.beginRequest((HttpServletRequest) request); chain.doFilter(request, response); } finally { - requestContext.destroy(container); - } + ServletLifecycle.endRequest((HttpServletRequest) request); + } } - public void destroy() + public void destroy() { - } }

15 years, 5 months

1
0
0 / 0

[webbeans-commits] Webbeans SVN: r363 - in ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans: introspector and 1 other directories.

by webbeans-commits＠lists.jboss.org

Author: nickarls Date: 2008-11-26 02:10:49 -0500 (Wed, 26 Nov 2008) New Revision: 363 Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java Log: Forwarding maps AnnotationMap and MetaAnnotationMap Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/AbstractBean.java 2008-11-26 07:10:49 UTC (rev 363) @@ -23,7 +23,6 @@ import java.util.Arrays; import java.util.HashSet; import java.util.List; -import java.util.Map; import java.util.Set; import javax.webbeans.BindingType; @@ -44,6 +43,7 @@ import org.jboss.webbeans.introspector.AnnotatedItem; import org.jboss.webbeans.introspector.AnnotatedMethod; import org.jboss.webbeans.introspector.AnnotatedParameter; +import org.jboss.webbeans.introspector.jlr.AbstractAnnotatedItem.AnnotationMap; import org.jboss.webbeans.log.LogProvider; import org.jboss.webbeans.log.Logging; import org.jboss.webbeans.util.Reflections; @@ -73,7 +73,7 @@ * @param possibleDeploymentTypes The possible deployment types * @return The deployment type */ - public static Class<? extends Annotation> getDeploymentType(List<Class<? extends Annotation>> enabledDeploymentTypes, Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes) + public static Class<? extends Annotation> getDeploymentType(List<Class<? extends Annotation>> enabledDeploymentTypes, AnnotationMap possibleDeploymentTypes) { for (int i = (enabledDeploymentTypes.size() - 1); i > 0; i--) { Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/bean/MergedStereotypes.java 2008-11-26 07:10:49 UTC (rev 363) @@ -18,13 +18,12 @@ package org.jboss.webbeans.bean; import java.lang.annotation.Annotation; -import java.util.HashMap; import java.util.HashSet; -import java.util.Map; import java.util.Set; import java.util.Map.Entry; import org.jboss.webbeans.ManagerImpl; +import org.jboss.webbeans.introspector.jlr.AbstractAnnotatedItem.AnnotationMap; import org.jboss.webbeans.model.StereotypeModel; /** @@ -35,7 +34,7 @@ */ public class MergedStereotypes<T, E> { - private Map<Class<? extends Annotation>, Annotation> possibleDeploymentTypes; + private AnnotationMap possibleDeploymentTypes; private Set<Annotation> possibleScopeTypes; private boolean beanNameDefaulted; private Set<Class<?>> requiredTypes; @@ -49,7 +48,7 @@ */ public MergedStereotypes(Set<Annotation> stereotypeAnnotations, ManagerImpl manager) { - possibleDeploymentTypes = new HashMap<Class<? extends Annotation>, Annotation>(); + possibleDeploymentTypes = new AnnotationMap(); possibleScopeTypes = new HashSet<Annotation>(); requiredTypes = new HashSet<Class<?>>(); supportedScopes = new HashSet<Class<? extends Annotation>>(); @@ -94,7 +93,7 @@ * * @return The deployment types */ - public Map<Class<? extends Annotation>, Annotation> getPossibleDeploymentTypes() + public AnnotationMap getPossibleDeploymentTypes() { return possibleDeploymentTypes; } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/AnnotatedItem.java 2008-11-26 07:10:49 UTC (rev 363) @@ -30,7 +30,6 @@ */ public interface AnnotatedItem<T, S> { - /** * Gets all annotations on the item * Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedItem.java 2008-11-26 07:10:49 UTC (rev 363) @@ -21,18 +21,54 @@ import org.jboss.webbeans.util.Reflections; import org.jboss.webbeans.util.Types; +import com.google.common.collect.ForwardingMap; + public abstract class AbstractAnnotatedItem<T, S> implements AnnotatedItem<T, S> { - private static final Annotation[] DEFAULT_BINDING_ARRAY = {new CurrentAnnotationLiteral()}; + public static class AnnotationMap extends ForwardingMap<Class<? extends Annotation>, Annotation> + { + private Map<Class<? extends Annotation>, Annotation> delegate; + + public AnnotationMap() + { + delegate = new HashMap<Class<? extends Annotation>, Annotation>(); + } + + @Override + protected Map<Class<? extends Annotation>, Annotation> delegate() + { + return delegate; + } + + } + + public static class MetaAnnotationMap extends ForwardingMap<Class<? extends Annotation>, Set<Annotation>> + { + private Map<Class<? extends Annotation>, Set<Annotation>> delegate; + + public MetaAnnotationMap() + { + delegate = new HashMap<Class<? extends Annotation>, Set<Annotation>>(); + } + + @Override + protected Map<Class<? extends Annotation>, Set<Annotation>> delegate() + { + return delegate; + } + + } + + private static final Annotation[] DEFAULT_BINDING_ARRAY = { new CurrentAnnotationLiteral() }; private static final Set<Annotation> DEFAULT_BINDING = new HashSet<Annotation>(Arrays.asList(DEFAULT_BINDING_ARRAY)); - - private Map<Class<? extends Annotation>, Annotation> annotationMap; - private Map<Class<? extends Annotation>, Set<Annotation>> metaAnnotationMap; + + private AnnotationMap annotationMap; + private MetaAnnotationMap metaAnnotationMap; private Set<Annotation> annotationSet; private Annotation[] annotationArray; - - public AbstractAnnotatedItem(Map<Class<? extends Annotation>, Annotation> annotationMap) + + public AbstractAnnotatedItem(AnnotationMap annotationMap) { if (annotationMap == null) { @@ -40,15 +76,15 @@ } this.annotationMap = annotationMap; } - - protected static Map<Class<? extends Annotation>, Annotation> buildAnnotationMap(AnnotatedElement element) + + protected static AnnotationMap buildAnnotationMap(AnnotatedElement element) { return buildAnnotationMap(element.getAnnotations()); } - - protected static Map<Class<? extends Annotation>, Annotation> buildAnnotationMap(Annotation[] annotations) + + protected static AnnotationMap buildAnnotationMap(Annotation[] annotations) { - Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>(); + AnnotationMap annotationMap = new AnnotationMap(); for (Annotation annotation : annotations) { annotationMap.put(annotation.annotationType(), annotation); @@ -56,7 +92,7 @@ return annotationMap; } - protected static Set<Annotation> populateAnnotationSet(Set<Annotation> annotationSet, Map<Class<? extends Annotation>, Annotation> annotationMap) + protected static Set<Annotation> populateAnnotationSet(Set<Annotation> annotationSet, AnnotationMap annotationMap) { for (Entry<Class<? extends Annotation>, Annotation> entry : annotationMap.entrySet()) { @@ -64,11 +100,11 @@ } return annotationSet; } - + protected static Object[] getParameterValues(List<AnnotatedParameter<Object>> parameters, ManagerImpl manager) { Object[] parameterValues = new Object[parameters.size()]; - Iterator<AnnotatedParameter<Object>> iterator = parameters.iterator(); + Iterator<AnnotatedParameter<Object>> iterator = parameters.iterator(); for (int i = 0; i < parameterValues.length; i++) { parameterValues[i] = iterator.next().getValue(manager); @@ -76,6 +112,7 @@ return parameterValues; } + @SuppressWarnings("unchecked") public <A extends Annotation> A getAnnotation(Class<? extends A> annotationType) { return (A) annotationMap.get(annotationType); @@ -85,12 +122,12 @@ { if (metaAnnotationMap == null) { - metaAnnotationMap = new HashMap<Class<? extends Annotation>, Set<Annotation>>(); + metaAnnotationMap = new MetaAnnotationMap(); } metaAnnotationMap = populateMetaAnnotationMap(metaAnnotationType, metaAnnotationMap, annotationMap); return metaAnnotationMap.get(metaAnnotationType); } - + public Annotation[] getMetaAnnotationsAsArray(Class<? extends Annotation> metaAnnotationType) { if (annotationArray == null) @@ -115,10 +152,7 @@ return annotationMap.containsKey(annotatedType); } - protected static <A extends Annotation> Map<Class<? extends Annotation>, Set<Annotation>> populateMetaAnnotationMap( - Class<A> metaAnnotationType, Map<Class<? extends Annotation>, - Set<Annotation>> metaAnnotationMap, - Map<Class<? extends Annotation>, Annotation> annotationMap) + protected static <A extends Annotation> MetaAnnotationMap populateMetaAnnotationMap(Class<A> metaAnnotationType, MetaAnnotationMap metaAnnotationMap, AnnotationMap annotationMap) { if (!metaAnnotationMap.containsKey(metaAnnotationType)) { @@ -135,11 +169,11 @@ return metaAnnotationMap; } - protected Map<Class<? extends Annotation>, Annotation> getAnnotationMap() + protected AnnotationMap getAnnotationMap() { return annotationMap; } - + @Override public boolean equals(Object other) { @@ -150,12 +184,12 @@ } return false; } - + public boolean isAssignableFrom(AnnotatedItem<?, ?> that) { return isAssignableFrom(that.getType(), that.getActualTypeArguments()); } - + public boolean isAssignableFrom(Set<Class<?>> types) { for (Class<?> type : types) @@ -167,18 +201,18 @@ } return false; } - + private boolean isAssignableFrom(Class<?> type, Type[] actualTypeArguments) { return Types.boxedType(getType()).isAssignableFrom(Types.boxedType(type)) && Arrays.equals(getActualTypeArguments(), actualTypeArguments); } - + @Override public int hashCode() { return getType().hashCode(); } - + @Override public String toString() { @@ -199,7 +233,7 @@ string += getAnnotations(); return string; } - + public Set<Annotation> getBindingTypes() { if (getMetaAnnotations(BindingType.class).size() > 0) @@ -211,7 +245,7 @@ return DEFAULT_BINDING; } } - + public Annotation[] getBindingTypesAsArray() { if (getMetaAnnotationsAsArray(BindingType.class).length > 0) @@ -223,7 +257,7 @@ return DEFAULT_BINDING_ARRAY; } } - + public boolean isProxyable() { if (Reflections.getConstructor(getType()) == null) Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedMember.java 2008-11-26 07:10:49 UTC (rev 363) @@ -1,8 +1,6 @@ package org.jboss.webbeans.introspector.jlr; -import java.lang.annotation.Annotation; import java.lang.reflect.Member; -import java.util.Map; import javax.webbeans.BindingType; @@ -14,7 +12,7 @@ private String name; - public AbstractAnnotatedMember(Map<Class<? extends Annotation>, Annotation> annotationMap) + public AbstractAnnotatedMember(AnnotationMap annotationMap) { super(annotationMap); } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AbstractAnnotatedType.java 2008-11-26 07:10:49 UTC (rev 363) @@ -1,8 +1,5 @@ package org.jboss.webbeans.introspector.jlr; -import java.lang.annotation.Annotation; -import java.util.Map; - import org.jboss.webbeans.introspector.AnnotatedClass; import org.jboss.webbeans.util.Reflections; @@ -11,7 +8,7 @@ private AnnotatedClass<Object> superclass; - public AbstractAnnotatedType(Map<Class<? extends Annotation>, Annotation> annotationMap) + public AbstractAnnotatedType(AnnotationMap annotationMap) { super(annotationMap); } Modified: ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java =================================================================== --- ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java 2008-11-25 19:47:31 UTC (rev 362) +++ ri/trunk/webbeans-ri/src/main/java/org/jboss/webbeans/introspector/jlr/AnnotatedItemImpl.java 2008-11-26 07:10:49 UTC (rev 363) @@ -3,7 +3,6 @@ import java.lang.annotation.Annotation; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; -import java.util.Map; import javax.webbeans.TypeLiteral; @@ -14,18 +13,18 @@ private Class<T> type; private Annotation[] actualAnnotations; - private AnnotatedItemImpl(Map<Class<? extends Annotation>, Annotation> annotationMap) + private AnnotatedItemImpl(AnnotationMap annotationMap) { super(annotationMap); } - private AnnotatedItemImpl(Map<Class<? extends Annotation>, Annotation> annotationMap, Class<T> type) + private AnnotatedItemImpl(AnnotationMap annotationMap, Class<T> type) { super(annotationMap); this.type = type; } - private AnnotatedItemImpl(Map<Class<? extends Annotation>, Annotation> annotationMap, TypeLiteral<T> apiType) + private AnnotatedItemImpl(AnnotationMap annotationMap, TypeLiteral<T> apiType) { super(annotationMap); this.type = apiType.getRawType(); @@ -35,7 +34,7 @@ } } - private AnnotatedItemImpl(Map<Class<? extends Annotation>, Annotation> annotationMap, Class<T> type, Type[] actualTypeArguments) + private AnnotatedItemImpl(AnnotationMap annotationMap, Class<T> type, Type[] actualTypeArguments) { this(annotationMap, type); this.actualTypeArguments = actualTypeArguments;

15 years, 5 months

1
0
0 / 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

weld-commits November 2008