How to use

isFinal

method

in

org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType

private void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class)
          .getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass().getName(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass().getName(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass().getName(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (constructor != null && Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass().getName(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (constructor != null && Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass().getName(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

public void init() {
  initTargetClassInterceptors();
  businessMethods = Beans.getInterceptableMethods(annotatedType);
  initEjbInterceptors();
  initCdiInterceptors();
  InterceptionModel interceptionModel = builder.build();
  if (interceptionModel.getAllInterceptors().size() > 0 || hasSerializationOrInvocationInterceptorMethods) {
    if (annotatedType.isFinal()) {
      throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(annotatedType.getJavaClass());
    }
    if (Reflections.isPrivate(constructor.getJavaMember())) {
      throw new DeploymentException(
          ValidatorLogger.LOG.notProxyablePrivateConstructor(annotatedType.getJavaClass(), constructor, annotatedType.getJavaClass()));
    }
    manager.getInterceptorModelRegistry().put(annotatedType.slim(), interceptionModel);
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}

protected void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) {
  if (type.isFinal()) {
    throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this);
  }
  checkNoArgsConstructor(type);
  for (Decorator<?> decorator : decorators) {
    EnhancedAnnotatedType<?> decoratorClass;
    if (decorator instanceof DecoratorImpl<?>) {
      DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator;
      decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated());
    } else if (decorator instanceof CustomDecoratorWrapper<?>) {
      decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated();
    } else {
      throw BeanLogger.LOG.nonContainerDecorator(decorator);
    }
    for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) {
      EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature());
      if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) {
        throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this);
      }
    }
  }
}