The default implementation of this method extracts this information from an invocation of the {@link
+ * #eventDependency()} method ({@linkplain #eventDependency() q.v.}).
+ *
+ * @return a non-{@code null}, determinate {@link AttributedType}
+ *
+ * @exception NullPointerException if the default implementation of this method receives a {@code null} return value
+ * from an invocation of the {@link #eventDependency()} method
+ *
+ * @see #eventDependency()
+ */
+ @Override // AttributedTypedAggregate (AttributedTyped)
+ public default AttributedType attributedType() {
+ return this.eventDependency().attributedType();
+ }
+
+ /**
+ * Returns a non-{@code null}, determinate, immutable {@link SequencedSet} of {@link AttributedElement}s representing
+ * dependencies this {@link EventListener} has that must be resolved before any invocation of the {@link
+ * #eventReceived(Object, ReferencesSelector)} method may properly occur.
+ *
+ *
Implementations of this method must not include a result of any invocation of the {@link #eventDependency()}
+ * method as an element of the return value.
+ *
+ *
The default implementation of this method returns an {@linkplain SequencedSet#isEmpty() empty} {@link
+ * SequencedSet}. Overrides are expected.
+ *
+ * @return a non-{@code null}, determinate, immutable {@link SequencedSet} of {@link AttributedElement}s
+ *
+ * @see #eventReceived(Object, ReferencesSelector)
+ *
+ * @see #eventDependency()
+ */
+ // Returns dependencies that are not the event dependency. These are resolved by the system. Think of an observer
+ // method with an observed parameter and other parameters. The other parameters are these dependencies.
+ @Override // AttributedTypedAggregate (Aggregate)
+ public default SequencedSet dependencies() {
+ return Aggregate.super.dependencies();
+ }
+
+ /**
+ * Returns a non-{@code null}, determinate {@link AttributedElement} representing the program element for which an
+ * event is destined.
+ *
+ *
The result of an invocation of this method must not appear as an element of the return value of an invocation of
+ * the {@link #dependencies()} method.
+ *
+ *
Note that the default implementation of the {@link #attributedType()} method calls this method and requires it
+ * to return a non-{@code null} value.
Note: Two {@link TypeMirror} instances may represent the {@linkplain
+ * org.microbean.construct.Domain#sameType(TypeMirror, TypeMirror) same type} while not being {@linkplain
+ * TypeMirror#equals(Object) equal to} one another. {@link java.util.List} implementations such as this one that contain
+ * {@link TypeMirror} elements may also represent the same types without being equal to each other.
+ *
+ * @author Laird Nelson
+ */
+public final class EventTypeList extends AbstractList {
+
+ static final EventTypeList EMPTY_LIST = new EventTypeList(SupertypeList.of());
+
+ private final SupertypeList types;
+
+ EventTypeList(final SupertypeList types) {
+ super();
+ this.types = requireNonNull(types, "types");
+ }
+
+ @Override // AbstractList
+ public final TypeMirror get(final int index) {
+ return this.types.get(index);
+ }
+
+ @Override // AbstractList
+ public final int size() {
+ return this.types.size();
+ }
+
+}
diff --git a/src/main/java/org/microbean/event/EventTypeMatcher.java b/src/main/java/org/microbean/event/EventTypeMatcher.java
index 626d420..dc5487b 100644
--- a/src/main/java/org/microbean/event/EventTypeMatcher.java
+++ b/src/main/java/org/microbean/event/EventTypeMatcher.java
@@ -98,7 +98,7 @@ public final boolean test(final TypeMirror receiver, final TypeMirror payload) {
// Interestingly array types are never discussed explicitly in the specification's sections on observer
// resolution, but clearly they must be possible.
case ARRAY -> switch (payload.getKind()) {
- case ARRAY -> this.identical(this.domain().elementType(receiver), this.domain().elementType(payload)); // never spelled out in the spec but inferred
+ case ARRAY -> this.test(((ArrayType)receiver).getComponentType(), ((ArrayType)payload).getComponentType()); // never spelled out in the spec but inferred
case DECLARED -> false;
default -> throw illegalPayload(payload);
};
@@ -262,7 +262,7 @@ private final boolean assignable(final DeclaredType receiver, final DeclaredType
}; // end switch(receiver); end parameterizedPayload case
case DeclaredType nonGenericOrRawPayload -> switch (receiver) {
- // "A [non-generic or] raw event type [nonGenericOrRawayload] is considered assignable..."
+ // "A [non-generic or] raw event type [nonGenericOrRawPayload] is considered assignable..."
case DeclaredType parameterizedReceiver when this.domain().parameterized(receiver) -> {
// "...to a parameterized observed event type [parameterizedReceiver] if the[ir] [non-generic classes or] raw
diff --git a/src/main/java/org/microbean/event/EventTypes.java b/src/main/java/org/microbean/event/EventTypes.java
index ecafb3f..cee906e 100644
--- a/src/main/java/org/microbean/event/EventTypes.java
+++ b/src/main/java/org/microbean/event/EventTypes.java
@@ -15,31 +15,51 @@
import java.lang.System.Logger;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import javax.lang.model.element.Element;
-import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.WildcardType;
+import org.microbean.assign.SupertypeList;
import org.microbean.assign.Types;
import org.microbean.construct.Domain;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+
import static java.lang.System.Logger.Level.WARNING;
+import static java.util.HashMap.newHashMap;
+
+import static java.util.Objects.requireNonNull;
+
+import static javax.lang.model.type.TypeKind.ARRAY;
+import static javax.lang.model.type.TypeKind.BOOLEAN;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.TYPEVAR;
+import static javax.lang.model.type.TypeKind.VOID;
+import static javax.lang.model.type.TypeKind.WILDCARD;
+
/**
* A utility for working with event types.
*
* @author Laird Nelson
*
- * @see #eventTypes(TypeMirror)
+ * @see #eventTypes(TypeMirror, Object)
*
* @see #legalEventType(TypeMirror)
*/
@@ -77,39 +97,312 @@ public EventTypes(final Domain domain) {
/**
- * Returns an immutable {@link List} of {@linkplain #legalEventType(TypeMirror) legal event types} that the supplied
+ * Returns an {@link EventTypeList} of {@linkplain #legalEventType(TypeMirror) legal event types} that the supplied
* {@link TypeMirror} bears.
*
- *
The returned {@link List} may be empty.
+ *
The returned {@link EventTypeList} may be {@linkplain EventTypeList#isEmpty() empty}.
*
- * @param t a {@link TypeMirror}; must not be {@code null}
- *
- * @return an immutable {@link List} of {@linkplain #legalEventType(TypeMirror) legal event types} that the supplied
- * {@link TypeMirror} bears; never {@code null}
+ * @param typeArgumentSource a {@link TypeMirror} used for {@index "event type argument inference"}; must
+ * not be {@code null}; must {@linkplain TypeMirror#getKind() have a kind} of either {@link TypeKind#ARRAY} or {@link
+ * TypeKind#DECLARED}
*
- * @exception NullPointerException if {@code t} is {@code null}
+ * @param event the event object whose event types should be returned; must not be {@code null}
*
- * @microbean.nullability This method never returns {@code null}.
+ * @return an {@link EventTypeList}; never {@code null}
*
- * @microbean.idempotency This method is idempotent and returns determinate values.
+ * @exception NullPointerException if any argument is {@code null}
*
- * @microbean.threadsafety This method is safe for concurrent use by multiple threads.
+ * @exception IllegalArgumentException if {@code typeArgumentSource} is not legal
*/
- public final List eventTypes(final TypeMirror t) {
- // https://jakarta.ee/specifications/cdi/4.0/jakarta-cdi-spec-4.0#event_types_and_qualifier_types
- if (t.getKind() == TypeKind.DECLARED) {
- final Element e = ((DeclaredType)t).asElement();
- if (e.getKind().isInterface() || !e.getKind().isClass() || e.getModifiers().contains(Modifier.ABSTRACT)) {
- // "An event object is an instance of a concrete Java class...."
- if (LOGGER.isLoggable(WARNING)) {
- LOGGER.log(WARNING, t + " is an illegal event type");
+ public final EventTypeList eventTypes(final TypeMirror typeArgumentSource, final Object event) {
+ return new EventTypeList(this.supertypes(this.eventType(typeArgumentSource, event.getClass()), EventTypes::legalEventType));
+ }
+
+ // This MUST NOT become public.
+ final TypeMirror eventType(final TypeMirror typeArgumentSource, final Class eventClass) {
+ if (eventClass == void.class) {
+ // Optimization: void.class is never the answer.
+ throw new IllegalArgumentException("eventClass: " + eventClass);
+ }
+ if (eventClass.isPrimitive()) {
+ // Optimization: if it is primitive, there's no further work to be done.
+ return this.domain().primitiveType(eventClass.getCanonicalName());
+ }
+ int dimensions = 0;
+ Class c = eventClass;
+ while (c.isArray()) {
+ c = c.getComponentType();
+ ++dimensions;
+ }
+ final Domain d = this.domain();
+ TypeMirror t =
+ this.eventType(typeArgumentSource,
+ c.isPrimitive() ? d.primitiveType(c.getCanonicalName()) : d.declaredType(d.typeElement(c.getCanonicalName())));
+ for (int i = 0; i < dimensions; i++) {
+ t = d.arrayTypeOf(t);
+ }
+ return t;
+ }
+
+ // This MUST NOT become public.
+ private final TypeMirror eventType(final TypeMirror typeArgumentSource, final TypeMirror eventType) {
+ //
+ // Given:
+ //
+ // class Sup {}
+ // class Sub extends Sup {}
+ // class Sub2 extends Sup {}
+ //
+ // +-----------------------+-------------+--------------------------+---------------------------------------------------+
+ // | typeArgumentSource | eventType | return value/exception | notes |
+ // +-----+-----------------------+-------------+--------------------------+---------------------------------------------------+
+ // | 1. | N/A | int | int | (typeArgumentSource not checked or used) |
+ // | 2. | N/A | int[] | int[] | (typeArgumentSource not checked or used) |
+ // | 3. | N/A | Object | Object | (typeArgumentSource not checked or used) |
+ // | 4. | N/A | Object[] | Object[] | (typeArgumentSource not checked or used) |
+ // | 5. | int | ArrayList | IllegalArgumentException | (typeArgumentSource cannot supply type arguments) |
+ // | 6. | int[] | ArrayList | IllegalArgumentException | (typeArgumentSource cannot supply type arguments) |
+ // | 7. | List | ArrayList | IllegalArgumentException | (typeArgumentSource cannot supply type arguments) |
+ // | 8. | List[] | ArrayList | IllegalArgumentException | (typeArgumentSource cannot supply type arguments) |
+ // | 9. | AbstractList | ArrayList | ArrayList | |
+ // | 10. | List[] | ArrayList[] | ArrayList[] | |
+ // | 11. | List[] | ArrayList | ArrayList | (typeArgumentSource dimensions don't matter) |
+ // | 12. | List | ArrayList | IllegalArgumentException | (type arguments must be declared or array types) |
+ // | 13. | List[] | ArrayList | IllegalArgumentException | (type arguments must be declared or array types) |
+ // | 14. | List | ArrayList | IllegalArgumentException | (type arguments must be declared or array types) |
+ // | 15. | List[] | ArrayList | IllegalArgumentException | (type arguments must be declared or array types) |
+ // | 16. | Map | ArrayList | IllegalArgumentException | (typeArgumentSource is not a supertype) |
+ // | 17. | Sup | Sub | Sub | |
+ // | 18. | Sup | Sub2 | Sub2