How to use

isNormalScope

method

in

javax.enterprise.inject.spi.BeanManager

private boolean isNormalScope(final Set<Annotation> annotations, final BeanManager bm)
{
  for (Annotation annotation : annotations)
  {
    if (bm.isNormalScope(annotation.annotationType()))
    {
      return true;
    }
  }
  return false;
}

private boolean isNormalScope(final Set<Annotation> annotations, final BeanManager bm)
{
  for (Annotation annotation : annotations)
  {
    if (bm.isNormalScope(annotation.annotationType()))
    {
      return true;
    }
  }
  return false;
}

@Override
public boolean isNormalScope(Class<? extends Annotation> annotationType) {
  return delegate().isNormalScope(annotationType);
}

private void starts(final BeanManager beanManager, final Class<?> clazz) {
  final Bean<?> bean = beanManager.resolve(beanManager.getBeans(clazz));
  if (!beanManager.isNormalScope(bean.getScope())) {
    throw new IllegalStateException("Only normal scoped beans can use @Startup - likely @ApplicationScoped");
  }
  final CreationalContext<Object> creationalContext = beanManager.createCreationalContext(null);
  beanManager.getReference(bean, clazz, creationalContext).toString();
  // don't release now, will be done by the context - why we restrict it to normal scoped beans
}

@Override
public boolean isNormalScope(Class<? extends Annotation> annotationType) {
  return delegate().isNormalScope(annotationType);
}

  private <T> T lookupByName(final String name, final Class<T> type)
  {
    final Set<Bean<?>> tfb = beanManager.getBeans(name);
    final Bean<?> bean = beanManager.resolve(tfb);
    final CreationalContext<?> ctx = beanManager.createCreationalContext(null);
    if (!beanManager.isNormalScope(bean.getScope()))
    {
      contexts.add(ctx);
    }
    return type.cast(beanManager.getReference(bean, type, ctx));
  }
}

private Object getInstance(final Class<?> javaClass, final BeanManager beanManager, final Bean<?> bean) {
  final CreationalContext<Object> creationalContext = beanManager.createCreationalContext(null);
  final Object reference = beanManager.getReference(bean, javaClass, creationalContext);
  if (!beanManager.isNormalScope(bean.getScope())) {
    creationalContexts.add(creationalContext);
  }
  return reference;
}

protected <X> boolean hasNormalScopeAnnotation(Bean<X> bean, BeanManager beanManager)
{
  Class<? extends Annotation> scopeAnnotationClass = bean.getScope();
  return scopeAnnotationClass != null && beanManager.isNormalScope(scopeAnnotationClass);
}

private synchronized void init(BeanManager beanManager) {
  if (queryInOutMapperIsNormalScope != null) {
    return;
  }
  if (beanManager != null) {
    final Set<Bean<?>> beans = beanManager.getBeans(mapper);
    final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    queryInOutMapperIsNormalScope = beanManager.isNormalScope(scope);
  } else {
    queryInOutMapperIsNormalScope = false;
  }
}

@Override
public boolean isNormalScope(Class<? extends Annotation> annotationType) {
  return delegate().isNormalScope(annotationType);
}

private synchronized void init(BeanManager beanManager) {
  if (queryInOutMapperIsNormalScope != null) {
    return;
  }
  if (beanManager != null) {
    final Set<Bean<?>> beans = beanManager.getBeans(mapper);
    final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    queryInOutMapperIsNormalScope = beanManager.isNormalScope(scope);
  } else {
    queryInOutMapperIsNormalScope = false;
  }
}

public <T> T getBean(final Class<T> type) { // ATM we recommand getting it once but if needed we can cache it in a concurrent map
  final BeanManager manager = getBeanManager();
  final Bean<?> bean = manager.resolve(manager.getBeans(type));
  if (!manager.isNormalScope(bean.getScope()) && !type.isAnnotationPresent(Singleton.class)) {
    throw new IllegalArgumentException("Only normal scoped instances or singleton EJB can use getBean()");
  }
  return type.cast(manager.getReference(bean, type, null));
}

private synchronized void init(BeanManager beanManager, EntityViewManager evm) {
  if (entityManagerResolverIsNormalScope != null) {
    return;
  }
  initialize(evm);
  if (entityManagerResolver != null && beanManager != null) {
    final Set<Bean<?>> beans = beanManager.getBeans(entityManagerResolver);
    final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    entityManagerResolverIsNormalScope = beanManager.isNormalScope(scope);
  } else {
    entityManagerResolverIsNormalScope = false;
  }
}

  private HealthCheck lookup(final Bean<?> bean, final BeanManager manager) {
    final Class<?> type = bean.getBeanClass() == null ? HealthCheck.class : bean.getBeanClass();
    final Set<Bean<?>> beans = manager.getBeans(type, bean.getQualifiers().toArray(new Annotation[bean.getQualifiers().size()]));
    final Bean<?> resolvedBean = manager.resolve(beans);
    final CreationalContext<Object> creationalContext = manager.createCreationalContext(null);
    if (!manager.isNormalScope(resolvedBean.getScope())) {
      contexts.add(creationalContext);
    }
    return HealthCheck.class.cast(manager.getReference(resolvedBean, HealthCheck.class, creationalContext));
  }
}

@Test
@SpecAssertion(section = BM_DETERMINING_ANNOTATION, id = "ag")
public void testDetermineScopeType() {
  assertTrue(getCurrentManager().isNormalScope(RequestScoped.class));
  assertFalse(getCurrentManager().isPassivatingScope(RequestScoped.class));
  assertTrue(getCurrentManager().isNormalScope(SessionScoped.class));
  assertTrue(getCurrentManager().isPassivatingScope(SessionScoped.class));
  assertTrue(getCurrentManager().isNormalScope(DummyScoped.class));
  assertFalse(getCurrentManager().isPassivatingScope(DummyScoped.class));
}

private void initQueryInOutMapperIsNormalScope(RepositoryMetadata repositoryMetadata, RepositoryMethodMetadata repositoryMethodMetadata, BeanManager beanManager) {
  if (repositoryMethodMetadata.getQueryInOutMapperClass() != null) {
    Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass());
    Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope));
  }
}

private void initQueryInOutMapperIsNormalScope(RepositoryMethodMetadata repositoryMethodMetadata,
                        BeanManager beanManager)
{
  if (repositoryMethodMetadata.getQueryInOutMapperClass() != null)
  {
    Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass());
    Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope));
  }
}

private void initQueryInOutMapperIsNormalScope(RepositoryMetadata repositoryMetadata, RepositoryMethodMetadata repositoryMethodMetadata, BeanManager beanManager) {
  if (repositoryMethodMetadata.getQueryInOutMapperClass() != null) {
    Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass());
    Class<? extends Annotation> scope = beanManager.resolve(beans).getScope();
    repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope));
  }
}

/**
 * This method will properly destroy the @Dependent scoped instance.
 * It will have no effect if the bean is NormalScoped as those have their
 * own lifecycle which we must not disrupt.
 */
public void destroy()
{
  if (!BeanManagerProvider.getInstance().getBeanManager().isNormalScope(bean.getScope()))
  {
    bean.destroy(instance, creationalContext);
  }
}

/**
 * This method will properly destroy the @Dependent scoped instance.
 * It will have no effect if the bean is NormalScoped as those have their
 * own lifecycle which we must not disrupt.
 */
public void destroy()
{
  if (!BeanManagerProvider.getInstance().getBeanManager().isNormalScope(bean.getScope()))
  {
    bean.destroy(instance, creationalContext);
  }
}