How to use

EnhancedAnnotationImpl

in

org.jboss.weld.annotated.enhanced.jlr

  @Override
  public EnhancedAnnotation<?> apply(Class<? extends Annotation> from) {
    SlimAnnotatedType<? extends Annotation> slimAnnotatedType = syntheticAnnotationsAnnotatedTypes.get(from);
    if (slimAnnotatedType == null) {
      // We do not recognize the BDA that defined the annotation This could in theory cause problem is two
      // annotations with the same name but different definition are defined within the same application (different
      // BDAs)
      slimAnnotatedType = getBackedAnnotatedType(from, AnnotatedTypeIdentifier.NULL_BDA_ID);
    }
    return EnhancedAnnotationImpl.create(slimAnnotatedType, ClassTransformer.this);
  }
}

/**
 * Gets a string representation of the annotation
 *
 * @return A string representation
 */
@Override
public String toString() {
  return getJavaClass().toString();
}

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

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (this == obj) {
      return true;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    EnhancedAnnotationImpl<?> that = cast(obj);
    return super.equals(that);
  }
}

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

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (this == obj) {
      return true;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    EnhancedAnnotationImpl<?> that = cast(obj);
    return super.equals(that);
  }
}

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

  @Override
  public EnhancedAnnotation<?> apply(Class<? extends Annotation> from) {
    SlimAnnotatedType<? extends Annotation> slimAnnotatedType = syntheticAnnotationsAnnotatedTypes.get(from);
    if (slimAnnotatedType == null) {
      // We do not recognize the BDA that defined the annotation This could in theory cause problem is two
      // annotations with the same name but different definition are defined within the same application (different
      // BDAs)
      slimAnnotatedType = getBackedAnnotatedType(from, AnnotatedTypeIdentifier.NULL_BDA_ID);
    }
    return EnhancedAnnotationImpl.create(slimAnnotatedType, ClassTransformer.this);
  }
}

/**
 * Gets a string representation of the annotation
 *
 * @return A string representation
 */
@Override
public String toString() {
  return getJavaClass().toString();
}

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (this == obj) {
      return true;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    EnhancedAnnotationImpl<?> that = cast(obj);
    return super.equals(that);
  }
}

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

  @Override
  public EnhancedAnnotation<?> apply(Class<? extends Annotation> from) {
    SlimAnnotatedType<? extends Annotation> slimAnnotatedType = syntheticAnnotationsAnnotatedTypes.get(from);
    if (slimAnnotatedType == null) {
      // We do not recognize the BDA that defined the annotation This could in theory cause problem is two
      // annotations with the same name but different definition are defined within the same application (different
      // BDAs)
      slimAnnotatedType = getBackedAnnotatedType(from, AnnotatedTypeIdentifier.NULL_BDA_ID);
    }
    return EnhancedAnnotationImpl.create(slimAnnotatedType, ClassTransformer.this);
  }
}

/**
 * Gets a string representation of the annotation
 *
 * @return A string representation
 */
@Override
public String toString() {
  return getJavaClass().toString();
}

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (this == obj) {
      return true;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    EnhancedAnnotationImpl<?> that = cast(obj);
    return super.equals(that);
  }
}

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

  @Override
  public EnhancedAnnotation<?> apply(Class<? extends Annotation> from) {
    SlimAnnotatedType<? extends Annotation> slimAnnotatedType = syntheticAnnotationsAnnotatedTypes.get(from);
    if (slimAnnotatedType == null) {
      // We do not recognize the BDA that defined the annotation This could in theory cause problem is two
      // annotations with the same name but different definition are defined within the same application (different
      // BDAs)
      slimAnnotatedType = getBackedAnnotatedType(from, AnnotatedTypeIdentifier.NULL_BDA_ID);
    }
    return EnhancedAnnotationImpl.create(slimAnnotatedType, ClassTransformer.this);
  }
}

/**
 * Gets a string representation of the annotation
 *
 * @return A string representation
 */
@Override
public String toString() {
  return getJavaClass().toString();
}

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (this == obj) {
      return true;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    EnhancedAnnotationImpl<?> that = cast(obj);
    return super.equals(that);
  }
}

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

  @Override
  public EnhancedAnnotation<?> apply(Class<? extends Annotation> from) {
    SlimAnnotatedType<? extends Annotation> slimAnnotatedType = syntheticAnnotationsAnnotatedTypes.get(from);
    if (slimAnnotatedType == null) {
      // We do not recognize the BDA that defined the annotation This could in theory cause problem is two
      // annotations with the same name but different definition are defined within the same application (different
      // BDAs)
      slimAnnotatedType = getBackedAnnotatedType(from, AnnotatedTypeIdentifier.NULL_BDA_ID);
    }
    return EnhancedAnnotationImpl.create(slimAnnotatedType, ClassTransformer.this);
  }
}