private <U extends T> WeldEvent<U> selectEvent(Type subtype, Annotation[] newQualifiers) { getBeanManager().getGlobalStrictObserverNotifier().checkEventObjectType(subtype); return new EventImpl<U>(new FacadeInjectionPoint(getBeanManager(), getInjectionPoint(), Event.class, subtype, getQualifiers(), newQualifiers), getBeanManager()); }
private CachedObservers createCachedObservers(Class<?> runtimeType) { final Type eventType = getEventType(runtimeType); // this performs type check final ResolvedObservers<T> observers = getBeanManager().getGlobalStrictObserverNotifier().resolveObserverMethods(eventType, getQualifiers()); final EventMetadata metadata = new EventMetadataImpl(eventType, getInjectionPoint(), getQualifiers()); return new CachedObservers(runtimeType, observers, metadata); }
@Override public WeldEvent<T> select(Annotation... qualifiers) { return selectEvent(this.getType(), qualifiers); }
private <U extends T> CompletionStage<U> fireAsyncInternal(U event, NotificationOptions options) { CachedObservers observers = getObservers(event); // we can do lenient here as the event type is checked within #getObservers() return getBeanManager().getGlobalLenientObserverNotifier().notifyAsync(observers.observers, event, observers.metadata, options); }
/** * Gets a string representation * * @return A string representation */ @Override public String toString() { return Formats.formatAnnotations(getQualifiers()) + " Event<" + Formats.formatType(getType()) + ">"; }
public WeldEvent<Object> event() { return EventImpl.of(EventInjectionPoint.INSTANCE, this); }
@Override public <U extends T> WeldEvent<U> select(Class<U> subtype, Annotation... qualifiers) { Preconditions.checkArgumentNotNull(subtype, SUBTYPE_ARGUMENT_NAME); return selectEvent(subtype, qualifiers); }
private EventImpl(InjectionPoint injectionPoint, BeanManagerImpl beanManager) { super(injectionPoint, null, beanManager); this.injectionPointTypeHierarchy = new HierarchyDiscovery(getType()); this.cachedObservers = new ConcurrentHashMap<Class<?>, CachedObservers>(DEFAULT_CACHE_CAPACITY); }
public static <E> EventImpl<E> of(InjectionPoint injectionPoint, BeanManagerImpl beanManager) { return new EventImpl<E>(injectionPoint, beanManager); }
private CachedObservers getObservers(T event) { Class<?> runtimeType = event.getClass(); CachedObservers lastResolvedObservers = this.lastCachedObservers; // fast track for cases when the same type is used repeatedly if (lastResolvedObservers != null && lastResolvedObservers.rawType.equals(runtimeType)) { return lastResolvedObservers; } lastResolvedObservers = cachedObservers.get(runtimeType); if (lastResolvedObservers == null) { // this is not atomic and less elegant than computeIfAbsent but is faster and atomicity does not really matter here // as createCachedObservers() does not have any side effects lastResolvedObservers = putIfAbsent(cachedObservers, runtimeType, createCachedObservers(runtimeType)); } return this.lastCachedObservers = lastResolvedObservers; }
private <U extends T> CompletionStage<U> fireAsyncInternal(U event, NotificationOptions options) { CachedObservers observers = getObservers(event); // we can do lenient here as the event type is checked within #getObservers() return getBeanManager().getGlobalLenientObserverNotifier().notifyAsync(observers.observers, event, observers.metadata, options); }
/** * Gets a string representation * * @return A string representation */ @Override public String toString() { return Formats.formatAnnotations(getQualifiers()) + " Event<" + Formats.formatType(getType()) + ">"; }
public WeldEvent<Object> event() { return EventImpl.of(EventInjectionPoint.INSTANCE, this); }
@Override public <U extends T> WeldEvent<U> select(Class<U> subtype, Annotation... qualifiers) { Preconditions.checkArgumentNotNull(subtype, SUBTYPE_ARGUMENT_NAME); return selectEvent(subtype, qualifiers); }
private EventImpl(InjectionPoint injectionPoint, BeanManagerImpl beanManager) { super(injectionPoint, null, beanManager); this.injectionPointTypeHierarchy = new HierarchyDiscovery(getType()); this.cachedObservers = new ConcurrentHashMap<Class<?>, CachedObservers>(DEFAULT_CACHE_CAPACITY); }
public static <E> EventImpl<E> of(InjectionPoint injectionPoint, BeanManagerImpl beanManager) { return new EventImpl<E>(injectionPoint, beanManager); }
private CachedObservers getObservers(T event) { Class<?> runtimeType = event.getClass(); CachedObservers lastResolvedObservers = this.lastCachedObservers; // fast track for cases when the same type is used repeatedly if (lastResolvedObservers != null && lastResolvedObservers.rawType.equals(runtimeType)) { return lastResolvedObservers; } lastResolvedObservers = cachedObservers.get(runtimeType); if (lastResolvedObservers == null) { // this is not atomic and less elegant than computeIfAbsent but is faster and atomicity does not really matter here // as createCachedObservers() does not have any side effects lastResolvedObservers = putIfAbsent(cachedObservers, runtimeType, createCachedObservers(runtimeType)); } return this.lastCachedObservers = lastResolvedObservers; }
private <U extends T> WeldEvent<U> selectEvent(Type subtype, Annotation[] newQualifiers) { getBeanManager().getGlobalStrictObserverNotifier().checkEventObjectType(subtype); return new EventImpl<U>(new FacadeInjectionPoint(getBeanManager(), getInjectionPoint(), Event.class, subtype, getQualifiers(), newQualifiers), getBeanManager()); }
private CachedObservers createCachedObservers(Class<?> runtimeType) { final Type eventType = getEventType(runtimeType); // this performs type check final ResolvedObservers<T> observers = getBeanManager().getGlobalStrictObserverNotifier().resolveObserverMethods(eventType, getQualifiers()); final EventMetadata metadata = new EventMetadataImpl(eventType, getInjectionPoint(), getQualifiers()); return new CachedObservers(runtimeType, observers, metadata); }
@Override public WeldEvent<T> select(Annotation... qualifiers) { return selectEvent(this.getType(), qualifiers); }