org.jboss.weld.logging.ValidatorLogger_$logger Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of weld-servlet-shaded Show documentation
Show all versions of weld-servlet-shaded Show documentation
This jar bundles all the bits of Weld and CDI required for running in a Servlet container.
package org.jboss.weld.logging;
import java.io.Serializable;
import javax.annotation.Generated;
import org.jboss.logging.DelegatingBasicLogger;
import java.lang.String;
import java.lang.reflect.Method;
import org.jboss.logging.Logger;
import org.jboss.weld.exceptions.UnserializableDependencyException;
import org.jboss.weld.logging.WeldLogger;
import org.jboss.weld.exceptions.InconsistentSpecializationException;
import org.jboss.weld.exceptions.UnproxyableResolutionException;
import org.jboss.logging.BasicLogger;
import java.lang.Throwable;
import java.lang.Object;
import org.jboss.weld.exceptions.DeploymentException;
import org.jboss.weld.exceptions.DefinitionException;
import java.util.Arrays;
import org.jboss.weld.exceptions.IllegalArgumentException;
/**
* Warning this class consists of generated code.
*/
@Generated(value = "org.jboss.logging.processor.generator.model.MessageLoggerImplementor", date = "2018-11-27T10:11:32+0100")
public class ValidatorLogger_$logger extends DelegatingBasicLogger implements ValidatorLogger,org.jboss.weld.logging.WeldLogger,BasicLogger,Serializable {
private static final long serialVersionUID = 1L;
private static final String FQCN = ValidatorLogger_$logger.class.getName();
public ValidatorLogger_$logger(final Logger log) {
super(log);
}
private static final String beanSpecializedTooManyTimes = "WELD-001401: Two beans cannot specialize the same bean {0}";
protected String beanSpecializedTooManyTimes$str() {
return beanSpecializedTooManyTimes;
}
@Override
public final InconsistentSpecializationException beanSpecializedTooManyTimes(final Object param1) {
final InconsistentSpecializationException result = new InconsistentSpecializationException(java.text.MessageFormat.format(beanSpecializedTooManyTimes$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String passivatingBeanWithNonserializableInterceptor = "WELD-001402: The bean {0} declares a passivating scope but has a non-serializable interceptor {1}";
protected String passivatingBeanWithNonserializableInterceptor$str() {
return passivatingBeanWithNonserializableInterceptor;
}
@Override
public final DeploymentException passivatingBeanWithNonserializableInterceptor(final Object param1, final Object param2) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(passivatingBeanWithNonserializableInterceptor$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String passivatingBeanWithNonserializableDecorator = "WELD-001403: The bean {0} declares a passivating scope but has a non-serializable decorator {1}";
protected String passivatingBeanWithNonserializableDecorator$str() {
return passivatingBeanWithNonserializableDecorator;
}
@Override
public final UnserializableDependencyException passivatingBeanWithNonserializableDecorator(final Object param1, final Object param2) {
final UnserializableDependencyException result = new UnserializableDependencyException(java.text.MessageFormat.format(passivatingBeanWithNonserializableDecorator$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String newWithQualifiers = "WELD-001404: The injection point is annotated with @New which cannot be combined with other qualifiers: {0}\n\tat {1}\n StackTrace";
protected String newWithQualifiers$str() {
return newWithQualifiers;
}
@Override
public final DefinitionException newWithQualifiers(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(newWithQualifiers$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionIntoNonBean = "WELD-001405: Cannot inject {0} in a class which is not a bean\n\tat {1}\n StackTrace";
protected String injectionIntoNonBean$str() {
return injectionIntoNonBean;
}
@Override
public final DefinitionException injectionIntoNonBean(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionIntoNonBean$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionIntoNonDependentBean = "WELD-001406: Cannot inject injection point metadata in a non @Dependent scoped bean: {0}\n\tat {1}\n StackTrace";
protected String injectionIntoNonDependentBean$str() {
return injectionIntoNonDependentBean;
}
@Override
public final DefinitionException injectionIntoNonDependentBean(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionIntoNonDependentBean$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointWithTypeVariable = "WELD-001407: Cannot declare an injection point with a type variable: {0}\n\tat {1}\n StackTrace";
protected String injectionPointWithTypeVariable$str() {
return injectionPointWithTypeVariable;
}
@Override
public final DefinitionException injectionPointWithTypeVariable(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionPointWithTypeVariable$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointHasUnsatisfiedDependencies = "WELD-001408: Unsatisfied dependencies for type {2} with qualifiers {1}\n at injection point {0}\n at {3}\n{4}";
protected String injectionPointHasUnsatisfiedDependencies$str() {
return injectionPointHasUnsatisfiedDependencies;
}
@Override
public final DeploymentException injectionPointHasUnsatisfiedDependencies(final Object param1, final Object param2, final Object param3, final Object param4, final Object param5) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(injectionPointHasUnsatisfiedDependencies$str(), param1, param2, param3, param4, param5));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointHasAmbiguousDependencies = "WELD-001409: Ambiguous dependencies for type {2} with qualifiers {1}\n at injection point {0}\n at {3}\n Possible dependencies: {4}\n";
protected String injectionPointHasAmbiguousDependencies$str() {
return injectionPointHasAmbiguousDependencies;
}
@Override
public final DeploymentException injectionPointHasAmbiguousDependencies(final Object param1, final Object param2, final Object param3, final Object param4, final Object param5) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(injectionPointHasAmbiguousDependencies$str(), param1, param2, param3, param4, param5));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointHasNonProxyableDependencies = "WELD-001410: The injection point has non-proxyable dependencies: {0}\n\tat {1}\n StackTrace";
protected String injectionPointHasNonProxyableDependencies$str() {
return injectionPointHasNonProxyableDependencies;
}
@Override
public final DeploymentException injectionPointHasNonProxyableDependencies(final Object param1, final Object stackElement, final Throwable cause) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(injectionPointHasNonProxyableDependencies$str(), param1, stackElement), cause);
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointHasNonSerializableDependency = "WELD-001413: The bean {0} declares a passivating scope but has a non-passivation-capable dependency {1}";
protected String injectionPointHasNonSerializableDependency$str() {
return injectionPointHasNonSerializableDependency;
}
@Override
public final UnserializableDependencyException injectionPointHasNonSerializableDependency(final Object param1, final Object param2) {
final UnserializableDependencyException result = new UnserializableDependencyException(java.text.MessageFormat.format(injectionPointHasNonSerializableDependency$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String ambiguousElName = "WELD-001414: Bean name is ambiguous. Name {0} resolves to beans: {1}";
protected String ambiguousElName$str() {
return ambiguousElName;
}
@Override
public final DeploymentException ambiguousElName(final Object param1, final Object param2) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(ambiguousElName$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String beanNameIsPrefix = "WELD-001415: Bean name is identical to a bean name prefix used elsewhere. Name {0}";
protected String beanNameIsPrefix$str() {
return beanNameIsPrefix;
}
@Override
public final DeploymentException beanNameIsPrefix(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(beanNameIsPrefix$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorSpecifiedTwice = "WELD-001416: Enabled interceptor class {0} specified twice:\n - {1},\n - {2}";
protected String interceptorSpecifiedTwice$str() {
return interceptorSpecifiedTwice;
}
@Override
public final DeploymentException interceptorSpecifiedTwice(final Object param1, final Object param2, final Object param3) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(interceptorSpecifiedTwice$str(), param1, param2, param3));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorClassDoesNotMatchInterceptorBean = "WELD-001417: Enabled interceptor class {0} ({1}) does not match an interceptor bean: the class is not found, or not annotated with @Interceptor and still not registered through a portable extension, or not annotated with @Dependent inside an implicit bean archive";
protected String interceptorClassDoesNotMatchInterceptorBean$str() {
return interceptorClassDoesNotMatchInterceptorBean;
}
@Override
public final DeploymentException interceptorClassDoesNotMatchInterceptorBean(final Object value, final Object location) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(interceptorClassDoesNotMatchInterceptorBean$str(), value, location));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorSpecifiedTwice = "WELD-001418: Enabled decorator class {0} specified twice:\n - {1},\n - {2}";
protected String decoratorSpecifiedTwice$str() {
return decoratorSpecifiedTwice;
}
@Override
public final DeploymentException decoratorSpecifiedTwice(final Object param1, final Object param2, final Object param3) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(decoratorSpecifiedTwice$str(), param1, param2, param3));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorClassNotBeanClassOfDecorator = "WELD-001419: Enabled decorator class {0} is not the bean class of at least one decorator bean (detected decorator beans: {1})";
protected String decoratorClassNotBeanClassOfDecorator$str() {
return decoratorClassNotBeanClassOfDecorator;
}
@Override
public final DeploymentException decoratorClassNotBeanClassOfDecorator(final Object param1, final Object param2) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(decoratorClassNotBeanClassOfDecorator$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alternativeStereotypeNotStereotype = "WELD-001420: Enabled alternative {0} is not a stereotype";
protected String alternativeStereotypeNotStereotype$str() {
return alternativeStereotypeNotStereotype;
}
@Override
public final DeploymentException alternativeStereotypeNotStereotype(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeStereotypeNotStereotype$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alternativeStereotypeSpecifiedMultipleTimes = "WELD-001421: Cannot enable the same alternative stereotype {0} in beans.xml:\n - {1},\n - {2}";
protected String alternativeStereotypeSpecifiedMultipleTimes$str() {
return alternativeStereotypeSpecifiedMultipleTimes;
}
@Override
public final DeploymentException alternativeStereotypeSpecifiedMultipleTimes(final Object param1, final Object param2, final Object param3) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeStereotypeSpecifiedMultipleTimes$str(), param1, param2, param3));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alternativeBeanClassNotAnnotated = "WELD-001422: Enabled alternative class {0} ({1}) does not match any bean, or is not annotated with @Alternative or an @Alternative stereotype, or does not declare a producer annotated with @Alternative or an @Alternative stereotype";
protected String alternativeBeanClassNotAnnotated$str() {
return alternativeBeanClassNotAnnotated;
}
@Override
public final DeploymentException alternativeBeanClassNotAnnotated(final Object value, final Object location) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeBeanClassNotAnnotated$str(), value, location));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String disposalMethodsWithoutProducer = "WELD-001424: The following disposal methods were declared but did not resolve to a producer method: {0}";
protected String disposalMethodsWithoutProducer$str() {
return disposalMethodsWithoutProducer;
}
@Override
public final DefinitionException disposalMethodsWithoutProducer(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(disposalMethodsWithoutProducer$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointHasWildcard = "WELD-001425: An injection point cannot have a wildcard type parameter: {0}\n\tat {1}\n StackTrace";
protected String injectionPointHasWildcard$str() {
return injectionPointHasWildcard;
}
@Override
public final DefinitionException injectionPointHasWildcard(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionPointHasWildcard$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionPointMustHaveTypeParameter = "WELD-001426: An injection point must have a type parameter: {0}\n\tat {1}\n StackTrace";
protected String injectionPointMustHaveTypeParameter$str() {
return injectionPointMustHaveTypeParameter;
}
@Override
public final DefinitionException injectionPointMustHaveTypeParameter(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionPointMustHaveTypeParameter$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String nonFieldInjectionPointCannotUseNamed = "WELD-001427: Only field injection points can use the @Named qualifier with no value: {0}\n\tat {1}\n StackTrace";
protected String nonFieldInjectionPointCannotUseNamed$str() {
return nonFieldInjectionPointCannotUseNamed;
}
@Override
public final DefinitionException nonFieldInjectionPointCannotUseNamed(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(nonFieldInjectionPointCannotUseNamed$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorsCannotHaveProducerMethods = "WELD-001428: A decorator cannot have producer methods, but at least one was found on {0}.";
protected String decoratorsCannotHaveProducerMethods$str() {
return decoratorsCannotHaveProducerMethods;
}
@Override
public final DefinitionException decoratorsCannotHaveProducerMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(decoratorsCannotHaveProducerMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorsCannotHaveProducerFields = "WELD-001429: A decorator cannot have producer fields, but at least one was found on {0}.";
protected String decoratorsCannotHaveProducerFields$str() {
return decoratorsCannotHaveProducerFields;
}
@Override
public final DefinitionException decoratorsCannotHaveProducerFields(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(decoratorsCannotHaveProducerFields$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorsCannotHaveDisposerMethods = "WELD-001430: A decorator cannot have disposer methods, but at least one was found on {0}.";
protected String decoratorsCannotHaveDisposerMethods$str() {
return decoratorsCannotHaveDisposerMethods;
}
@Override
public final DefinitionException decoratorsCannotHaveDisposerMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(decoratorsCannotHaveDisposerMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorsCannotHaveProducerMethods = "WELD-001431: An interceptor cannot have producer methods, but at least one was found on {0}.";
protected String interceptorsCannotHaveProducerMethods$str() {
return interceptorsCannotHaveProducerMethods;
}
@Override
public final DefinitionException interceptorsCannotHaveProducerMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorsCannotHaveProducerMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorsCannotHaveProducerFields = "WELD-001432: An interceptor cannot have producer fields, but at least one was found on {0}.";
protected String interceptorsCannotHaveProducerFields$str() {
return interceptorsCannotHaveProducerFields;
}
@Override
public final DefinitionException interceptorsCannotHaveProducerFields(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorsCannotHaveProducerFields$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorsCannotHaveDisposerMethods = "WELD-001433: An interceptor cannot have disposer methods, but at least one was found on {0}.";
protected String interceptorsCannotHaveDisposerMethods$str() {
return interceptorsCannotHaveDisposerMethods;
}
@Override
public final DefinitionException interceptorsCannotHaveDisposerMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorsCannotHaveDisposerMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notProxyableUnknown = "WELD-001434: Normal scoped bean {0} is not proxyable for an unknown reason - {1}.";
protected String notProxyableUnknown$str() {
return notProxyableUnknown;
}
@Override
public final UnproxyableResolutionException notProxyableUnknown(final Object param1, final Object param2) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyableUnknown$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notProxyableNoConstructor = "WELD-001435: Normal scoped bean {0} is not proxyable because it has no no-args constructor - {1}.";
protected String notProxyableNoConstructor$str() {
return notProxyableNoConstructor;
}
@Override
public final UnproxyableResolutionException notProxyableNoConstructor(final Object param1, final Object param2) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyableNoConstructor$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notProxyablePrivateConstructor = "WELD-001436: Type {0} is not proxyable because it has a private constructor {1} - {2}.";
protected String notProxyablePrivateConstructor$str() {
return notProxyablePrivateConstructor;
}
@Override
public final String notProxyablePrivateConstructor(final Object param1, final Object param2, final Object param3) {
return java.text.MessageFormat.format(notProxyablePrivateConstructor$str(), param1, param2, param3);
}
private static final String notProxyableFinalType = "WELD-001437: Bean type {0} is not proxyable because it is final - {1}.";
protected String notProxyableFinalType$str() {
return notProxyableFinalType;
}
@Override
public final UnproxyableResolutionException notProxyableFinalType(final Object param1, final Object param2) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyableFinalType$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notProxyablePrimitive = "WELD-001438: Bean type {0} is not proxyable because it is a primitive - {1}.";
protected String notProxyablePrimitive$str() {
return notProxyablePrimitive;
}
@Override
public final UnproxyableResolutionException notProxyablePrimitive(final Object param1, final Object param2) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyablePrimitive$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notProxyableArrayType = "WELD-001439: Bean type {0} is not proxyable because it is an array type - {1}.";
protected String notProxyableArrayType$str() {
return notProxyableArrayType;
}
@Override
public final UnproxyableResolutionException notProxyableArrayType(final Object param1, final Object param2) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyableArrayType$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void scopeAnnotationOnInjectionPoint(final Object param1, final Object param2, final Object stackElement) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, scopeAnnotationOnInjectionPoint$str(), param1, param2, stackElement);
}
private static final String scopeAnnotationOnInjectionPoint = "WELD-001440: Scope type {0} used on injection point {1}\n\tat {2}\n StackTrace";
protected String scopeAnnotationOnInjectionPoint$str() {
return scopeAnnotationOnInjectionPoint;
}
private static final String alternativeBeanClassNotClass = "WELD-001441: Enabled alternative {0} is not a class";
protected String alternativeBeanClassNotClass$str() {
return alternativeBeanClassNotClass;
}
@Override
public final DeploymentException alternativeBeanClassNotClass(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeBeanClassNotClass$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alternativeStereotypeNotAnnotated = "WELD-001442: Enabled alternative {0} is not annotated @Alternative";
protected String alternativeStereotypeNotAnnotated$str() {
return alternativeStereotypeNotAnnotated;
}
@Override
public final DeploymentException alternativeStereotypeNotAnnotated(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeStereotypeNotAnnotated$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String pseudoScopedBeanHasCircularReferences = "WELD-001443: Pseudo scoped bean has circular dependencies. Dependency path: {0}";
protected String pseudoScopedBeanHasCircularReferences$str() {
return pseudoScopedBeanHasCircularReferences;
}
@Override
public final DeploymentException pseudoScopedBeanHasCircularReferences(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(pseudoScopedBeanHasCircularReferences$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorsCannotHaveObserverMethods = "WELD-001445: An interceptor cannot have observer methods, but at least one was found on {0}.";
protected String interceptorsCannotHaveObserverMethods$str() {
return interceptorsCannotHaveObserverMethods;
}
@Override
public final DefinitionException interceptorsCannotHaveObserverMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorsCannotHaveObserverMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String decoratorsCannotHaveObserverMethods = "WELD-001446: A decorator cannot have observer methods, but at least one was found on {0}.";
protected String decoratorsCannotHaveObserverMethods$str() {
return decoratorsCannotHaveObserverMethods;
}
@Override
public final DefinitionException decoratorsCannotHaveObserverMethods(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(decoratorsCannotHaveObserverMethods$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDoesNotReturnObject = "WELD-001447: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but it does not return {3}\n\tat {4}\n StackTrace";
protected String interceptorMethodDoesNotReturnObject$str() {
return interceptorMethodDoesNotReturnObject;
}
@Override
public final DefinitionException interceptorMethodDoesNotReturnObject(final Object param1, final Object param2, final Object param3, final Object param4, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDoesNotReturnObject$str(), param1, param2, param3, param4, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDoesNotHaveExactlyOneParameter = "WELD-001448: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but it does not have exactly one parameter\n\tat {3}\n StackTrace";
protected String interceptorMethodDoesNotHaveExactlyOneParameter$str() {
return interceptorMethodDoesNotHaveExactlyOneParameter;
}
@Override
public final DefinitionException interceptorMethodDoesNotHaveExactlyOneParameter(final Object param1, final Object param2, final Object param3, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDoesNotHaveExactlyOneParameter$str(), param1, param2, param3, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDoesNotHaveCorrectTypeOfParameter = "WELD-001449: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but its single parameter is not a {3}\n\tat {4}\n StackTrace";
protected String interceptorMethodDoesNotHaveCorrectTypeOfParameter$str() {
return interceptorMethodDoesNotHaveCorrectTypeOfParameter;
}
@Override
public final DefinitionException interceptorMethodDoesNotHaveCorrectTypeOfParameter(final Object param1, final Object param2, final Object param3, final Object param4, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDoesNotHaveCorrectTypeOfParameter$str(), param1, param2, param3, param4, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String userTransactionInjectionIntoBeanWithContainerManagedTransactions = "WELD-001451: javax.transaction.UserTransaction cannot be injected into an enterprise bean with container-managed transactions: {0}\n\tat {1}\n StackTrace";
protected String userTransactionInjectionIntoBeanWithContainerManagedTransactions$str() {
return userTransactionInjectionIntoBeanWithContainerManagedTransactions;
}
@Override
public final DefinitionException userTransactionInjectionIntoBeanWithContainerManagedTransactions(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(userTransactionInjectionIntoBeanWithContainerManagedTransactions$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidBeanMetadataInjectionPointType = "WELD-001452: {0} is not a valid type for a Bean metadata injection point {1}\n\tat {2}\n StackTrace";
protected String invalidBeanMetadataInjectionPointType$str() {
return invalidBeanMetadataInjectionPointType;
}
@Override
public final DefinitionException invalidBeanMetadataInjectionPointType(final Object param1, final Object param2, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(invalidBeanMetadataInjectionPointType$str(), param1, param2, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidBeanMetadataInjectionPointTypeArgument = "WELD-001453: {0} is not a valid type argument for a Bean metadata injection point {1}\n\tat {2}\n StackTrace";
protected String invalidBeanMetadataInjectionPointTypeArgument$str() {
return invalidBeanMetadataInjectionPointTypeArgument;
}
@Override
public final DefinitionException invalidBeanMetadataInjectionPointTypeArgument(final Object param1, final Object param2, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(invalidBeanMetadataInjectionPointTypeArgument$str(), param1, param2, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidBeanMetadataInjectionPointQualifier = "WELD-001454: {0} cannot be used at a Bean metadata injection point of a bean which is not {1}, {2}\n\tat {3}\n StackTrace";
protected String invalidBeanMetadataInjectionPointQualifier$str() {
return invalidBeanMetadataInjectionPointQualifier;
}
@Override
public final DefinitionException invalidBeanMetadataInjectionPointQualifier(final Object param1, final Object param2, final Object param3, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(invalidBeanMetadataInjectionPointQualifier$str(), param1, param2, param3, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String noDecoratedTypes = "WELD-001455: {0} does not declare any decorated types.";
protected String noDecoratedTypes$str() {
return noDecoratedTypes;
}
@Override
public final DefinitionException noDecoratedTypes(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(noDecoratedTypes$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String argumentNull1 = "WELD-001456: Argument {0} must not be null";
protected String argumentNull1$str() {
return argumentNull1;
}
@Override
public final IllegalArgumentException argumentNull(final Object param1) {
final IllegalArgumentException result = new IllegalArgumentException(java.text.MessageFormat.format(argumentNull1$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alternativeClassSpecifiedMultipleTimes = "WELD-001457: Cannot enable the same alternative class {0} in beans.xml:\n - {1},\n - {2}";
protected String alternativeClassSpecifiedMultipleTimes$str() {
return alternativeClassSpecifiedMultipleTimes;
}
@Override
public final DeploymentException alternativeClassSpecifiedMultipleTimes(final Object param1, final Object param2, final Object param3) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(alternativeClassSpecifiedMultipleTimes$str(), param1, param2, param3));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String beanWithPassivatingScopeNotPassivationCapable = "WELD-001463: Bean declaring a passivating scope must be passivation capable. Bean: {0}";
protected String beanWithPassivatingScopeNotPassivationCapable$str() {
return beanWithPassivatingScopeNotPassivationCapable;
}
@Override
public final DeploymentException beanWithPassivatingScopeNotPassivationCapable(final Object param1) {
final DeploymentException result = new DeploymentException(java.text.MessageFormat.format(beanWithPassivatingScopeNotPassivationCapable$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String builtinBeanWithNonserializableDecorator = "WELD-001465: {0} for a built-in bean {1} must be passivation capable.";
protected String builtinBeanWithNonserializableDecorator$str() {
return builtinBeanWithNonserializableDecorator;
}
@Override
public final UnserializableDependencyException builtinBeanWithNonserializableDecorator(final Object param1, final Object param2) {
final UnserializableDependencyException result = new UnserializableDependencyException(java.text.MessageFormat.format(builtinBeanWithNonserializableDecorator$str(), param1, param2));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String injectionIntoDisposerMethod = "WELD-001466: Invalid injection point found in a disposer method: {0}\n\tat {1}\n StackTrace";
protected String injectionIntoDisposerMethod$str() {
return injectionIntoDisposerMethod;
}
@Override
public final DefinitionException injectionIntoDisposerMethod(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(injectionIntoDisposerMethod$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDoesNotReturnObjectOrVoid = "WELD-001467: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but it does not return {3} or {4}.\n\tat {5}\n StackTrace";
protected String interceptorMethodDoesNotReturnObjectOrVoid$str() {
return interceptorMethodDoesNotReturnObjectOrVoid;
}
@Override
public final DefinitionException interceptorMethodDoesNotReturnObjectOrVoid(final Object param1, final Object param2, final Object param3, final Object param4, final Object param5, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDoesNotReturnObjectOrVoid$str(), param1, param2, param3, param4, param5, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDoesNotHaveVoidReturnType = "WELD-001468: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but it does not have a {3} return type.\n\tat {4}\n StackTrace";
protected String interceptorMethodDoesNotHaveVoidReturnType$str() {
return interceptorMethodDoesNotHaveVoidReturnType;
}
@Override
public final DefinitionException interceptorMethodDoesNotHaveVoidReturnType(final Object param1, final Object param2, final Object param3, final Object param4, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDoesNotHaveVoidReturnType$str(), param1, param2, param3, param4, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void interceptorMethodDoesNotHaveZeroParameters(final Object param1, final Object param2, final Object param3) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, interceptorMethodDoesNotHaveZeroParameters$str(), param1, param2, param3);
}
private static final String interceptorMethodDoesNotHaveZeroParameters = "WELD-001469: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} but it does not have zero parameters.\n";
protected String interceptorMethodDoesNotHaveZeroParameters$str() {
return interceptorMethodDoesNotHaveZeroParameters;
}
@Override
public final void interceptorMethodShouldNotThrowCheckedExceptions(final Object param1, final Object param2, final Object param3, final Object stackElement) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, interceptorMethodShouldNotThrowCheckedExceptions$str(), param1, param2, param3, stackElement);
}
private static final String interceptorMethodShouldNotThrowCheckedExceptions = "WELD-001471: Interceptor method {0} defined on class {1} is not defined according to the specification. It should not throw {2}, which is a checked exception.\n\tat {3}\n StackTrace";
protected String interceptorMethodShouldNotThrowCheckedExceptions$str() {
return interceptorMethodShouldNotThrowCheckedExceptions;
}
private static final String eventMetadataInjectedOutsideOfObserver = "WELD-001472: EventMetadata can only be injected into an observer method: {0}\n\tat {1}\n StackTrace";
protected String eventMetadataInjectedOutsideOfObserver$str() {
return eventMetadataInjectedOutsideOfObserver;
}
@Override
public final DefinitionException eventMetadataInjectedOutsideOfObserver(final Object param1, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(eventMetadataInjectedOutsideOfObserver$str(), param1, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void beanNotPassivationCapable(final Object param1) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, beanNotPassivationCapable$str(), param1);
}
private static final String beanNotPassivationCapable = "WELD-001473: javax.enterprise.inject.spi.Bean implementation {0} declared a normal scope but does not implement javax.enterprise.inject.spi.PassivationCapable. It won'''t be possible to inject this bean into a bean with a passivating scope (@SessionScoped, @ConversationScoped). This can be fixed by assigning the Bean implementation a unique id by implementing the PassivationCapable interface.";
protected String beanNotPassivationCapable$str() {
return beanNotPassivationCapable;
}
private static final String unsatisfiedDependencyBecauseClassIgnored = "WELD-001474: Class {0} is on the classpath, but was ignored because a class it references was not found: {1}.\n";
protected String unsatisfiedDependencyBecauseClassIgnored$str() {
return unsatisfiedDependencyBecauseClassIgnored;
}
@Override
public final String unsatisfiedDependencyBecauseClassIgnored(final Object param1, final Object param2) {
return java.text.MessageFormat.format(unsatisfiedDependencyBecauseClassIgnored$str(), param1, param2);
}
private static final String unsatisfiedDependencyBecauseQualifiersDontMatch = "WELD-001475: The following beans match by type, but none have matching qualifiers:{0}\n";
protected String unsatisfiedDependencyBecauseQualifiersDontMatch$str() {
return unsatisfiedDependencyBecauseQualifiersDontMatch;
}
@Override
public final String unsatisfiedDependencyBecauseQualifiersDontMatch(final Object param1) {
return java.text.MessageFormat.format(unsatisfiedDependencyBecauseQualifiersDontMatch$str(), param1);
}
private static final String interceptorOrDecoratorMustBeDependent = "WELD-001476: {0} must be @Dependent";
protected String interceptorOrDecoratorMustBeDependent$str() {
return interceptorOrDecoratorMustBeDependent;
}
@Override
public final DefinitionException interceptorOrDecoratorMustBeDependent(final Object param1) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorOrDecoratorMustBeDependent$str(), param1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorDecoratorInjectionPointHasNonSerializableDependency = "WELD-001477: The bean {0} declares a passivating scope but has a(n) {1} with a non-passivation-capable dependency {2}";
protected String interceptorDecoratorInjectionPointHasNonSerializableDependency$str() {
return interceptorDecoratorInjectionPointHasNonSerializableDependency;
}
@Override
public final UnserializableDependencyException interceptorDecoratorInjectionPointHasNonSerializableDependency(final Object param1, final Object param2, final Object param3) {
final UnserializableDependencyException result = new UnserializableDependencyException(java.text.MessageFormat.format(interceptorDecoratorInjectionPointHasNonSerializableDependency$str(), param1, param2, param3));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void interceptorEnabledForApplicationAndBeanArchive(final Object interceptor, final Object beanArchive) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, interceptorEnabledForApplicationAndBeanArchive$str(), interceptor, beanArchive);
}
private static final String interceptorEnabledForApplicationAndBeanArchive = "WELD-001478: Interceptor {0} is enabled for the application and for the bean archive {1}. It will only be invoked in the @Priority part of the chain.";
protected String interceptorEnabledForApplicationAndBeanArchive$str() {
return interceptorEnabledForApplicationAndBeanArchive;
}
@Override
public final void decoratorEnabledForApplicationAndBeanArchive(final Object decorator, final Object beanArchive) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, decoratorEnabledForApplicationAndBeanArchive$str(), decorator, beanArchive);
}
private static final String decoratorEnabledForApplicationAndBeanArchive = "WELD-001479: Decorator {0} is enabled for the application and for the bean archive {1}. It will only be invoked in the @Priority part of the chain.";
protected String decoratorEnabledForApplicationAndBeanArchive$str() {
return decoratorEnabledForApplicationAndBeanArchive;
}
private static final String notProxyableFinalMethod = "WELD-001480: Bean type {0} is not proxyable because it contains a final method {1} - {2}.";
protected String notProxyableFinalMethod$str() {
return notProxyableFinalMethod;
}
@Override
public final UnproxyableResolutionException notProxyableFinalMethod(final Object beanType, final Method finalMethod, final Object declaringBean) {
final UnproxyableResolutionException result = new UnproxyableResolutionException(java.text.MessageFormat.format(notProxyableFinalMethod$str(), beanType, finalMethod, declaringBean));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void notProxyableFinalMethodIgnored(final Method invalidMethod, final Object declaringBean) {
super.log.logv(FQCN, org.jboss.logging.Logger.Level.WARN, null, notProxyableFinalMethodIgnored$str(), invalidMethod, declaringBean);
}
private static final String notProxyableFinalMethodIgnored = "WELD-001481: Final method will be ignored during proxy generation and should never be invoked upon the proxy instance! {0} - {1}.";
protected String notProxyableFinalMethodIgnored$str() {
return notProxyableFinalMethodIgnored;
}
private static final String invalidInterceptionFactoryInjectionPoint = "WELD-001482: InterceptionFactory can only be injected in a parameter of a producer method: {0}\n\tat {1}\n StackTrace";
protected String invalidInterceptionFactoryInjectionPoint$str() {
return invalidInterceptionFactoryInjectionPoint;
}
@Override
public final DefinitionException invalidInterceptionFactoryInjectionPoint(final Object injectionPoint, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(invalidInterceptionFactoryInjectionPoint$str(), injectionPoint, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String argumentNull0 = "WELD-001483: Argument must not be null";
protected String argumentNull0$str() {
return argumentNull0;
}
@Override
public final IllegalArgumentException argumentNull() {
final IllegalArgumentException result = new IllegalArgumentException(argumentNull0$str());
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String interceptorMethodDeclaresMultipleParameters = "WELD-001485: Method {0} defined on class {1} is not defined according to the specification. It is annotated with @{2} and it declares more than one parameter.\n\tat {3}\n StackTrace";
protected String interceptorMethodDeclaresMultipleParameters$str() {
return interceptorMethodDeclaresMultipleParameters;
}
@Override
public final DefinitionException interceptorMethodDeclaresMultipleParameters(final Object param1, final Object param2, final Object param3, final Object stackElement) {
final DefinitionException result = new DefinitionException(java.text.MessageFormat.format(interceptorMethodDeclaresMultipleParameters$str(), param1, param2, param3, stackElement));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
@Override
public final void catchingDebug(final Throwable throwable) {
super.log.logf(FQCN, org.jboss.logging.Logger.Level.DEBUG, throwable, catchingDebug$str());
}
private static final String catchingDebug = "Catching";
protected String catchingDebug$str() {
return catchingDebug;
}
}