[aries-cdi] 02/19: implement annotated

[ro...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

rotty3000 pushed a commit to branch rotty3000/cdi-spi
in repository https://gitbox.apache.org/repos/asf/aries-cdi.git

commit c77abe2dea3fb4a719ff33802513fd89b0dc16b5
Author: Raymond Augé <ro...@apache.org>
AuthorDate: Wed Nov 20 14:05:30 2019 -0500

    implement annotated
    
    Signed-off-by: Raymond Augé <ro...@apache.org>
---
 .../internal/annotated/AnnotatedCallableImpl.java  | 45 ++++++++++++++
 .../annotated/AnnotatedConstructorImpl.java        | 34 +++++++++++
 .../internal/annotated/AnnotatedFieldImpl.java     | 33 ++++++++++
 .../internal/annotated/AnnotatedImpl.java          | 71 ++++++++++++++++++++++
 .../internal/annotated/AnnotatedMemberImpl.java    | 52 ++++++++++++++++
 .../internal/annotated/AnnotatedMethodImpl.java    | 33 ++++++++++
 .../internal/annotated/AnnotatedParameterImpl.java | 68 +++++++++++++++++++++
 .../internal/annotated/AnnotatedTypeImpl.java      | 66 ++++++++++++++++++++
 8 files changed, 402 insertions(+)

diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedCallableImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedCallableImpl.java
new file mode 100644
index 0000000..82fb02f
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedCallableImpl.java
@@ -0,0 +1,45 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import javax.enterprise.inject.spi.AnnotatedCallable;
+import javax.enterprise.inject.spi.AnnotatedParameter;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedCallableImpl<X> extends AnnotatedMemberImpl<X> implements AnnotatedCallable<X> {
+
+	private final List<AnnotatedParameter<X>> _parameters;
+
+	public AnnotatedCallableImpl(final Type baseType, final AnnotatedElement annotatedElement, final AnnotatedType<X> declaringType, final Executable executable) {
+		super(baseType, annotatedElement, declaringType, executable);
+
+		_parameters = IntStream.range(0, executable.getParameterCount())
+			.mapToObj(i -> new AnnotatedParameterImpl<X>(executable.getAnnotatedParameterTypes()[i].getType(), executable.getParameterAnnotations()[i], this, i))
+			.collect(Collectors.toList());
+	}
+
+	@Override
+	public List<AnnotatedParameter<X>> getParameters() {
+		return _parameters;
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedConstructorImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedConstructorImpl.java
new file mode 100644
index 0000000..90924cc
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedConstructorImpl.java
@@ -0,0 +1,34 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.reflect.Constructor;
+
+import javax.enterprise.inject.spi.AnnotatedConstructor;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedConstructorImpl<X> extends AnnotatedCallableImpl<X> implements AnnotatedConstructor<X> {
+
+	public AnnotatedConstructorImpl(final AnnotatedType<X> declaringType, final Constructor<X> constructor) {
+		super(constructor.getAnnotatedReturnType().getType(), constructor, declaringType, constructor);
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Constructor<X> getJavaMember() {
+		return (Constructor<X>)super.getJavaMember();
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedFieldImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedFieldImpl.java
new file mode 100644
index 0000000..73099b7
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedFieldImpl.java
@@ -0,0 +1,33 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.reflect.Field;
+
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedFieldImpl<X> extends AnnotatedMemberImpl<X> implements AnnotatedField<X> {
+
+	public AnnotatedFieldImpl(final AnnotatedType<X> declaringType, final Field field) {
+		super(field.getGenericType(), field, declaringType, field);
+	}
+
+	@Override
+	public Field getJavaMember() {
+		return (Field)super.getJavaMember();
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedImpl.java
new file mode 100644
index 0000000..62d54d5
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedImpl.java
@@ -0,0 +1,71 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import static java.util.stream.Collectors.*;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Set;
+
+import javax.enterprise.inject.spi.Annotated;
+
+import org.apache.aries.cdi.container.internal.util.Reflection;
+
+public class AnnotatedImpl<X> implements Annotated {
+
+	private final Type _baseType;
+	private final AnnotatedElement _annotatedElement;
+	private final Set<Type> _typeClosure;
+
+	public AnnotatedImpl(final Type baseType, final AnnotatedElement annotatedElement) {
+		_baseType = baseType;
+		_annotatedElement = annotatedElement;
+		_typeClosure = Reflection.getTypes(_baseType);
+	}
+
+	@Override
+	public Type getBaseType() {
+		return _baseType;
+	}
+
+	@Override
+	public Set<Type> getTypeClosure() {
+		return _typeClosure;
+	}
+
+	@Override
+	public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+		return _annotatedElement.getAnnotation(annotationType);
+	}
+
+	@Override
+	public <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) {
+		return Arrays.stream(_annotatedElement.getAnnotationsByType(annotationType)).collect(toSet());
+	}
+
+	@Override
+	public Set<Annotation> getAnnotations() {
+		return Arrays.stream(_annotatedElement.getAnnotations()).collect(toSet());
+	}
+
+	@Override
+	public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
+		return _annotatedElement.isAnnotationPresent(annotationType);
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMemberImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMemberImpl.java
new file mode 100644
index 0000000..e621667
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMemberImpl.java
@@ -0,0 +1,52 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+
+import javax.enterprise.inject.spi.AnnotatedMember;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedMemberImpl<X> extends AnnotatedImpl<X> implements AnnotatedMember<X> {
+
+	private final Member _member;
+	private final AnnotatedType<X> _declaringType;
+
+	public AnnotatedMemberImpl(final Type baseType, final AnnotatedElement annotatedElement, final AnnotatedType<X> declaringType, final Member member) {
+		super(baseType, annotatedElement);
+
+		_declaringType = declaringType;
+		_member = member;
+	}
+
+	@Override
+	public Member getJavaMember() {
+		return _member;
+	}
+
+	@Override
+	public boolean isStatic() {
+		return Modifier.isStatic(_member.getModifiers());
+	}
+
+	@Override
+	public AnnotatedType<X> getDeclaringType() {
+		return _declaringType;
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMethodImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMethodImpl.java
new file mode 100644
index 0000000..ddde40b
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedMethodImpl.java
@@ -0,0 +1,33 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.reflect.Method;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedMethodImpl<X> extends AnnotatedCallableImpl<X> implements AnnotatedMethod<X> {
+
+	public AnnotatedMethodImpl(final AnnotatedType<X> declaringType, final Method method) {
+		super(method.getGenericReturnType(), method, declaringType, method);
+	}
+
+	@Override
+	public Method getJavaMember() {
+		return (Method)super.getJavaMember();
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedParameterImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedParameterImpl.java
new file mode 100644
index 0000000..a4388b1
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedParameterImpl.java
@@ -0,0 +1,68 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+
+import javax.enterprise.inject.spi.AnnotatedCallable;
+import javax.enterprise.inject.spi.AnnotatedParameter;
+
+public class AnnotatedParameterImpl<X> extends AnnotatedImpl<X> implements AnnotatedParameter<X> {
+
+	private final AnnotatedCallable<X> _annotatedCallable;
+	private final int _position;
+
+	public AnnotatedParameterImpl(final Type baseType, final Annotation[] parameterAnnotations, final AnnotatedCallable<X> annotatedCallable, final int position) {
+		super(baseType, newAnnotatedElement(parameterAnnotations));
+
+		_annotatedCallable = annotatedCallable;
+		_position = position;
+	}
+
+	@Override
+	public int getPosition() {
+		return _position;
+	}
+
+	@Override
+	public AnnotatedCallable<X> getDeclaringCallable() {
+		return _annotatedCallable;
+	}
+
+	private static AnnotatedElement newAnnotatedElement(final Annotation[] parameterAnnotations) {
+		return new AnnotatedElement() {
+
+			@Override
+			public Annotation[] getDeclaredAnnotations() {
+				return parameterAnnotations;
+			}
+
+			@Override
+			public Annotation[] getAnnotations() {
+				return parameterAnnotations;
+			}
+
+			@Override
+			public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+				return Arrays.stream(parameterAnnotations).filter(annotationType::isInstance).map(annotationType::cast).findFirst().orElse(null);
+			}
+
+		};
+	}
+
+}
diff --git a/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedTypeImpl.java b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedTypeImpl.java
new file mode 100644
index 0000000..e5de340
--- /dev/null
+++ b/cdi-extender/src/main/java/org/apache/aries/cdi/container/internal/annotated/AnnotatedTypeImpl.java
@@ -0,0 +1,66 @@
+/**
+ * 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.apache.aries.cdi.container.internal.annotated;
+
+import static java.util.stream.Collectors.*;
+import static org.apache.aries.cdi.container.internal.util.Reflection.*;
+
+import java.lang.reflect.Constructor;
+import java.util.Set;
+
+import javax.enterprise.inject.spi.AnnotatedConstructor;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedType;
+
+public class AnnotatedTypeImpl<X> extends AnnotatedImpl<X> implements AnnotatedType<X> {
+
+	private final Class<X> _declaringClass;
+	private final Set<AnnotatedConstructor<X>> _constructors;
+	private final Set<AnnotatedField<? super X>> _fields;
+	private final Set<AnnotatedMethod<? super X>> _methods;
+
+	@SuppressWarnings("unchecked")
+	public AnnotatedTypeImpl(final Class<X> declaringClass) {
+		super(declaringClass, declaringClass);
+
+		_declaringClass = declaringClass;
+
+		_constructors = allConstructors(_declaringClass).map(c -> new AnnotatedConstructorImpl<>(this, (Constructor<X>)c)).collect(toSet());
+		_fields = allFields(_declaringClass).map(f -> new AnnotatedFieldImpl<>(this, f)).collect(toSet());
+		_methods = allMethods(_declaringClass).map(m -> new AnnotatedMethodImpl<>(this, m)).collect(toSet());
+	}
+
+	@Override
+	public Class<X> getJavaClass() {
+		return _declaringClass;
+	}
+
+	@Override
+	public Set<AnnotatedConstructor<X>> getConstructors() {
+		return _constructors;
+	}
+
+	@Override
+	public Set<AnnotatedMethod<? super X>> getMethods() {
+		return _methods;
+	}
+
+	@Override
+	public Set<AnnotatedField<? super X>> getFields() {
+		return _fields;
+	}
+
+}