@Override @SuppressWarnings("unchecked") public <X> WeldInstance<X> select(Type subtype, Annotation... qualifiers) { // verify if this was invoked on WeldInstance<Object> if (!this.getType().equals(Object.class)) { throw BeanLogger.LOG.selectByTypeOnlyWorksOnObject(); } // This cast should be safe, we make sure that this method is only invoked on WeldInstance<Object> // and any type X will always extend Object return (WeldInstance<X>)selectInstance(subtype, qualifiers); }
@Override @SuppressWarnings("unchecked") public <X> WeldInstance<X> select(Type subtype, Annotation... qualifiers) { // verify if this was invoked on WeldInstance<Object> if (!this.getType().equals(Object.class)) { throw BeanLogger.LOG.selectByTypeOnlyWorksOnObject(); } // This cast should be safe, we make sure that this method is only invoked on WeldInstance<Object> // and any type X will always extend Object return (WeldInstance<X>)selectInstance(subtype, qualifiers); }
@Override @SuppressWarnings("unchecked") public <X> WeldInstance<X> select(Type subtype, Annotation... qualifiers) { // verify if this was invoked on WeldInstance<Object> if (!this.getType().equals(Object.class)) { throw BeanLogger.LOG.selectByTypeOnlyWorksOnObject(); } // This cast should be safe, we make sure that this method is only invoked on WeldInstance<Object> // and any type X will always extend Object return (WeldInstance<X>)selectInstance(subtype, qualifiers); }
@Override @SuppressWarnings("unchecked") public <X> WeldInstance<X> select(Type subtype, Annotation... qualifiers) { // verify if this was invoked on WeldInstance<Object> if (!this.getType().equals(Object.class)) { throw BeanLogger.LOG.selectByTypeOnlyWorksOnObject(); } // This cast should be safe, we make sure that this method is only invoked on WeldInstance<Object> // and any type X will always extend Object return (WeldInstance<X>)selectInstance(subtype, qualifiers); }
@Override @SuppressWarnings("unchecked") public <X> WeldInstance<X> select(Type subtype, Annotation... qualifiers) { // verify if this was invoked on WeldInstance<Object> if (!this.getType().equals(Object.class)) { throw BeanLogger.LOG.selectByTypeOnlyWorksOnObject(); } // This cast should be safe, we make sure that this method is only invoked on WeldInstance<Object> // and any type X will always extend Object return (WeldInstance<X>)selectInstance(subtype, qualifiers); }
/** * Gets a string representation * * @return A string representation */ @Override public String toString() { return Formats.formatAnnotations(getQualifiers()) + " Instance<" + Formats.formatType(getType()) + ">"; }
/** * Gets a string representation * * @return A string representation */ @Override public String toString() { return Formats.formatAnnotations(getQualifiers()) + " Instance<" + Formats.formatType(getType()) + ">"; }
/** * Gets a string representation * * @return A string representation */ @Override public String toString() { return Formats.formatAnnotations(getQualifiers()) + " Instance<" + Formats.formatType(getType()) + ">"; }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.push(ip); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(ip, isRegisterableInjectionPoint()); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(ip, isRegisterableInjectionPoint()); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(ip, isRegisterableInjectionPoint()); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(ip, isRegisterableInjectionPoint()); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private T getBeanInstance(Bean<?> bean) { final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(ip, isRegisterableInjectionPoint()); try { return Reflections.<T> cast(getBeanManager().getReference(bean, getType(), getCreationalContext(), false)); } finally { stack.pop(); } }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }
private Set<Bean<?>> resolveBeans() { // Perform typesafe resolution, and possibly attempt to resolve the ambiguity Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager()).addQualifiers(getQualifiers()) .setDeclaringBean(getInjectionPoint().getBean()).create(); TypeSafeBeanResolver beanResolver = getBeanManager().getBeanResolver(); return beanResolver.resolve(beanResolver.resolve(resolvable, Reflections.isCacheable(getQualifiers()))); }