@Override public BeanAttributesConfigurator<T> scope(Class<? extends Annotation> scope) { checkArgumentNotNull(scope); this.scope = scope; return this; }
@Override public WeldBeanConfigurator<T> addInjectionPoints(Set<InjectionPoint> injectionPoints) { checkArgumentNotNull(injectionPoints); this.injectionPoints.addAll(injectionPoints); return this; }
@Override public BeanAttributesConfigurator<T> addTypes(Type... types) { checkArgumentNotNull(types); Collections.addAll(this.types, types); return this; }
/** * * @param type * @return the primitive type of the given type if it is a wrapper, or the type itself otherwise */ public static <T> Class<T> unwrap(Class<T> type) { checkArgumentNotNull(type, ARG_TYPE); Class<T> primitive = cast(WRAPPER_TO_PRIMITIVE.get(type)); return primitive != null ? primitive : type; }
@Override public WeldBeanConfigurator<T> read(BeanAttributes<?> beanAttributes) { checkArgumentNotNull(beanAttributes); this.attributes.read(beanAttributes); return this; }
@Override public WeldBeanConfigurator<T> addTransitiveTypeClosure(Type type) { checkArgumentNotNull(type); this.attributes.addTransitiveTypeClosure(type); return this; }
@Override public WeldBeanConfigurator<T> addQualifier(Annotation qualifier) { checkArgumentNotNull(qualifier); this.attributes.addQualifier(qualifier); return this; }
@Override public WeldBeanConfigurator<T> addStereotypes(Set<Class<? extends Annotation>> stereotypes) { checkArgumentNotNull(stereotypes); this.attributes.addStereotypes(stereotypes); return this; }
@Override public BeanAttributesConfigurator<T> addQualifier(Annotation qualifier) { checkArgumentNotNull(qualifier); removeDefaultQualifierIfNeeded(qualifier); qualifiers.add(qualifier); return this; }
@Override public BeanAttributesConfigurator<T> addQualifiers(Annotation... qualifiers) { checkArgumentNotNull(qualifiers); for (Annotation annotation : qualifiers) { removeDefaultQualifierIfNeeded(annotation); } Collections.addAll(this.qualifiers, qualifiers); return this; }
@Override public BeanAttributesConfigurator<T> addQualifiers(Set<Annotation> qualifiers) { checkArgumentNotNull(qualifiers); for (Annotation annotation : qualifiers) { removeDefaultQualifierIfNeeded(annotation); } this.qualifiers.addAll(qualifiers); return this; }
@Override @SuppressFBWarnings("NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE") public Method apply(AnnotatedMethod<?> method) { Preconditions.checkArgumentNotNull(method, "method"); return AccessController.doPrivileged(new GetAccessibleCopyOfMember<Method>(method.getJavaMember())); } };
@Override public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id) { checkWithinObserverNotification(); Preconditions.checkArgumentNotNull(type, TYPE_ARGUMENT_NAME); return slimAnnotatedTypeStore.get(type, id); }
@Override public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id) { checkWithinObserverNotification(); Preconditions.checkArgumentNotNull(type, TYPE_ARGUMENT_NAME); return slimAnnotatedTypeStore.get(type, id); }
@Override public <U extends T> WeldBeanConfigurator<U> produceWith(Function<Instance<Object>, U> callback) { checkArgumentNotNull(callback); this.createCallback = cast(CreateCallback.fromProduceWith(callback)); return cast(this); }
@Override public void addObserverMethod(ObserverMethod<?> observerMethod) { checkWithinObserverNotification(); Preconditions.checkArgumentNotNull(observerMethod, "observerMethod"); validateObserverMethod(observerMethod, getBeanManager()); additionalObservers.add(observerMethod); BootstrapLogger.LOG.addObserverMethodCalled(getReceiver(), observerMethod); }
@Override public void addBean(Bean<?> bean) { checkWithinObserverNotification(); Preconditions.checkArgumentNotNull(bean, "bean"); ExternalBeanAttributesFactory.validateBeanAttributes(bean, getBeanManager()); validateBean(bean); additionalBeans.add(bean); BootstrapLogger.LOG.addBeanCalled(getReceiver(), bean); }
public void setProducer(Producer<X> producer) { if (configurator != null) { throw BootstrapLogger.LOG.configuratorAndSetMethodBothCalled(ProcessProducer.class.getSimpleName(), getReceiver()); } checkArgumentNotNull(producer, "producer"); checkWithinObserverNotification(); BootstrapLogger.LOG.setProducerCalled(getReceiver(), getProducer(), producer); this.bean.setProducer(producer); producerSet = true; }
@Override public void addBean(Bean<?> bean) { checkWithinObserverNotification(); Preconditions.checkArgumentNotNull(bean, "bean"); ExternalBeanAttributesFactory.validateBeanAttributes(bean, getBeanManager()); validateBean(bean); additionalBeans.add(BeanRegistration.of(bean, getReceiver())); BootstrapLogger.LOG.addBeanCalled(getReceiver(), bean); }
protected AbstractInjector(WeldManager manager) { Preconditions.checkArgumentNotNull(manager, "manager"); this.manager = manager; this.cache = ComputingCacheBuilder.newBuilder().setWeakValues().build(clazz -> { AnnotatedType<?> type = manager.createAnnotatedType(clazz); return manager.createInjectionTargetBuilder(type) .setResourceInjectionEnabled(false) .setTargetClassLifecycleCallbacksEnabled(false) .build(); }); }