org.jboss.weld.annotated.enhanced.jlr.EnhancedAnnotatedMethodImpl java code examples

Refine search

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 FileOutputStream f =File file;new FileOutputStream(file)
String name;new FileOutputStream(name)
File file;new FileOutputStream(file, true)
Smart code suggestions by Codota
}

public static <T, X, Y extends X> EnhancedAnnotatedMethodImpl<T, X> of(AnnotatedMethod<X> annotatedMethod, EnhancedAnnotatedType<Y> declaringClass, ClassTransformer classTransformer) {
  EnhancedAnnotatedType<X> downcastDeclaringType = Reflections.cast(declaringClass);
  return new EnhancedAnnotatedMethodImpl<T, X>(annotatedMethod, buildAnnotationMap(annotatedMethod.getAnnotations()), buildAnnotationMap(annotatedMethod.getAnnotations()), downcastDeclaringType, classTransformer);
}

public boolean isEquivalent(Method method) {
  return this.getDeclaringType().isEquivalent(method.getDeclaringClass()) && this.getName().equals(method.getName()) && Arrays.equals(this.getParameterTypesAsArray(), method.getParameterTypes());
}

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map
 *
 * @param annotationType The annotation type
 */
protected EnhancedAnnotationImpl(SlimAnnotatedType<T> annotatedType, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) {
  super(annotatedType, annotationMap, declaredAnnotationMap, classTransformer);
  this.clazz = annotatedType.getJavaClass();
  members = new HashSet<EnhancedAnnotatedMethod<?, ?>>();
  annotatedMembers = SetMultimap.newSetMultimap();
  for (AnnotatedMethod<? super T> annotatedMethod : annotatedType.getMethods()) {
    EnhancedAnnotatedMethod<?, ? super T> enhancedAnnotatedMethod = EnhancedAnnotatedMethodImpl.of(annotatedMethod, this, classTransformer);
    members.add(enhancedAnnotatedMethod);
    for (Annotation annotation : enhancedAnnotatedMethod.getAnnotations()) {
      annotatedMembers.put(annotation.annotationType(), enhancedAnnotatedMethod);
    }
  }
}

ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>();
Class<T> javaClass = annotatedType.getJavaClass();
      fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields()));
      if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
        EnhancedAnnotatedMethod<?, ? super T> weldMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
        declaredMethodsTemp.add(weldMethod);
        for (Annotation annotation : weldMethod.getAnnotations()) {
          declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod);
          if (weldMethod.getEnhancedParameters(annotationType).size() > 0) {
            declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod);
    for (Class<?> interfaceClazz : Reflections.getInterfaceClosure(javaClass)) {
        if(Reflections.isDefault(interfaceMethod.getJavaMember())) {
          methodsTemp.add((EnhancedAnnotatedMethod<?, ? super T>) interfaceMethod);
    EnhancedAnnotatedMethod<?, ? super T> enhancedMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
    methodsTemp.add(enhancedMethod);
    if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
      declaredMethodsTemp.add(enhancedMethod);
this.declaredMethodsByAnnotatedParameters = Multimaps.unmodifiableMultimap(declaredMethodsByAnnotatedParameters);

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map, sets the method
 * and declaring class abstraction and detects the actual type arguments
 *
 * @param method         The underlying method
 * @param declaringClass The declaring class abstraction
 */
private EnhancedAnnotatedMethodImpl(AnnotatedMethod<X> annotatedMethod, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, EnhancedAnnotatedType<X> declaringClass, ClassTransformer classTransformer) {
  super(annotatedMethod, annotationMap, declaredAnnotationMap, classTransformer, declaringClass);
  this.slim = annotatedMethod;
  ArrayList<EnhancedAnnotatedParameter<?, X>> parameters = new ArrayList<EnhancedAnnotatedParameter<?, X>>(annotatedMethod.getParameters().size());
  validateParameterCount(annotatedMethod);
  for (AnnotatedParameter<X> annotatedParameter : annotatedMethod.getParameters()) {
    EnhancedAnnotatedParameter<?, X> parameter = EnhancedAnnotatedParameterImpl.of(annotatedParameter, this, classTransformer);
    parameters.add(parameter);
  }
  this.parameters = immutableListView(parameters);
  String propertyName = Reflections.getPropertyName(getDelegate());
  if (propertyName == null) {
    this.propertyName = getName();
  } else {
    this.propertyName = propertyName;
  }
  this.signature = new MethodSignatureImpl(this);
}

public boolean isGeneric() {
  return getJavaMember().getTypeParameters().length > 0;
}

ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>();
Class<T> javaClass = annotatedType.getJavaClass();
      fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields()));
      if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
        EnhancedAnnotatedMethod<?, ? super T> weldMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
        declaredMethodsTemp.add(weldMethod);
        for (Annotation annotation : weldMethod.getAnnotations()) {
          declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod);
          if (weldMethod.getEnhancedParameters(annotationType).size() > 0) {
            declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod);
    for (Class<?> interfaceClazz : Reflections.getInterfaceClosure(javaClass)) {
        if(Reflections.isDefault(interfaceMethod.getJavaMember())) {
          methodsTemp.add((EnhancedAnnotatedMethod<?, ? super T>) interfaceMethod);
    EnhancedAnnotatedMethod<?, ? super T> enhancedMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
    methodsTemp.add(enhancedMethod);
    if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
      declaredMethodsTemp.add(enhancedMethod);
this.declaredMethodsByAnnotatedParameters = Multimaps.unmodifiableMultimap(declaredMethodsByAnnotatedParameters);

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map, sets the method
 * and declaring class abstraction and detects the actual type arguments
 *
 * @param method         The underlying method
 * @param declaringClass The declaring class abstraction
 */
private EnhancedAnnotatedMethodImpl(AnnotatedMethod<X> annotatedMethod, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, EnhancedAnnotatedType<X> declaringClass, ClassTransformer classTransformer) {
  super(annotatedMethod, annotationMap, declaredAnnotationMap, classTransformer, declaringClass);
  this.slim = annotatedMethod;
  ArrayList<EnhancedAnnotatedParameter<?, X>> parameters = new ArrayList<EnhancedAnnotatedParameter<?, X>>(annotatedMethod.getParameters().size());
  validateParameterCount(annotatedMethod);
  for (AnnotatedParameter<X> annotatedParameter : annotatedMethod.getParameters()) {
    EnhancedAnnotatedParameter<?, X> parameter = EnhancedAnnotatedParameterImpl.of(annotatedParameter, this, classTransformer);
    parameters.add(parameter);
  }
  this.parameters = immutableListView(parameters);
  String propertyName = Reflections.getPropertyName(getDelegate());
  if (propertyName == null) {
    this.propertyName = getName();
  } else {
    this.propertyName = propertyName;
  }
  this.signature = new MethodSignatureImpl(this);
}

public boolean isGeneric() {
  return getJavaMember().getTypeParameters().length > 0;
}

ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>();
Class<T> javaClass = annotatedType.getJavaClass();
      fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields()));
      if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
        EnhancedAnnotatedMethod<?, ? super T> weldMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
        declaredMethodsTemp.add(weldMethod);
        for (Annotation annotation : weldMethod.getAnnotations()) {
          declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod);
          if (weldMethod.getEnhancedParameters(annotationType).size() > 0) {
            declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod);
    for (Class<?> interfaceClazz : Reflections.getInterfaceClosure(javaClass)) {
        if(Reflections.isDefault(interfaceMethod.getJavaMember())) {
          methodsTemp.add((EnhancedAnnotatedMethod<?, ? super T>) interfaceMethod);
    EnhancedAnnotatedMethod<?, ? super T> enhancedMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
    methodsTemp.add(enhancedMethod);
    if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
      declaredMethodsTemp.add(enhancedMethod);
this.declaredMethodsByAnnotatedParameters = Multimaps.unmodifiableMultimap(declaredMethodsByAnnotatedParameters);
  declaredMetaAnnotationMap.put(declaredAnnotation.annotationType(), declaredAnnotation);

public static <T, X, Y extends X> EnhancedAnnotatedMethodImpl<T, X> of(AnnotatedMethod<X> annotatedMethod, EnhancedAnnotatedType<Y> declaringClass, ClassTransformer classTransformer) {
  EnhancedAnnotatedType<X> downcastDeclaringType = Reflections.cast(declaringClass);
  return new EnhancedAnnotatedMethodImpl<T, X>(annotatedMethod, buildAnnotationMap(annotatedMethod.getAnnotations()), buildAnnotationMap(annotatedMethod.getAnnotations()), downcastDeclaringType, classTransformer);
}

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map, sets the method
 * and declaring class abstraction and detects the actual type arguments
 *
 * @param method         The underlying method
 * @param declaringClass The declaring class abstraction
 */
private EnhancedAnnotatedMethodImpl(AnnotatedMethod<X> annotatedMethod, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, EnhancedAnnotatedType<X> declaringClass, ClassTransformer classTransformer) {
  super(annotatedMethod, annotationMap, declaredAnnotationMap, classTransformer, declaringClass);
  this.slim = annotatedMethod;
  ArrayList<EnhancedAnnotatedParameter<?, X>> parameters = new ArrayList<EnhancedAnnotatedParameter<?, X>>(annotatedMethod.getParameters().size());
  validateParameterCount(annotatedMethod);
  for (AnnotatedParameter<X> annotatedParameter : annotatedMethod.getParameters()) {
    EnhancedAnnotatedParameter<?, X> parameter = EnhancedAnnotatedParameterImpl.of(annotatedParameter, this, classTransformer);
    parameters.add(parameter);
  }
  this.parameters = immutableListView(parameters);
  String propertyName = Reflections.getPropertyName(getDelegate());
  if (propertyName == null) {
    this.propertyName = getName();
  } else {
    this.propertyName = propertyName;
  }
  this.signature = new MethodSignatureImpl(this);
}

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map
 *
 * @param annotationType The annotation type
 */
protected EnhancedAnnotationImpl(SlimAnnotatedType<T> annotatedType, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) {
  super(annotatedType, annotationMap, declaredAnnotationMap, classTransformer);
  this.clazz = annotatedType.getJavaClass();
  members = new HashSet<EnhancedAnnotatedMethod<?, ?>>();
  annotatedMembers = SetMultimap.newSetMultimap();
  for (AnnotatedMethod<? super T> annotatedMethod : annotatedType.getMethods()) {
    EnhancedAnnotatedMethod<?, ? super T> enhancedAnnotatedMethod = EnhancedAnnotatedMethodImpl.of(annotatedMethod, this, classTransformer);
    members.add(enhancedAnnotatedMethod);
    for (Annotation annotation : enhancedAnnotatedMethod.getAnnotations()) {
      annotatedMembers.put(annotation.annotationType(), enhancedAnnotatedMethod);
    }
  }
}

public boolean isEquivalent(Method method) {
  return this.getDeclaringType().isEquivalent(method.getDeclaringClass()) && this.getName().equals(method.getName()) && Arrays.equals(this.getParameterTypesAsArray(), method.getParameterTypes());
}

public boolean isGeneric() {
  return getJavaMember().getTypeParameters().length > 0;
}

ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>();
Class<T> javaClass = annotatedType.getJavaClass();
      fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields()));
      if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
        EnhancedAnnotatedMethod<?, ? super T> weldMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
        declaredMethodsTemp.add(weldMethod);
        for (Annotation annotation : weldMethod.getAnnotations()) {
          declaredAnnotatedMethods.put(annotation.annotationType(), weldMethod);
          if (weldMethod.getEnhancedParameters(annotationType).size() > 0) {
            declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod);
    for (Class<?> interfaceClazz : Reflections.getInterfaceClosure(javaClass)) {
        if(Reflections.isDefault(interfaceMethod.getJavaMember())) {
          methodsTemp.add((EnhancedAnnotatedMethod<?, ? super T>) interfaceMethod);
    EnhancedAnnotatedMethod<?, ? super T> enhancedMethod = EnhancedAnnotatedMethodImpl.of(method, this, classTransformer);
    methodsTemp.add(enhancedMethod);
    if (method.getJavaMember().getDeclaringClass().equals(javaClass)) {
      declaredMethodsTemp.add(enhancedMethod);
this.declaredMethodsByAnnotatedParameters = Multimaps.unmodifiableMultimap(declaredMethodsByAnnotatedParameters);

public static <T, X, Y extends X> EnhancedAnnotatedMethodImpl<T, X> of(AnnotatedMethod<X> annotatedMethod, EnhancedAnnotatedType<Y> declaringClass, ClassTransformer classTransformer) {
  EnhancedAnnotatedType<X> downcastDeclaringType = Reflections.cast(declaringClass);
  return new EnhancedAnnotatedMethodImpl<T, X>(annotatedMethod, buildAnnotationMap(annotatedMethod.getAnnotations()), buildAnnotationMap(annotatedMethod.getAnnotations()), downcastDeclaringType, classTransformer);
}

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map, sets the method
 * and declaring class abstraction and detects the actual type arguments
 *
 * @param method         The underlying method
 * @param declaringClass The declaring class abstraction
 */
private EnhancedAnnotatedMethodImpl(AnnotatedMethod<X> annotatedMethod, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, EnhancedAnnotatedType<X> declaringClass, ClassTransformer classTransformer) {
  super(annotatedMethod, annotationMap, declaredAnnotationMap, classTransformer, declaringClass);
  this.slim = annotatedMethod;
  ArrayList<EnhancedAnnotatedParameter<?, X>> parameters = new ArrayList<EnhancedAnnotatedParameter<?, X>>(annotatedMethod.getParameters().size());
  validateParameterCount(annotatedMethod);
  for (AnnotatedParameter<X> annotatedParameter : annotatedMethod.getParameters()) {
    EnhancedAnnotatedParameter<?, X> parameter = EnhancedAnnotatedParameterImpl.of(annotatedParameter, this, classTransformer);
    parameters.add(parameter);
  }
  this.parameters = immutableListView(parameters);
  String propertyName = Reflections.getPropertyName(getDelegate());
  if (propertyName == null) {
    this.propertyName = getName();
  } else {
    this.propertyName = propertyName;
  }
  this.signature = new MethodSignatureImpl(this);
}

/**
 * Constructor
 * <p/>
 * Initializes the superclass with the built annotation map
 *
 * @param annotationType The annotation type
 */
protected EnhancedAnnotationImpl(SlimAnnotatedType<T> annotatedType, Map<Class<? extends Annotation>, Annotation> annotationMap, Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) {
  super(annotatedType, annotationMap, declaredAnnotationMap, classTransformer);
  this.clazz = annotatedType.getJavaClass();
  members = new HashSet<EnhancedAnnotatedMethod<?, ?>>();
  annotatedMembers = SetMultimap.newSetMultimap();
  for (AnnotatedMethod<? super T> annotatedMethod : annotatedType.getMethods()) {
    EnhancedAnnotatedMethod<?, ? super T> enhancedAnnotatedMethod = EnhancedAnnotatedMethodImpl.of(annotatedMethod, this, classTransformer);
    members.add(enhancedAnnotatedMethod);
    for (Annotation annotation : enhancedAnnotatedMethod.getAnnotations()) {
      annotatedMembers.put(annotation.annotationType(), enhancedAnnotatedMethod);
    }
  }
}

public boolean isEquivalent(Method method) {
  return this.getDeclaringType().isEquivalent(method.getDeclaringClass()) && this.getName().equals(method.getName()) && Arrays.equals(this.getParameterTypesAsArray(), method.getParameterTypes());
}

Javadoc

Represents an annotated method

This class is immutable and therefore threadsafe

Most used methods

<init>
Constructor Initializes the superclass with the built annotation map, sets the method and declaring
buildAnnotationMap
getDeclaringType
getDelegate
getJavaMember
getName
getParameterTypesAsArray
of
validateParameterCount

Popular in Java

Start an intent from android
setContentView (Activity)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
getResourceAsStream (ClassLoader)
Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
Pointer (com.sun.jna)
An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
File (java.io)
An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
Filter (javax.servlet)
A filter is an object that performs filtering tasks on either the request to a resource (a servlet o

How to useEnhancedAnnotatedMethodImpl in org.jboss.weld.annotated.enhanced.jlr

Best Java code snippets using org.jboss.weld.annotated.enhanced.jlr.EnhancedAnnotatedMethodImpl (Showing top 20 results out of 315)

Refine search

How to use
EnhancedAnnotatedMethodImpl
in
org.jboss.weld.annotated.enhanced.jlr