org.jboss.weld.annotated.enhanced.EnhancedAnnotatedType.getNoArgsEnhancedConstructor 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 checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
    return;
  }
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
  } else if (constructor.isPrivate()) {
    throw BeanLogger.LOG
        .decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
  }
}

public EnhancedAnnotatedConstructor<T> getNoArgsEnhancedConstructor() {
  return delegate().getNoArgsEnhancedConstructor();
}

public EnhancedAnnotatedConstructor<T> getNoArgsEnhancedConstructor() {
  return delegate().getNoArgsEnhancedConstructor();
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(ObservesAsync.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@ObservesAsync", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(ObservesAsync.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@ObservesAsync", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(ObservesAsync.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@ObservesAsync", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(ObservesAsync.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@ObservesAsync", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructor(EnhancedAnnotatedType<T> type) {
  Collection<EnhancedAnnotatedConstructor<T>> initializerAnnotatedConstructors = type
      .getEnhancedConstructors(Inject.class);
  BeanLogger.LOG.foundInjectableConstructors(initializerAnnotatedConstructors, type);
  EnhancedAnnotatedConstructor<T> constructor = null;
  if (initializerAnnotatedConstructors.size() > 1) {
    throw UtilLogger.LOG.ambiguousConstructor(type, initializerAnnotatedConstructors);
  } else if (initializerAnnotatedConstructors.size() == 1) {
    constructor = initializerAnnotatedConstructors.iterator().next();
    BeanLogger.LOG.foundOneInjectableConstructor(constructor, type);
  } else if (type.getNoArgsEnhancedConstructor() != null) {
    constructor = type.getNoArgsEnhancedConstructor();
    BeanLogger.LOG.foundDefaultConstructor(constructor, type);
  }
  if (constructor != null) {
    if (!constructor.getEnhancedParameters(Disposes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Disposes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(Observes.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@Observes", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
    if (!constructor.getEnhancedParameters(ObservesAsync.class).isEmpty()) {
      throw BeanLogger.LOG.parameterAnnotationNotAllowedOnConstructor("@ObservesAsync", constructor,
          Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
  return constructor;
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

protected void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) {
  EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor();
  if (constructor == null) {
    if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) {
      // Relaxed construction allows us to bypass non-existent no-arg constructor
      return;
    } else {
      // Without relaxed contruction, CDI enforces existence of no-arg constructor
      throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this);
    }
  } else {
    if (constructor.isPrivate()) {
      // Private no-arg constructor is a problem while creating the decorator and we have to blow up
      throw BeanLogger.LOG.decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember()));
    }
  }
}

Javadoc

Gets the no-args constructor

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
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
getDeclaredMetaAnnotations
Gets all annotations which are declared on this annotated item with the given meta annotation type

Popular in Java

Updating database using SQL prepared statement
getSystemService (Context)
setContentView (Activity)
getSharedPreferences (Context)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
SortedSet (java.util)
SortedSet is a Set which iterates over its elements in a sorted order. The order is determined eithe
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr
StringUtils (org.apache.commons.lang)
Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin
Top 17 Free Sublime Text Plugins

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

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

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