Author: dallen6 Date: 2009-12-07 21:39:38 -0500 (Mon, 07 Dec 2009) New Revision: 5220 Added: core/trunk/impl/src/main/java/org/jboss/weld/logging/messages/ValidatorMessage.java core/trunk/impl/src/main/resources/org/jboss/weld/messages/validator_en.properties Modified: core/trunk/impl/src/main/java/org/jboss/weld/InconsistentSpecializationException.java core/trunk/impl/src/main/java/org/jboss/weld/NullableDependencyException.java core/trunk/impl/src/main/java/org/jboss/weld/UnserializableDependencyException.java core/trunk/impl/src/main/java/org/jboss/weld/Validator.java Log: Final exception message conversions to localized messages Modified: core/trunk/impl/src/main/java/org/jboss/weld/InconsistentSpecializationException.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/InconsistentSpecializationException.java 2009-12-07 09:40:04 UTC (rev 5219) +++ core/trunk/impl/src/main/java/org/jboss/weld/InconsistentSpecializationException.java 2009-12-08 02:39:38 UTC (rev 5220) @@ -16,6 +16,9 @@ */ package org.jboss.weld; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import ch.qos.cal10n.IMessageConveyor; + /** * * @author Pete Muir @@ -25,6 +28,14 @@ private static final long serialVersionUID = 4359656880524913555L; + // Exception messages + private static final IMessageConveyor messageConveyer = loggerFactory().getMessageConveyor(); + + public <E extends Enum<?>> InconsistentSpecializationException(E key, Object... args) + { + super(messageConveyer.getMessage(key, args)); + } + public InconsistentSpecializationException() { super(); @@ -42,7 +53,7 @@ public InconsistentSpecializationException(Throwable throwable) { - super(throwable); + super(throwable.getLocalizedMessage(), throwable); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/NullableDependencyException.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/NullableDependencyException.java 2009-12-07 09:40:04 UTC (rev 5219) +++ core/trunk/impl/src/main/java/org/jboss/weld/NullableDependencyException.java 2009-12-08 02:39:38 UTC (rev 5220) @@ -16,6 +16,9 @@ */ package org.jboss.weld; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import ch.qos.cal10n.IMessageConveyor; + /** * Thrown if an injection point of primitive type resolves to a bean which may * be null @@ -27,6 +30,14 @@ private static final long serialVersionUID = 6877485218767005761L; + // Exception messages + private static final IMessageConveyor messageConveyer = loggerFactory().getMessageConveyor(); + + public <E extends Enum<?>> NullableDependencyException(E key, Object... args) + { + super(messageConveyer.getMessage(key, args)); + } + public NullableDependencyException() { super(); Modified: core/trunk/impl/src/main/java/org/jboss/weld/UnserializableDependencyException.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/UnserializableDependencyException.java 2009-12-07 09:40:04 UTC (rev 5219) +++ core/trunk/impl/src/main/java/org/jboss/weld/UnserializableDependencyException.java 2009-12-08 02:39:38 UTC (rev 5220) @@ -16,7 +16,10 @@ */ package org.jboss.weld; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import ch.qos.cal10n.IMessageConveyor; + /** * Thrown if a simple bean is dependent scoped and injected into a stateful * session bean, into a non-transient field, bean constructor parameter or @@ -30,6 +33,14 @@ private static final long serialVersionUID = -6287506607413810688L; + // Exception messages + private static final IMessageConveyor messageConveyer = loggerFactory().getMessageConveyor(); + + public <E extends Enum<?>> UnserializableDependencyException(E key, Object... args) + { + super(messageConveyer.getMessage(key, args)); + } + public UnserializableDependencyException() { super(); Modified: core/trunk/impl/src/main/java/org/jboss/weld/Validator.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/Validator.java 2009-12-07 09:40:04 UTC (rev 5219) +++ core/trunk/impl/src/main/java/org/jboss/weld/Validator.java 2009-12-08 02:39:38 UTC (rev 5220) @@ -16,6 +16,32 @@ */ package org.jboss.weld; +import static org.jboss.weld.logging.messages.ValidatorMessage.ALTERNATIVE_BEAN_CLASS_NOT_ANNOTATED; +import static org.jboss.weld.logging.messages.ValidatorMessage.ALTERNATIVE_BEAN_CLASS_SPECIFIED_MULTIPLE_TIMES; +import static org.jboss.weld.logging.messages.ValidatorMessage.ALTERNATIVE_STEREOTYPE_NOT_ANNOTATED; +import static org.jboss.weld.logging.messages.ValidatorMessage.ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES; +import static org.jboss.weld.logging.messages.ValidatorMessage.BEAN_SPECIALIZED_TOO_MANY_TIMES; +import static org.jboss.weld.logging.messages.ValidatorMessage.DECORATOR_CLASS_NOT_BEAN_CLASS_OF_DECORATOR; +import static org.jboss.weld.logging.messages.ValidatorMessage.DECORATOR_SPECIFIED_TWICE; +import static org.jboss.weld.logging.messages.ValidatorMessage.DISPOSAL_METHODS_WITHOUT_PRODUCER; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_INTO_NON_BEAN; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_INTO_NON_DEPENDENT_BEAN; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_NON_SERIALIZABLE_DEPENDENCY; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_HAS_WILDCARD; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_MUST_HAVE_TYPE_PARAMETER; +import static org.jboss.weld.logging.messages.ValidatorMessage.INJECTION_POINT_WITH_TYPE_VARIABLE; +import static org.jboss.weld.logging.messages.ValidatorMessage.INTERCEPTOR_NOT_ANNOTATED_OR_REGISTERED; +import static org.jboss.weld.logging.messages.ValidatorMessage.INTERCEPTOR_SPECIFIED_TWICE; +import static org.jboss.weld.logging.messages.ValidatorMessage.NEW_WITH_QUALIFIERS; +import static org.jboss.weld.logging.messages.ValidatorMessage.NON_SERIALIZABLE_BEAN_INJECTED_INTO_PASSIVATING_BEAN; +import static org.jboss.weld.logging.messages.ValidatorMessage.NOT_PROXYABLE; +import static org.jboss.weld.logging.messages.ValidatorMessage.PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR; +import static org.jboss.weld.logging.messages.ValidatorMessage.PASSIVATING_BEAN_WITH_NONSERIALIZABLE_INTERCEPTOR; + import java.lang.annotation.Annotation; import java.lang.reflect.ParameterizedType; import java.lang.reflect.TypeVariable; @@ -27,15 +53,12 @@ import java.util.HashSet; import java.util.List; import java.util.Set; -import java.util.Map; import javax.enterprise.context.Dependent; import javax.enterprise.event.Event; import javax.enterprise.inject.Alternative; -import javax.enterprise.inject.IllegalProductException; import javax.enterprise.inject.Instance; import javax.enterprise.inject.New; -import javax.enterprise.inject.UnproxyableResolutionException; import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.Decorator; import javax.enterprise.inject.spi.InjectionPoint; @@ -45,17 +68,16 @@ import org.jboss.interceptor.model.InterceptionModel; import org.jboss.weld.bean.AbstractClassBean; import org.jboss.weld.bean.AbstractProducerBean; -import org.jboss.weld.bean.DecoratorImpl; import org.jboss.weld.bean.DisposalMethod; import org.jboss.weld.bean.NewManagedBean; import org.jboss.weld.bean.NewSessionBean; import org.jboss.weld.bean.RIBean; import org.jboss.weld.bootstrap.BeanDeployerEnvironment; import org.jboss.weld.bootstrap.api.Service; -import org.jboss.weld.serialization.spi.helpers.SerializableContextual; import org.jboss.weld.introspector.WeldAnnotated; import org.jboss.weld.metadata.cache.MetaAnnotationStore; import org.jboss.weld.resolution.ResolvableWeldClass; +import org.jboss.weld.serialization.spi.helpers.SerializableContextual; import org.jboss.weld.util.Beans; import org.jboss.weld.util.Proxies; import org.jboss.weld.util.reflection.Reflections; @@ -82,7 +104,7 @@ boolean normalScoped = beanManager.getServices().get(MetaAnnotationStore.class).getScopeModel(bean.getScope()).isNormal(); if (normalScoped && !Beans.isBeanProxyable(bean)) { - throw new UnproxyableResolutionException("Normal scoped bean " + bean + " is not proxyable"); + throw new UnproxyableResolutionException(NOT_PROXYABLE, bean); } } @@ -105,7 +127,7 @@ { if (specializedBeans.contains(abstractBean.getSpecializedBean())) { - throw new InconsistentSpecializationException("Two beans cannot specialize the same bean: " + bean); + throw new InconsistentSpecializationException(BEAN_SPECIALIZED_TOO_MANY_TIMES, bean); } specializedBeans.add(abstractBean.getSpecializedBean()); } @@ -142,8 +164,7 @@ { if (!Reflections.isSerializable(interceptorClass)) { - throw new DeploymentException("The bean " + this + " declared a passivating scope, " + - "but has a non-serializable interceptor class: " + interceptorClass.getName()); + throw new DeploymentException(PASSIVATING_BEAN_WITH_NONSERIALIZABLE_INTERCEPTOR, this, interceptorClass.getName()); } InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) beanManager.createInjectionTarget(beanManager.createAnnotatedType(interceptorClass)); for (InjectionPoint injectionPoint: injectionTarget.getInjectionPoints()) @@ -168,8 +189,7 @@ { if (!Reflections.isSerializable(serializableContextual.get().getBeanClass())) { - throw new DeploymentException("The bean " + this + " declared a passivating scope " + - "but has a non-serializable interceptor: " + serializableContextual.get()); + throw new DeploymentException(PASSIVATING_BEAN_WITH_NONSERIALIZABLE_INTERCEPTOR, this, serializableContextual.get()); } for (InjectionPoint injectionPoint: serializableContextual.get().getInjectionPoints()) { @@ -187,7 +207,7 @@ { if (!Reflections.isSerializable(decorator.getBeanClass())) { - throw new UnserializableDependencyException("The bean " + classBean + " declares a passivating scope but has non-serializable decorator: " + decorator); + throw new UnserializableDependencyException(PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR, classBean, decorator); } for (InjectionPoint ij : decorator.getInjectionPoints()) { @@ -208,19 +228,19 @@ { if (ij.getAnnotated().getAnnotation(New.class) != null && ij.getQualifiers().size() > 1) { - throw new DefinitionException("The injection point " + ij + " is annotated with @New which cannot be combined with other binding types"); + throw new DefinitionException(NEW_WITH_QUALIFIERS, ij); } if (ij.getType().equals(InjectionPoint.class) && ij.getBean() == null) { - throw new DefinitionException("Cannot inject an Injection point into a class which isn't a bean " + ij); + throw new DefinitionException(INJECTION_INTO_NON_BEAN, ij); } if (ij.getType().equals(InjectionPoint.class) && !Dependent.class.equals(ij.getBean().getScope())) { - throw new DefinitionException("Cannot inject an InjectionPoint into a non @Dependent scoped bean " + ij); + throw new DefinitionException(INJECTION_INTO_NON_DEPENDENT_BEAN, ij); } if (ij.getType() instanceof TypeVariable<?>) { - throw new DefinitionException("Cannot declare an injection point with a type variable " + ij); + throw new DefinitionException(INJECTION_POINT_WITH_TYPE_VARIABLE, ij); } checkFacadeInjectionPoint(ij, Instance.class); checkFacadeInjectionPoint(ij, Event.class); @@ -229,20 +249,20 @@ Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getInjectableBeans(ij)); if (resolvedBeans.isEmpty()) { - throw new DeploymentException("Injection point has unstatisfied dependencies. Injection point: " + ij.toString() + "; Qualifiers: " + Arrays.toString(bindings)); + throw new DeploymentException(INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES, ij, Arrays.toString(bindings)); } if (resolvedBeans.size() > 1) { - throw new DeploymentException("Injection point has ambiguous dependencies. Injection point: " + ij.toString() + "; Qualifiers: " + Arrays.toString(bindings) +"; Possible dependencies: " + resolvedBeans); + throw new DeploymentException(INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES, ij, Arrays.toString(bindings) +"; Possible dependencies: " + resolvedBeans); } Bean<?> resolvedBean = (Bean<?>) resolvedBeans.iterator().next(); if (beanManager.getServices().get(MetaAnnotationStore.class).getScopeModel(resolvedBean.getScope()).isNormal() && !Proxies.isTypeProxyable(ij.getType())) { - throw new UnproxyableResolutionException("The injection point " + ij + " has non-proxyable dependencies"); + throw new UnproxyableResolutionException(INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES, ij); } if (Reflections.isPrimitive(annotatedItem.getJavaClass()) && resolvedBean.isNullable()) { - throw new NullableDependencyException("The injection point " + ij + " has nullable dependencies"); + throw new NullableDependencyException(INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES, ij); } if (ij.getBean() != null && Beans.isPassivatingScope(ij.getBean(), beanManager) && (!ij.isTransient()) && !Beans.isPassivationCapableBean(resolvedBean)) { @@ -256,9 +276,9 @@ { if (resolvedBean.getScope().equals(Dependent.class) && resolvedBean instanceof AbstractProducerBean<?, ?,?>) { - throw new IllegalProductException("The bean " + ij.getBean() + " declares a passivating scope but the producer returned a non-serializable bean for injection: " + resolvedBean); + throw new IllegalProductException(NON_SERIALIZABLE_BEAN_INJECTED_INTO_PASSIVATING_BEAN, ij.getBean(), resolvedBean); } - throw new UnserializableDependencyException("The bean " + ij.getBean() + " declares a passivating scope but has non-serializable dependency: " + resolvedBean); + throw new UnserializableDependencyException(INJECTION_POINT_HAS_NON_SERIALIZABLE_DEPENDENCY, ij.getBean(), resolvedBean); } } @@ -339,12 +359,11 @@ if (beanManager.getEnabledInterceptorClasses().indexOf(enabledInterceptorClass) < beanManager.getEnabledInterceptorClasses().lastIndexOf(enabledInterceptorClass)) { - throw new DeploymentException("Enabled interceptor class" + enabledInterceptorClass + " specified twice"); + throw new DeploymentException(INTERCEPTOR_SPECIFIED_TWICE, enabledInterceptorClass + " specified twice"); } if (!interceptorBeanClasses.contains(enabledInterceptorClass)) { - throw new DeploymentException("Enabled interceptor class " + enabledInterceptorClass - + " is neither annotated with @Interceptor, nor registered through a portable extension"); + throw new DeploymentException(INTERCEPTOR_NOT_ANNOTATED_OR_REGISTERED, enabledInterceptorClass); } } } @@ -361,11 +380,11 @@ { if (beanManager.getEnabledDecoratorClasses().indexOf(clazz) < beanManager.getEnabledDecoratorClasses().lastIndexOf(clazz)) { - throw new DeploymentException("Enabled decorator class" + clazz + " specified twice"); + throw new DeploymentException(DECORATOR_SPECIFIED_TWICE, clazz); } if (!decoratorBeanClasses.contains(clazz)) { - throw new DeploymentException("Enabled decorator class " + clazz + " is not the bean class of at least one decorator bean (detected decorator beans " + decoratorBeanClasses + ")"); + throw new DeploymentException(DECORATOR_CLASS_NOT_BEAN_CLASS_OF_DECORATOR, clazz, decoratorBeanClasses); } } } @@ -378,11 +397,11 @@ { if (!stereotype.isAnnotationPresent(Alternative.class)) { - throw new DeploymentException("Enabled alternative sterotype " + stereotype + " is not annotated @Alternative"); + throw new DeploymentException(ALTERNATIVE_STEREOTYPE_NOT_ANNOTATED, stereotype); } if (seenAlternatives.contains(stereotype)) { - throw new DeploymentException("Cannot enable the same alternative sterotype " + stereotype + " in beans.xml"); + throw new DeploymentException(ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES, stereotype); } seenAlternatives.add(stereotype); } @@ -390,11 +409,11 @@ { if (!clazz.isAnnotationPresent(Alternative.class)) { - throw new DeploymentException("Enabled alternative bean class " + clazz + " is not annotated @Alternative"); + throw new DeploymentException(ALTERNATIVE_BEAN_CLASS_NOT_ANNOTATED, clazz); } if (seenAlternatives.contains(clazz)) { - throw new DeploymentException("Cannot enable the same alternative bean class " + clazz + " in beans.xml"); + throw new DeploymentException(ALTERNATIVE_BEAN_CLASS_SPECIFIED_MULTIPLE_TIMES, clazz); } seenAlternatives.add(clazz); } @@ -405,7 +424,7 @@ Set<DisposalMethod<?, ?>> beans = environment.getUnresolvedDisposalBeans(); if (!beans.isEmpty()) { - throw new DefinitionException("The following Disposal methods were declared but did not resolved to a producer method " + beans); + throw new DefinitionException(DISPOSAL_METHODS_WITHOUT_PRODUCER, beans); } } @@ -418,16 +437,16 @@ ParameterizedType parameterizedType = (ParameterizedType) injectionPoint.getType(); if (parameterizedType.getActualTypeArguments()[0] instanceof TypeVariable<?>) { - throw new DefinitionException("An injection point of type " + type + " cannot have a type variable type parameter " + injectionPoint); + throw new DefinitionException(INJECTION_POINT_WITH_TYPE_VARIABLE, injectionPoint); } if (parameterizedType.getActualTypeArguments()[0] instanceof WildcardType) { - throw new DefinitionException("An injection point of type " + type + " cannot have a wildcard type parameter " + injectionPoint); + throw new DefinitionException(INJECTION_POINT_HAS_WILDCARD, type, injectionPoint); } } else { - throw new DefinitionException("An injection point of type " + type + " must have a type parameter " + injectionPoint); + throw new DefinitionException(INJECTION_POINT_MUST_HAVE_TYPE_PARAMETER, type, injectionPoint); } } Added: core/trunk/impl/src/main/java/org/jboss/weld/logging/messages/ValidatorMessage.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/logging/messages/ValidatorMessage.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/logging/messages/ValidatorMessage.java 2009-12-08 02:39:38 UTC (rev 5220) @@ -0,0 +1,67 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat, Inc. and/or its affiliates, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jboss.weld.logging.messages; + +import org.jboss.weld.logging.MessageId; + +import ch.qos.cal10n.BaseName; +import ch.qos.cal10n.Locale; +import ch.qos.cal10n.LocaleData; + +(a)BaseName(&quot;org.jboss.weld.messages.validator&quot;) +@LocaleData({ + @Locale("en") +}) +/** + * Log messages for validation related classes. + * + * Message IDs: 001400 - 001499 + * + * @author David Allen + * + */ +public enum ValidatorMessage +{ + @MessageId("001400") NOT_PROXYABLE, + @MessageId("001401") BEAN_SPECIALIZED_TOO_MANY_TIMES, + @MessageId("001402") PASSIVATING_BEAN_WITH_NONSERIALIZABLE_INTERCEPTOR, + @MessageId("001403") PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR, + @MessageId("001404") NEW_WITH_QUALIFIERS, + @MessageId("001405") INJECTION_INTO_NON_BEAN, + @MessageId("001406") INJECTION_INTO_NON_DEPENDENT_BEAN, + @MessageId("001407") INJECTION_POINT_WITH_TYPE_VARIABLE, + @MessageId("001408") INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES, + @MessageId("001409") INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES, + @MessageId("001410") INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES, + @MessageId("001411") INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES, + @MessageId("001412") NON_SERIALIZABLE_BEAN_INJECTED_INTO_PASSIVATING_BEAN, + @MessageId("001413") INJECTION_POINT_HAS_NON_SERIALIZABLE_DEPENDENCY, + @MessageId("001414") AMBIGUOUS_EL_NAME, + @MessageId("001415") BEAN_NAME_IS_PREFIX, + @MessageId("001416") INTERCEPTOR_SPECIFIED_TWICE, + @MessageId("001417") INTERCEPTOR_NOT_ANNOTATED_OR_REGISTERED, + @MessageId("001418") DECORATOR_SPECIFIED_TWICE, + @MessageId("001419") DECORATOR_CLASS_NOT_BEAN_CLASS_OF_DECORATOR, + @MessageId("001420") ALTERNATIVE_STEREOTYPE_NOT_ANNOTATED, + @MessageId("001421") ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES, + @MessageId("001422") ALTERNATIVE_BEAN_CLASS_NOT_ANNOTATED, + @MessageId("001423") ALTERNATIVE_BEAN_CLASS_SPECIFIED_MULTIPLE_TIMES, + @MessageId("001424") DISPOSAL_METHODS_WITHOUT_PRODUCER, + @MessageId("001425") INJECTION_POINT_HAS_WILDCARD, + @MessageId("001426") INJECTION_POINT_MUST_HAVE_TYPE_PARAMETER; +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/logging/messages/ValidatorMessage.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: core/trunk/impl/src/main/resources/org/jboss/weld/messages/validator_en.properties =================================================================== --- core/trunk/impl/src/main/resources/org/jboss/weld/messages/validator_en.properties (rev 0) +++ core/trunk/impl/src/main/resources/org/jboss/weld/messages/validator_en.properties 2009-12-08 02:39:38 UTC (rev 5220) @@ -0,0 +1,25 @@ +NOT_PROXYABLE=Normal scoped bean {0} is not proxyable +BEAN_SPECIALIZED_TOO_MANY_TIMES=Two beans cannot specialize the same bean {0} +PASSIVATING_BEAN_WITH_NONSERIALIZABLE_INTERCEPTOR=The bean {0} declared a passivating scope but has a non-serializable interceptor {1} +PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR=The bean {0} declared a passivating scope but has non-serializable decorator {1} +NEW_WITH_QUALIFIERS=The injection point {0} is annotated with @New which cannot be combined with other qualifiers +INJECTION_INTO_NON_BEAN=Cannot inject {0} in a class which isn't a bean +INJECTION_INTO_NON_DEPENDENT_BEAN=Cannot inject {0} in a non @Dependent scoped bean +INJECTION_POINT_WITH_TYPE_VARIABLE=Cannot declare an injection point with a type variable\: {0} +INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES=Injection point has unsatisfied dependencies. Injection point\: {0}; Qualifiers\: {1} +INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES=Injection point has ambiguous dependencies. Injection point\: {0}; Qualifiers\: {1} +INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES=The injection point {0} has non-proxyable dependencies +INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES=Injection point {0} has nullable dependencies +NON_SERIALIZABLE_BEAN_INJECTED_INTO_PASSIVATING_BEAN=The bean {0} declares passivating scope but the producer returned a non-serializable bean for injection\: {1} +INJECTION_POINT_HAS_NON_SERIALIZABLE_DEPENDENCY=The bean {0} declares passivating scope but has non-serializable dependency {1} +INTERCEPTOR_SPECIFIED_TWICE=Enabled interceptor class {0} specified twice +INTERCEPTOR_NOT_ANNOTATED_OR_REGISTERED=Enabled interceptor class {0} is neither annotated @Interceptor nor registered through a portable extension +DECORATOR_SPECIFIED_TWICE=Enabled decorator class {0} specified twice +DECORATOR_CLASS_NOT_BEAN_CLASS_OF_DECORATOR=Enabled decorator class {0} is not the bean class of at least one decorator bean (detected decorator beans {1}) +ALTERNATIVE_STEREOTYPE_NOT_ANNOTATED=Enabled alternative stereotype {0} is not annotated @Alternative +ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES=Cannot enable the same alternative stereotype {0} in beans.xml +ALTERNATIVE_BEAN_CLASS_NOT_ANNOTATED=Enabled alternative bean class {0} is not annotated @Alternative +ALTERNATIVE_BEAN_CLASS_SPECIFIED_MULTIPLE_TIMES=Cannot enable the same alternative bean class {0} in beans.xml +DISPOSAL_METHODS_WITHOUT_PRODUCER=The following disposal methods were declared but did not resolve to a producer method\: {0} +INJECTION_POINT_HAS_WILDCARD=An injection point of type {0} cannot have a wildcard type parameter\: {0} +INJECTION_POINT_MUST_HAVE_TYPE_PARAMETER=An injection point of type {0} must have a type parameter\: {1} Property changes on: core/trunk/impl/src/main/resources/org/jboss/weld/messages/validator_en.properties ___________________________________________________________________ Name: svn:mime-type + text/plain