@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
@Override public InterceptorResolvableBuilder addTypes(Set<Type> types) { super.addTypes(types); return this; }
/** * Resolve the disposal method for the given producer method. Any resolved * beans will be marked as such for the purpose of validating that all * disposal methods are used. For internal use. * * @param types the types * @param qualifiers The binding types to match * @param declaringBean declaring bean * @return The set of matching disposal methods */ public <X> Set<DisposalMethod<X, ?>> resolveDisposalBeans(Set<Type> types, Set<Annotation> qualifiers, AbstractClassBean<X> declaringBean) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<DisposalMethod<X, ?>> beans = cast(disposalMethodResolver.resolve(new ResolvableBuilder(manager).addTypes(types).addQualifiers(qualifiers).setDeclaringBean(declaringBean).create(), true)); resolvedDisposalBeans.addAll(beans); return Collections.unmodifiableSet(beans); }
/** * Resolve the disposal method for the given producer method. Any resolved * beans will be marked as such for the purpose of validating that all * disposal methods are used. For internal use. * * @param types the types * @param qualifiers The binding types to match * @param declaringBean declaring bean * @return The set of matching disposal methods */ public <X> Set<DisposalMethod<X, ?>> resolveDisposalBeans(Set<Type> types, Set<Annotation> qualifiers, AbstractClassBean<X> declaringBean) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<DisposalMethod<X, ?>> beans = cast(disposalMethodResolver.resolve(new ResolvableBuilder(manager).addTypes(types).addQualifiers(qualifiers).setDeclaringBean(declaringBean).create(), true)); resolvedDisposalBeans.addAll(beans); return Collections.unmodifiableSet(beans); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()) .addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()) .addType(Object.class) .addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY) .create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()) .addTypes(typeClosure) .addType(Object.class) .addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY) .create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }