private void defaultRules(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private void defaultRules(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private void defaultRules(ExtensionObserverMethodImpl<?, ?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private void defaultRules(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private void defaultRules(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private void defaultRules(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException { if (ProcessAnnotatedType.class.equals(observedType)) { catchAllObservers.add(observer); } else if (observedType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) observedType; if (ProcessAnnotatedType.class.equals(parameterizedType.getRawType())) { Type argument = parameterizedType.getActualTypeArguments()[0]; if (argument instanceof Class<?>) { this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(argument))); } else { throw new UnsupportedObserverMethodException(observer); } } } else if (observedType instanceof TypeVariable) { final TypeVariable<?> typeVariable = (TypeVariable<?>) observedType; if (Reflections.isUnboundedTypeVariable(observedType)) { // <T> void observe(T event) catchAllObservers.add(observer); } else { if (typeVariable.getBounds().length == 1) { // here we expect that a PAT impl only implements the PAT interface defaultRules(observer, typeVariable.getBounds()[0]); } } } }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethodImpl<?, ?> observerMethod) { if (observerMethod instanceof ExtensionObserverMethodImpl) { ExtensionObserverMethodImpl<?, ?> extensionObserverMethod = (ExtensionObserverMethodImpl<?, ?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(extensionObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && extensionObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = extensionObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }
@Override protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) { Class<?> rawObserverType = Reflections.getRawType(getObservedType()); boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class); if (!isProcessAnnotatedType && !requiredTypeAnnotations.isEmpty()) { throw EventLogger.LOG .invalidWithAnnotations(this, Formats.formatAsStackTraceElement(eventParameter.getDeclaringEnhancedCallable().getJavaMember())); } if (isProcessAnnotatedType && requiredTypeAnnotations.isEmpty()) { Type[] typeArguments = eventParameter.getActualTypeArguments(); if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { EventLogger.LOG.unrestrictedProcessAnnotatedTypes(this); } } }