new ParameterizedTypeImpl(Foo.class, new Type[]{String.class}, null)
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
/** * In multi-threaded environment we often cannot leverage multiple core fully in bootstrap because the deployer * threads are often blocked by the reflection API or waiting to get a classloader lock. While waiting for classes to be loaded or * reflection metadata to be obtained, we can make use of the idle CPU cores and start resolving container lifecycle event observers * (extensions) upfront for those types of events we know we will be firing. Since these resolutions are cached, firing of the * lifecycle events will then be very fast. * */ @SuppressFBWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE", justification = "We never need to synchronize with the preloader.") void preloadContainerLifecycleEvent(Class<?> eventRawType, Type... typeParameters) { executor.submit(new PreloadingTask(new ParameterizedTypeImpl(eventRawType, typeParameters, null))); }
public FacadeInjectionPoint(BeanManagerImpl manager, InjectionPoint injectionPoint, Type rawType, Type subtype, Set<Annotation> existingQualifiers, Annotation[] newQualifiers) { this.injectionPoint = injectionPoint; this.type = new ParameterizedTypeImpl(rawType, new Type[]{subtype}, null); this.qualifiers = mergeInQualifiers(manager, existingQualifiers, newQualifiers); }
public FacadeInjectionPoint(BeanManagerImpl manager, InjectionPoint injectionPoint, Type rawType, Type subtype, Set<Annotation> existingQualifiers, Annotation[] newQualifiers) { this.injectionPoint = injectionPoint; this.type = new ParameterizedTypeImpl(rawType, new Type[]{subtype}, null); this.qualifiers = mergeInQualifiers(manager, existingQualifiers, newQualifiers); }
public FacadeInjectionPoint(BeanManagerImpl manager, InjectionPoint injectionPoint, Type rawType, Type subtype, Set<Annotation> existingQualifiers, Annotation[] newQualifiers) { this.injectionPoint = injectionPoint; this.type = new ParameterizedTypeImpl(rawType, new Type[]{subtype}, null); this.qualifiers = mergeInQualifiers(manager, existingQualifiers, newQualifiers); }
public FacadeInjectionPoint(BeanManagerImpl manager, InjectionPoint injectionPoint, Type rawType, Type subtype, Set<Annotation> existingQualifiers, Annotation[] newQualifiers) { this.injectionPoint = injectionPoint; this.type = new ParameterizedTypeImpl(rawType, new Type[]{subtype}, null); this.qualifiers = mergeInQualifiers(manager, existingQualifiers, newQualifiers); }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public Type getEventType() { return new ParameterizedTypeImpl(getRawType(), getActualTypeArguments(), null); } }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) { ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null); return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery); }
public Type getEventType() { return new ParameterizedTypeImpl(getRawType(), getActualTypeArguments(), null); } }
public Type getEventType() { return new ParameterizedTypeImpl(getRawType(), getActualTypeArguments(), null); } }