org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType.isFinal java code examples

Common ways to obtain EnhancedAnnotatedType

private void myMethod () {
 EnhancedAnnotatedType e =SlimAnnotatedType annotatedType;ClassTransformer classTransformer;EnhancedAnnotatedTypeImpl.of(annotatedType, classTransformer)
DecoratorImpl decoratorBean;decoratorBean.getBeanManager().getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(decoratorBean.getAnnotated())
EnhancedAnnotatedParameterImpl enhancedAnnotatedParameterImpl;enhancedAnnotatedParameterImpl.getDeclaringEnhancedCallable().getDeclaringType()
Smart code suggestions by Tabnine
}

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);
      }
    }
  }
}

Popular methods of EnhancedAnnotatedType

getDeclaredEnhancedConstructor
Get the constructor which matches the argument list provided
getJavaClass
getEnhancedMethod
Get a method by name
getEnhancedMethods
Gets all methods annotated with annotationType including those declared on a superclass of #getJavaC
getNoArgsEnhancedConstructor
Gets the no-args constructor
isAbstract
isDiscovered
slim
Returns a lightweight implementation of AnnotatedType with minimal memory footprint.
getConstructors
getDeclaredEnhancedFields
Gets all fields which are annotated with the given annotation type on this class only.
getDeclaredEnhancedMethods
Gets all methods annotated with annotationType
getDeclaredEnhancedMethodsWithAnnotatedParameters
Gets declared with parameters annotated with annotationType

Popular in Java

Running tasks concurrently on multiple threads
getContentResolver (Context)
onCreateOptionsMenu (Activity)
addToBackStack (FragmentTransaction)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
Socket (java.net)
Provides a client-side TCP socket.
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
DateFormat (java.text)
Formats or parses dates and times.This class provides factories for obtaining instances configured f
Top 12 Jupyter Notebook Extensions

How to use isFinalmethodin org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType

Best Java code snippets using org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType.isFinal (Showing top 13 results out of 315)

How to use
isFinal
method
in
org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType