public static String forSessionBean(EnhancedAnnotatedType<?> type, EjbDescriptor<?> descriptor) { StringBuilder builder = getPrefix(SessionBean.class); appendEjbNameAndClass(builder, descriptor); if (!type.isDiscovered()) { builder.append(BEAN_ID_SEPARATOR).append(type.slim().getIdentifier().asString()); } return builder.toString(); }
public InterceptorMetadataBean(BeanManagerImpl beanManager) { super(new StringBeanIdentifier(BeanIdentifiers.forBuiltInBean(beanManager, Interceptor.class, null)), Reflections.<Class<Interceptor<?>>> cast(Interceptor.class), beanManager); }
protected DecoratorImpl(BeanAttributes<T> attributes, EnhancedAnnotatedType<T> type, BeanManagerImpl beanManager) { super(attributes, type, new StringBeanIdentifier(forDecorator(type)), beanManager); }
public ExtensionBean(BeanManagerImpl manager, EnhancedAnnotatedType<E> enhancedAnnotatedType, Metadata<E> instance) { super(new StringBeanIdentifier(BeanIdentifiers.forExtension(enhancedAnnotatedType)), manager, enhancedAnnotatedType.getJavaClass()); this.annotatedType = enhancedAnnotatedType.slim(); this.instance = instance; this.passivationCapable = enhancedAnnotatedType.isSerializable(); this.proxiable = Proxies.isTypeProxyable(enhancedAnnotatedType.getBaseType(), manager.getServices()); checkPublicFields(enhancedAnnotatedType); }
public static String forProducerMethod(EnhancedAnnotatedMethod<?, ?> method, AbstractClassBean<?> declaringBean) { if (declaringBean.getEnhancedAnnotated().isDiscovered()) { return forProducerMethod(declaringBean.getAnnotated().getIdentifier(), DeclaredMemberIndexer.getIndexForMethod(method.getJavaMember())); } return getPrefix(ProducerMethod.class).append(method.getDeclaringType().slim().getIdentifier()).append(AnnotatedTypes.createCallableId(method)).toString(); }
super(attributes, new StringBeanIdentifier(BeanIdentifiers.forProducerField(field, declaringBean)), declaringBean, manager, services); this.enhancedAnnotatedField = field; this.annotatedField = field.slim(); initType(); this.proxiable = Proxies.isTypesProxyable(field.getTypeClosure(), beanManager.getServices()); setProducer(new ProducerFieldProducer<X, T>(field, disposalMethod) {
protected AbstractDecorableBuiltInBean(BeanManagerImpl beanManager, Class<T> type) { super(new StringBeanIdentifier(BeanIdentifiers.forBuiltInBean(beanManager, type, null)), beanManager, type); this.cip = beanManager.getServices().get(CurrentInjectionPoint.class); }
private static BeanIdentifier createId(BeanAttributes<?> attributes, EnhancedAnnotatedType<?> clazz) { if (Dependent.class.equals(attributes.getScope()) || ApplicationScoped.class.equals(attributes.getScope())) { return new ManagedBeanIdentifier(clazz.slim().getIdentifier()); } else { return new StringBeanIdentifier(forManagedBean(clazz)); } }
protected InterceptorImpl(BeanAttributes<T> attributes, EnhancedAnnotatedType<T> type, BeanManagerImpl beanManager) { super(attributes, type, new StringBeanIdentifier(forInterceptor(type)), beanManager); this.interceptorMetadata = initInterceptorMetadata(); this.serializable = type.isSerializable(); this.interceptorBindingTypes = Collections.unmodifiableSet(new HashSet<Annotation>(Interceptors.mergeBeanInterceptorBindings(beanManager, getEnhancedAnnotated(), getStereotypes()).values())); if (Beans.findInterceptorBindingConflicts(beanManager, interceptorBindingTypes)) { throw new DeploymentException(BeanLogger.LOG.conflictingInterceptorBindings(getType())); } }
public static String forManagedBean(EnhancedAnnotatedType<?> type) { return forManagedBean(type.slim().getIdentifier()); }
public ContextBean(ContextHolder<T> contextHolder, BeanManagerImpl beanManager) { super(new StringBeanIdentifier(BeanIdentifiers.forBuiltInBean(beanManager, contextHolder.getType(), null)), beanManager, contextHolder.getType()); this.context = contextHolder.getContext(); this.types = HierarchyDiscovery.forNormalizedType(contextHolder.getType()).getTypeClosure(); this.qualifiers = contextHolder.getQualifiers(); }
private static BeanIdentifier createId(BeanAttributes<?> attributes, EnhancedAnnotatedMethod<?, ?> method, AbstractClassBean<?> declaringBean) { if (Dependent.class.equals(attributes.getScope()) || ApplicationScoped.class.equals(attributes.getScope())) { return new ProducerMethodIdentifier(method, declaringBean); } else { return new StringBeanIdentifier(BeanIdentifiers.forProducerMethod(method, declaringBean)); } }
/** * Creates an instance of a NewSimpleBean from an annotated class * * @param clazz The annotated class * @param beanManager The Bean manager * @return a new NewSimpleBean instance */ public static <T> NewManagedBean<T> of(BeanAttributes<T> attributes, EnhancedAnnotatedType<T> clazz, BeanManagerImpl beanManager) { return new NewManagedBean<T>(attributes, clazz, new StringBeanIdentifier(BeanIdentifiers.forNewManagedBean(clazz)), beanManager); }
protected AbstractSyntheticBean(BeanAttributes<T> attributes, BeanManagerImpl manager, Class<?> beanClass) { super(attributes, new StringBeanIdentifier(BeanIdentifiers.forSyntheticBean(attributes, beanClass))); this.beanClass = beanClass; }
public static String forBuiltInBean(BeanManagerImpl manager, Class<?> type, String suffix) { StringBuilder builder = getPrefix(AbstractBuiltInBean.class).append(manager.getId()).append(BEAN_ID_SEPARATOR).append(type.getSimpleName()); if (suffix != null) { builder.append(BEAN_ID_SEPARATOR).append(suffix); } return builder.toString(); }
@Override public String asString() { return BeanIdentifiers.forManagedBean(typeIdentifier); }
public ExtensionBean(BeanManagerImpl manager, EnhancedAnnotatedType<E> enhancedAnnotatedType, Metadata<E> instance) { super(new StringBeanIdentifier(BeanIdentifiers.forExtension(enhancedAnnotatedType)), manager, enhancedAnnotatedType.getJavaClass()); this.annotatedType = enhancedAnnotatedType.slim(); this.instance = instance; this.passivationCapable = enhancedAnnotatedType.isSerializable(); this.proxiable = Proxies.isTypeProxyable(enhancedAnnotatedType.getBaseType(), manager.getServices()); checkPublicFields(enhancedAnnotatedType); }
public static String forProducerMethod(EnhancedAnnotatedMethod<?, ?> method, AbstractClassBean<?> declaringBean) { if (declaringBean.getEnhancedAnnotated().isDiscovered()) { return forProducerMethod(declaringBean.getAnnotated().getIdentifier(), DeclaredMemberIndexer.getIndexForMethod(method.getJavaMember())); } return getPrefix(ProducerMethod.class).append(method.getDeclaringType().slim().getIdentifier()).append(AnnotatedTypes.createCallableId(method)).toString(); }
super(attributes, new StringBeanIdentifier(BeanIdentifiers.forProducerField(field, declaringBean)), declaringBean, manager, services); this.enhancedAnnotatedField = field; this.annotatedField = field.slim(); initType(); this.proxiable = Proxies.isTypesProxyable(field.getTypeClosure(), beanManager.getServices()); setProducer(new ProducerFieldProducer<X, T>(field, disposalMethod) {
protected AbstractDecorableBuiltInBean(BeanManagerImpl beanManager, Class<T> type) { super(new StringBeanIdentifier(BeanIdentifiers.forBuiltInBean(beanManager, type, null)), beanManager, type); this.cip = beanManager.getServices().get(CurrentInjectionPoint.class); }