org.jboss.weld.annotated.slim.SlimAnnotatedType.getJavaClass java code examples

Common ways to obtain SlimAnnotatedType

private void myMethod () {
 SlimAnnotatedType s =EnhancedAnnotatedType type;type.slim()
AbstractClassBean abstractClassBean;abstractClassBean.getAnnotated()
ClassTransformer classTransformer;Class rawType;String bdaId;classTransformer.getBackedAnnotatedType(rawType, bdaId)
Smart code suggestions by Codota
}

private boolean isInterceptionCandidate() {
  return !isInterceptor() && !isDecorator() && !Modifier.isAbstract(getType().getJavaClass().getModifiers());
}

private void replaceAnnotatedType(AnnotatedType<X> type) {
  if (!this.originalAnnotatedType.getJavaClass().equals(type.getJavaClass())) {
    throw BootstrapLogger.LOG.annotatedTypeJavaClassMismatch(this.annotatedType.getJavaClass(), type.getJavaClass());
  }
  AnnotatedTypeValidator.validateAnnotatedType(type);
  this.annotatedType = type;
}

private void replaceAnnotatedType(AnnotatedType<X> type) {
  if (!this.originalAnnotatedType.getJavaClass().equals(type.getJavaClass())) {
    throw BootstrapLogger.LOG.annotatedTypeJavaClassMismatch(this.annotatedType.getJavaClass(), type.getJavaClass());
  }
  AnnotatedTypeValidator.validateAnnotatedType(type);
  this.annotatedType = type;
}

private void replaceAnnotatedType(AnnotatedType<X> type) {
  if (!this.originalAnnotatedType.getJavaClass().equals(type.getJavaClass())) {
    throw BootstrapLogger.LOG.annotatedTypeJavaClassMismatch(this.annotatedType.getJavaClass(), type.getJavaClass());
  }
  AnnotatedTypeValidator.validateAnnotatedType(type);
  this.annotatedType = type;
}

private void replaceAnnotatedType(AnnotatedType<X> type) {
  if (!this.originalAnnotatedType.getJavaClass().equals(type.getJavaClass())) {
    throw BootstrapLogger.LOG.annotatedTypeJavaClassMismatch(this.annotatedType.getJavaClass(), type.getJavaClass());
  }
  AnnotatedTypeValidator.validateAnnotatedType(type);
  this.annotatedType = type;
}

public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) {
  ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery);
}

@Override
protected void preSpecialize() {
  super.preSpecialize();
  Class<?> superclass = getAnnotated().getJavaClass().getSuperclass();
  if (superclass == null || superclass.equals(Object.class)) {
    throw BeanLogger.LOG.specializingBeanMustExtendABean(this);
  }
}

public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) {
  ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery);
}

@Override
protected void preSpecialize() {
  super.preSpecialize();
  Class<?> superclass = getAnnotated().getJavaClass().getSuperclass();
  if (superclass == null || superclass.equals(Object.class)) {
    throw BeanLogger.LOG.specializingBeanMustExtendABean(this);
  }
}

@Override
protected void preSpecialize() {
  super.preSpecialize();
  Class<?> superclass = getAnnotated().getJavaClass().getSuperclass();
  if (superclass == null || superclass.equals(Object.class)) {
    throw BeanLogger.LOG.specializingBeanMustExtendABean(this);
  }
}

public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) {
  ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type1, type2), annotatedType, discovery);
}

@Override
protected void preSpecialize() {
  super.preSpecialize();
  Class<?> superclass = getAnnotated().getJavaClass().getSuperclass();
  if (superclass == null || superclass.equals(Object.class)) {
    throw BeanLogger.LOG.specializingBeanMustExtendABean(this);
  }
}

@Override
public void setAnnotatedType(AnnotatedType<X> type) {
  checkWithinObserverNotification();
  if (type == null) {
    throw BootstrapLogger.LOG.annotationTypeNull(this);
  }
  if (!this.originalAnnotatedType.getJavaClass().equals(type.getJavaClass())) {
    throw BootstrapLogger.LOG.annotatedTypeJavaClassMismatch(this.annotatedType.getJavaClass(), type.getJavaClass());
  }
  AnnotatedTypeValidator.validateAnnotatedType(type);
  BootstrapLogger.LOG.setAnnotatedTypeCalled(getReceiver(), annotatedType, type);
  this.annotatedType = type;
}

public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) {
  Class<A> annotationType = annotatedType.getJavaClass();
  Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
  annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations()));
  annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType)));
  // Annotations and declared annotations are the same for annotation type
  return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer);
}

public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) {
  Class<A> annotationType = annotatedType.getJavaClass();
  Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
  annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations()));
  annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType)));
  // Annotations and declared annotations are the same for annotation type
  return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer);
}

public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) {
  Class<A> annotationType = annotatedType.getJavaClass();
  Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
  annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations()));
  annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType)));
  // Annotations and declared annotations are the same for annotation type
  return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer);
}

public static ProcessAnnotatedTypeEventResolvable forProcessAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery) {
  ParameterizedType type = new ParameterizedTypeImpl(ProcessAnnotatedType.class, new Type[] { annotatedType.getJavaClass() }, null);
  return new ProcessAnnotatedTypeEventResolvable(Sets.<Type> newHashSet(Object.class, type), annotatedType, discovery);
}

public static <T> EnhancedAnnotatedType<T> of(SlimAnnotatedType<T> annotatedType, ClassTransformer classTransformer) {
  if (annotatedType instanceof BackedAnnotatedType<?>) {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(classTransformer.getReflectionCache().getDeclaredAnnotations(annotatedType.getJavaClass())), classTransformer);
  } else {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(annotatedType.getAnnotations()), classTransformer);
  }
}

public static <T> EnhancedAnnotatedType<T> of(SlimAnnotatedType<T> annotatedType, ClassTransformer classTransformer) {
  if (annotatedType instanceof BackedAnnotatedType<?>) {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(classTransformer.getReflectionCache().getDeclaredAnnotations(annotatedType.getJavaClass())), classTransformer);
  } else {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(annotatedType.getAnnotations()), classTransformer);
  }
}

public static <T> EnhancedAnnotatedType<T> of(SlimAnnotatedType<T> annotatedType, ClassTransformer classTransformer) {
  if (annotatedType instanceof BackedAnnotatedType<?>) {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(classTransformer.getReflectionCache().getDeclaredAnnotations(annotatedType.getJavaClass())), classTransformer);
  } else {
    return new EnhancedAnnotatedTypeImpl<T>(annotatedType, buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(annotatedType.getAnnotations()), classTransformer);
  }
}

Popular methods of SlimAnnotatedType

Popular in Java

Creating JSON documents from java classes using gson
getApplicationContext (Context)
getContentResolver (Context)
setScale (BigDecimal)
Returns a BigDecimal whose scale is the specified value, and whose value is numerically equal to thi
Menu (java.awt)
RandomAccessFile (java.io)
Allows reading from and writing to a file in a random-access manner. This is different from the uni-
Vector (java.util)
The Vector class implements a growable array of objects. Like an array, it contains components that
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Scheduler (org.quartz)
This is the main interface of a Quartz Scheduler. A Scheduler maintains a registery of org.quartz
Reflections (org.reflections)
Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t

How to use getJavaClassmethodin org.jboss.weld.annotated.slim.SlimAnnotatedType

Best Java code snippets using org.jboss.weld.annotated.slim.SlimAnnotatedType.getJavaClass (Showing top 20 results out of 315)

How to use
getJavaClass
method
in
org.jboss.weld.annotated.slim.SlimAnnotatedType