• Home
• org.jboss.weld.se
• weld-se-shaded
• 3.0.0.Alpha17
• source code
• BeanLogger_$logger.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jboss.weld.logging.BeanLogger_$logger Maven / Gradle / Ivy

package org.jboss.weld.logging;

import java.io.Serializable;
import javax.annotation.Generated;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.DelegatingBasicLogger;
import org.jboss.logging.Logger;


/**
 * Warning this class consists of generated code.
 * 
 */
@Generated(value = "org.jboss.logging.processor.generator.model.MessageLoggerImplementor", date = "2016-09-13T11:41:24+0200")
public class BeanLogger_$logger
    extends DelegatingBasicLogger
    implements Serializable, BasicLogger, BeanLogger, WeldLogger
{

    private final static long serialVersionUID = 1L;
    private final static java.lang.String FQCN = BeanLogger_$logger.class.getName();
    private final static java.lang.String decoratedHasNoNoargsConstructor = "WELD-001534: Bean class which has decorators must have a public constructor without parameters: {0}";
    private final static java.lang.String proxyInstantiationBeanAccessFailed = "WELD-000034: Could not access bean correctly when creating client proxy for {0}";
    private final static java.lang.String methodNotBusinessMethod = "WELD-000068: {0} method {1} is not a business method of {2}\n\tat {3}\n  StackTrace:";
    private final static java.lang.String simpleBeanAsNonStaticInnerClassNotAllowed = "WELD-000070: Simple bean {0} cannot be a non-static inner class";
    private final static java.lang.String injectedFieldCannotBeProducer = "WELD-000094: Injected field {0} cannot be annotated @Produces on {1}";
    private final static java.lang.String finalBeanClassWithInterceptorsNotAllowed = "WELD-001503: Bean class which has interceptors cannot be declared final:  {0}";
    private final static java.lang.String noInterceptionFunction = "WELD-001565: Interceptor builder {0} does not define an interception function.";
    private final static java.lang.String decoratedNoargsConstructorIsPrivate = "WELD-001535: Constructor without parameters cannot be private in bean class which has decorators: {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String errorDestroying = "WELD-000019: Error destroying an instance {0} of {1}";
    private final static java.lang.String createdMethodHandlerInitializerForDecoratorProxy = "WELD-001539: Created MH initializer body for decorator proxy: {0}";
    private final static java.lang.String multipleDisposeParams = "WELD-000066: {0} has more than one @Dispose parameter \n\tat {1}\n  StackTrace:";
    private final static java.lang.String extensionWithNonStaticPublicField = "WELD-001552: An extension ({0}) has a non-static public field ({1}).";
    private final static java.lang.String securityServicesNotAvailable = "WELD-000026: Security Services not available - unable to obtain the Principal";
    private final static java.lang.String namedResourceProducerField = "WELD-001516: Resource producer field [{0}] must not have an EL name";
    private final static java.lang.String noInterceptionType = "WELD-001566: Interceptor builder {0} does not define any InterceptionType.";
    private final static java.lang.String nonSerializableProductError = "WELD-000053: Producers cannot declare passivating scope and return a non-serializable class: {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String createdNewClientProxyType = "WELD-001506: Created new client proxy of type {0} for bean {1} with ID {2}";
    private final static java.lang.String beansWithDifferentBeanNamesCannotBeSpecialized = "WELD-001520: Beans with different bean names {0}, {1} cannot be specialized by a single bean {2}";
    private final static java.lang.String statelessSessionBeanInjectionPointMetadataNotAvailable = "WELD-001564: Injection point metadata injected into a stateless session bean may only be accessed within its business method invocation";
    private final static java.lang.String nonContainerDecorator = "WELD-000042: Cannot operate on non container provided decorator {0}";
    private final static java.lang.String unableToLoadMember = "WELD-001515: Unable to load annotated member {0}";
    private final static java.lang.String producerMethodReturnTypeInvalidTypeVariable = "WELD-001562: A producer method return type may not be a type variable or an array type whose component type is a type variable: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String producerFieldTypeInvalidTypeVariable = "WELD-001563: A producer field type may not be a type variable or an array type whose component type is a type variable: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String delegateNotOnDecorator = "WELD-000038: A bean class that is not a decorator has an injection point annotated @Delegate\n  at injection point {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String interceptionModelNull = "WELD-000028: Interception model must not be null";
    private final static java.lang.String producerMethodNotSpecializing = "WELD-000078: Specialized producer method does not override another producer method: {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String multipleDisposalMethods = "WELD-000077: Cannot declare multiple disposal methods for this producer method.\n\nProducer method:  {0}\nDisposal methods:  {1}";
    private final static java.lang.String specializingEnterpriseBeanMustExtendAnEnterpriseBean = "WELD-000084: Specializing enterprise bean must extend another enterprise bean:  {0}";
    private final static java.lang.String sessionBeanProxyInstantiationFailed = "WELD-000079: Could not instantiate a proxy for a session bean:  {0}\n  Proxy: {1}";
    private final static java.lang.String addingMethodToProxy = "WELD-001541: Adding method to proxy: {0}";
    private final static java.lang.String invalidResourceProducerType = "WELD-001517: The type of the resource producer field [{0}] does not match the resource type {1}";
    private final static java.lang.String tooManyDelegateInjectionPoints = "WELD-000060: Too many delegate injection points defined for {0}";
    private final static java.lang.String createdSessionBeanProxy = "WELD-000007: Created session bean proxy for {0}";
    private final static java.lang.String usingName = "WELD-000014: Using name {0} for {1}";
    private final static java.lang.String passivatingBeanNeedsSerializableImpl = "WELD-000072: Bean declaring a passivating scope must be passivation capable.  Bean:  {0}";
    private final static java.lang.String producerCastError = "WELD-000050: Cannot cast producer type {0} to bean type {1}";
    private final static java.lang.String injectionTargetCannotProduceInstance = "WELD-001530: Cannot produce an instance of {0}.";
    private final static java.lang.String genericSessionBeanMustBeDependent = "WELD-000095: Session bean with generic class {0} must be @Dependent scope";
    private final static java.lang.String createdContextInstance = "WELD-001538: Created context instance for bean {0} identified as {1}";
    private final static java.lang.String delegateMustSupportEveryDecoratedType = "WELD-000061: The delegate type does not extend or implement the decorated type. \n  Decorated type: {0}\n  Decorator: {1}";
    private final static java.lang.String usingScope = "WELD-000016: Using scope {0} for {1}";
    private final static java.lang.String parameterAnnotationNotAllowedOnConstructor = "WELD-000076: Bean constructor must not have a parameter annotated with {0}: {1}\n\tat {2}\n  StackTrace:";
    private final static java.lang.String methodHandlerProcessingCall = "WELD-001545: MethodHandler processing call to {0} for {1}";
    private final static java.lang.String nonDependentResourceProducerField = "WELD-001502: Resource producer field [{0}] must be @Dependent scoped";
    private final static java.lang.String interceptionTypeNotLifecycle = "WELD-000032: InterceptionType must be lifecycle, but it is {0}";
    private final static java.lang.String managedBeanWithParameterizedBeanClassMustBeDependent = "WELD-000071: Managed bean with a parameterized bean class must be @Dependent: {0}";
    private final static java.lang.String invalidAnnotatedCallable = "WELD-001513: An implementation of AnnotatedCallable must implement either AnnotatedConstructor or AnnotatedMethod, {0}";
    private final static java.lang.String methodNull = "WELD-000030: Method must not be null";
    private final static java.lang.String noDelegateInjectionPoint = "WELD-000059: No delegate injection point defined for {0}";
    private final static java.lang.String proxyDeserializationFailure = "WELD-001500: Failed to deserialize proxy object with beanId {0}";
    private final static java.lang.String foundOnePreDestroyMethod = "WELD-000006: Exactly one pre destroy method ({0}) for {1}";
    private final static java.lang.String unableToProcessDecoratedType = "WELD-000064: Unable to process decorated type: {0}";
    private final static java.lang.String ejbCannotBeDecorator = "WELD-000081: Enterprise beans cannot be decorators:  {0}";
    private final static java.lang.String cannotDestroyEnterpriseBeanNotCreated = "WELD-000086: Cannot destroy session bean instance not created by the container:  {0}";
    private final static java.lang.String catchingDebug = "Catching";
    private final static java.lang.String finalInterceptedBeanMethodNotAllowed = "WELD-001504: Intercepted bean method {0} (intercepted by {1}) cannot be declared final";
    private final static java.lang.String settingNewMethodHandler = "WELD-001546: Setting new MethodHandler with bean instance for {0} on {1}";
    private final static java.lang.String ejbCannotBeInterceptor = "WELD-000080: Enterprise beans cannot be interceptors:  {0}";
    private final static java.lang.String producerFieldCannotHaveAWildcardBeanType = "WELD-001551: A producer field type may not contain a wildcard: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String declaringBeanMissing = "WELD-001518: Cannot create Producer implementation. Declaring bean missing for a non-static member {0}";
    private final static java.lang.String activatedSessionBeanProxy = "WELD-001553: Proxy activated after passivation for {0}";
    private final static java.lang.String unableToRestoreInjectionPointMultiple = "WELD-001523: Unable to restore InjectionPoint. Multiple matching InjectionPoints found on {0}:\n  - {1},\n  - {2}";
    private final static java.lang.String dynamicLookupOfBuiltInNotAllowed = "WELD-000009: Dynamic lookup of {0} is not supported";
    private final static java.lang.String unableToRestoreInjectionPoint = "WELD-001522: Unable to restore InjectionPoint. No matching InjectionPoint found on {0}";
    private final static java.lang.String foundOneInjectableConstructor = "WELD-000001: Exactly one constructor ({0}) annotated with @Inject defined, using it as the bean constructor for {1}";
    private final static java.lang.String foundInjectableConstructors = "WELD-001536: Found {0} constructors annotated with @Inject for {1}";
    private final static java.lang.String decoratorMethodReturnsNull = "WELD-001555: Decorator.{0}() returned null for {1}";
    private final static java.lang.String typeParameterMustBeConcrete = "WELD-000023: Type parameter must be a concrete type:  {0}";
    private final static java.lang.String directoryCannotBeCreated = "WELD-001558: Unable to create directory {0} to dump the proxy classes.";
    private final static java.lang.String createdProxyClass = "WELD-001543: Created Proxy class of type {0} supporting interfaces {1}";
    private final static java.lang.String specializingBeanMissingSpecializedType = "WELD-001511: Specializing bean {0} does not have bean type {1} of specialized bean {2}";
    private final static java.lang.String nameNotAllowedOnSpecialization = "WELD-000041: Specializing bean may not declare a bean name if it is declared by specialized bean\n  specializing: {0}\n  specialized: {1}";
    private final static java.lang.String proxyInstantiationFailed = "WELD-000033: Could not instantiate client proxy for {0}";
    private final static java.lang.String publicFieldOnNormalScopedBeanNotAllowed = "WELD-000075: Normal scoped managed bean implementation class has a public field:  {0}";
    private final static java.lang.String producerMethodWithTypeVariableReturnTypeMustBeDependent = "WELD-000097: A producer method with a parameterized return type with a type variable must be declared @Dependent scoped: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String generatingProxyClass = "WELD-001542: Retrieving/generating proxy class {0}";
    private final static java.lang.String creatingBean = "WELD-000012: Building bean metadata for {0}";
    private final static java.lang.String finalMethodNotIntercepted = "WELD-001505: Method {0} cannot be intercepted by {1} - will be ignored by interceptors and should never be invoked upon the proxy instance!";
    private final static java.lang.String unableToCreateClassFile = "WELD-001568: Unable to create ClassFile for: {1}.";
    private final static java.lang.String foundOnePostConstructMethod = "WELD-000004: Exactly one post construct method ({0}) for {1}";
    private final static java.lang.String passivatingBeanHasNonPassivationCapableDecorator = "WELD-001526: Managed bean declaring a passivating scope has a non-passivation capable decorator.  Bean:  {0}  Decorator: {1}";
    private final static java.lang.String beanNotEeResourceProducer = "WELD-000043: The following bean is not an EE resource producer:  {0}";
    private final static java.lang.String invocationError = "WELD-000049: Unable to invoke {0} on {1}";
    private final static java.lang.String observerMethodMustBeStaticOrBusiness = "WELD-000088: Observer method must be static or local business method:  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String destroyUnsupported = "WELD-001525: Instance.destroy() is not supported. The underlying context {0} does not support destroying of contextual instances";
    private final static java.lang.String injectionTargetCannotBeCreatedForInterface = "WELD-001508: Cannot create an InjectionTarget from {0} as it is an interface";
    private final static java.lang.String invalidInjectionPointType = "WELD-001512: {0} cannot be constructed for {1}";
    private final static java.lang.String injectionTargetCreatedForAbstractClass = "WELD-001519: An InjectionTarget is created for an abstract {0}. It will not be possible to produce instances of this type!";
    private final static java.lang.String beanBuilderInvalidCreateCallback = "WELD-001559: Bean builder {0} does not define a create lifecycle callback.";
    private final static java.lang.String nullInstance = "WELD-000044: Unable to obtain instance from {0}";
    private final static java.lang.String nullNotAllowedFromProducer = "WELD-000052: Cannot return null from a non-dependent producer method: {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String invalidRemoveMethodInvocation = "WELD-000037: Cannot call EJB remove method directly on non-dependent scoped bean {0}";
    private final static java.lang.String onlyOneScopeAllowed = "WELD-000046: At most one scope may be specified on {0}";
    private final static java.lang.String instanceIteratorRemoveUnsupported = "WELD-001531: Instance.iterator().remove() is not supported.";
    private final static java.lang.String unableToDetermineParentCreationalContext = "WELD-001549: Unable to determine parent creational context of {0}";
    private final static java.lang.String beanBuilderInvalidBeanManager = "WELD-001561: Bean builder {0} does not define a BeanManager.";
    private final static java.lang.String unserializableProductInjectionError = "WELD-000054: Producers cannot produce unserializable instances for injection into an injection point that requires a passivation capable dependency\n  Producer:  {0}\n\tat {1}\n  Injection Point:  {2}\n\tat {3}\n  StackTrace:";
    private final static java.lang.String producerFieldOnSessionBeanMustBeStatic = "WELD-000096: Producer fields on session beans must be static. Field {0} declared on {1}";
    private final static java.lang.String beanMethodReturnsNull = "WELD-001554: Bean.{0}() returned null for {1}";
    private final static java.lang.String interceptionTypeNull = "WELD-000029: InterceptionType must not be null";
    private final static java.lang.String multipleScopesFoundFromStereotypes = "WELD-000040: All stereotypes must specify the same scope or the bean must declare a scope - declaring class: {0}, declared stereotypes [{1}], possible scopes {2}{3}";
    private final static java.lang.String scopeNotAllowedOnSingletonBean = "WELD-000083: Scope {0} is not allowed on singleton session beans for {1}. Only @Dependent and @ApplicationScoped is allowed.";
    private final static java.lang.String interceptionTypeLifecycle = "WELD-000031: InterceptionType must not be lifecycle, but it is {0}";
    private final static java.lang.String invalidAnnotatedOfInjectionPoint = "WELD-001521: InjectionPoint.getAnnotated() must return either AnnotatedParameter or AnnotatedField but {0} was returned for {1}";
    private final static java.lang.String invokingMethodDirectly = "WELD-001548: Invoking method {0} directly on {1}";
    private final static java.lang.String producerFieldWithTypeVariableBeanTypeMustBeDependent = "WELD-001550: A producer field with a parameterized type with a type variable must be declared @Dependent scoped: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String injectionTargetCreatedForClassWithoutAppropriateConstructorException = "WELD-001537: An InjectionTarget is created for a {0} which does not have any appropriate constructor.";
    private final static java.lang.String injectionTargetCreatedForNonStaticInnerClass = "WELD-001533: An InjectionTarget is created for a non-static inner {0}. It will not be possible to produce instances of this type!";
    private final static java.lang.String methodHandlerProcessingReturningBeanInstance = "WELD-001544: MethodHandler processing returning bean instance for {0}";
    private final static java.lang.String beanInstanceNotSetOnProxy = "WELD-001501: Method call requires a BeanInstance which has not been set for this proxy {0}";
    private final static java.lang.String conflictingInterceptorBindings = "WELD-000048: Conflicting interceptor bindings found on {0}";
    private final static java.lang.String beanCannotBeDumped = "WELD-001557: Unable to dump the proxy class file for {0}";
    private final static java.lang.String foundDefaultConstructor = "WELD-000002: Exactly one constructor ({0}) defined, using it as the bean constructor for {1}";
    private final static java.lang.String specializingManagedBeanCanExtendOnlyManagedBeans = "WELD-001556: Specializing {0} cannot specialize a non-managed bean {1}";
    private final static java.lang.String abstractMethodMustMatchDecoratedType = "WELD-000090: A decorator has an abstract method that is not declared by any decorated type\n  Method: {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String injectionTargetCreatedForClassWithoutAppropriateConstructor = "WELD-001529: An InjectionTarget is created for a {0} which does not have any appropriate constructor. It will not be possible to produce instances of this type!";
    private final static java.lang.String proxyHandlerSerializedForNonSerializableBean = "WELD-001510: Non passivation capable bean serialized with ProxyMethodHandler";
    private final static java.lang.String invokingInterceptorChain = "WELD-001547: Invoking interceptor chain for method {0} on {1}";
    private final static java.lang.String invalidResourceProducerField = "WELD-000025: Tried to create an EEResourceProducerField, but no @Resource, @PersistenceContext, @PersistenceUnit, @WebServiceRef or @EJB is present: {0}";
    private final static java.lang.String inconsistentAnnotationsOnMethod = "WELD-000067: {0} is not allowed on same method as {1}, see {2}\n\tat {3}\n  StackTrace:";
    private final static java.lang.String invalidAnnotatedMember = "WELD-001514: An implementation of AnnotatedMember must implement either AnnotatedConstructor, AnnotatedMethod or AnnotatedField, {0}";
    private final static java.lang.String cannotDestroyNullBean = "WELD-000085: Cannot destroy null instance of {0}";
    private final static java.lang.String lookedUpClientProxy = "WELD-001507: Located client proxy of type {0} for bean {1}";
    private final static java.lang.String circularCall = "WELD-000018: Executing producer field or method {0} on incomplete declaring bean {1} due to circular injection";
    private final static java.lang.String cannotLoadClass = "WELD-000099: Cannot load class {0} during deserialization of proxy";
    private final static java.lang.String transactionServicesNotAvailable = "WELD-000027: Transaction Services not available - unable to obtain the UserTransaction";
    private final static java.lang.String finalBeanClassWithDecoratorsNotAllowed = "WELD-000073: Bean class which has decorators cannot be declared final:  {0}";
    private final static java.lang.String serializationProxyRequired = "WELD-000045: Unable to deserialize object - serialization proxy is required";
    private final static java.lang.String unableToLoadProxyClass = "WELD-001524: Unable to load proxy class for bean {0} with class {1} using classloader {2}";
    private final static java.lang.String scopeNotAllowedOnStatelessSessionBean = "WELD-000082: Scope {0} is not allowed on stateless session beans for {1}. Only @Dependent is allowed.";
    private final static java.lang.String tooManyEjbsForClass = "WELD-000089: Unable to determine EJB for {0}, multiple EJBs with that class:  {1}";
    private final static java.lang.String messageDrivenBeansCannotBeManaged = "WELD-000087: Message driven beans cannot be Managed Beans:  {0}";
    private final static java.lang.String beanBuilderInvalidDestroyCallback = "WELD-001560: Bean builder {0} does not define a destroy lifecycle callback.";
    private final static java.lang.String producerMethodCannotHaveAWildcardReturnType = "WELD-000098: A producer method return type may not contain a wildcard: \n  {0}\n\tat {1}\n  StackTrace:";
    private final static java.lang.String addingMethodToEnterpriseProxy = "WELD-001540: Adding method to enterprise proxy: {0}";
    private final static java.lang.String qualifiersUsed = "WELD-000010: Using qualifiers {0} for {1}";
    private final static java.lang.String passivationCapableBeanHasNullId = "WELD-001532: A passivation capable bean cannot have a null id: {0}";
    private final static java.lang.String unexpectedUnwrappedCustomDecorator = "WELD-000036: Unexpected unwrapped custom decorator instance: {0}";
    private final static java.lang.String beanIdCreationFailed = "WELD-000035: There was an error creating an id for {0}";
    private final static java.lang.String passivatingBeanHasNonPassivationCapableInterceptor = "WELD-001527: Managed bean declaring a passivating scope has a non-serializable interceptor.  Bean:  {0}  Interceptor: {1}";
    private final static java.lang.String callProxiedMethod = "WELD-000008: Called {0} on {1} with parameters {2} which returned {3}";
    private final static java.lang.String specializingBeanMustExtendABean = "WELD-000047: Specializing bean must extend another bean:  {0}";
    private final static java.lang.String cannotCreateContextualInstanceOfBuilderInterceptor = "WELD-001567: Cannot create contextual instance of {0}";
    private final static java.lang.String typedClassNotInHierarchy = "WELD-000039: @Typed class {0} not present in the set of bean types of {1} [{2}]";

    public BeanLogger_$logger(final Logger log) {
        super(log);
    }

    public final org.jboss.weld.exceptions.DeploymentException decoratedHasNoNoargsConstructor(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(decoratedHasNoNoargsConstructor$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String decoratedHasNoNoargsConstructor$str() {
        return decoratedHasNoNoargsConstructor;
    }

    public final java.lang.String proxyInstantiationBeanAccessFailed(final java.lang.Object param1) {
        java.lang.String result = java.text.MessageFormat.format(proxyInstantiationBeanAccessFailed$str(), param1);
        return result;
    }

    protected java.lang.String proxyInstantiationBeanAccessFailed$str() {
        return proxyInstantiationBeanAccessFailed;
    }

    public final org.jboss.weld.exceptions.DefinitionException methodNotBusinessMethod(final java.lang.Object methodType, final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(methodNotBusinessMethod$str(), methodType, param1, param2, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String methodNotBusinessMethod$str() {
        return methodNotBusinessMethod;
    }

    public final org.jboss.weld.exceptions.DefinitionException simpleBeanAsNonStaticInnerClassNotAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(simpleBeanAsNonStaticInnerClassNotAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String simpleBeanAsNonStaticInnerClassNotAllowed$str() {
        return simpleBeanAsNonStaticInnerClassNotAllowed;
    }

    public final org.jboss.weld.exceptions.DefinitionException injectedFieldCannotBeProducer(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(injectedFieldCannotBeProducer$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String injectedFieldCannotBeProducer$str() {
        return injectedFieldCannotBeProducer;
    }

    public final org.jboss.weld.exceptions.DeploymentException finalBeanClassWithInterceptorsNotAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(finalBeanClassWithInterceptorsNotAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String finalBeanClassWithInterceptorsNotAllowed$str() {
        return finalBeanClassWithInterceptorsNotAllowed;
    }

    public final org.jboss.weld.exceptions.DefinitionException noInterceptionFunction(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(noInterceptionFunction$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String noInterceptionFunction$str() {
        return noInterceptionFunction;
    }

    public final org.jboss.weld.exceptions.DeploymentException decoratedNoargsConstructorIsPrivate(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(decoratedNoargsConstructorIsPrivate$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String decoratedNoargsConstructorIsPrivate$str() {
        return decoratedNoargsConstructorIsPrivate;
    }

    public final void errorDestroying(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.ERROR), null, errorDestroying$str(), param1, param2);
    }

    protected java.lang.String errorDestroying$str() {
        return errorDestroying;
    }

    public final void createdMethodHandlerInitializerForDecoratorProxy(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, createdMethodHandlerInitializerForDecoratorProxy$str(), param1);
    }

    protected java.lang.String createdMethodHandlerInitializerForDecoratorProxy$str() {
        return createdMethodHandlerInitializerForDecoratorProxy;
    }

    public final org.jboss.weld.exceptions.DefinitionException multipleDisposeParams(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(multipleDisposeParams$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String multipleDisposeParams$str() {
        return multipleDisposeParams;
    }

    public final void extensionWithNonStaticPublicField(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, extensionWithNonStaticPublicField$str(), param1, param2);
    }

    protected java.lang.String extensionWithNonStaticPublicField$str() {
        return extensionWithNonStaticPublicField;
    }

    public final org.jboss.weld.exceptions.IllegalStateException securityServicesNotAvailable() {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.lang.String.format(securityServicesNotAvailable$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String securityServicesNotAvailable$str() {
        return securityServicesNotAvailable;
    }

    public final org.jboss.weld.exceptions.DefinitionException namedResourceProducerField(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(namedResourceProducerField$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String namedResourceProducerField$str() {
        return namedResourceProducerField;
    }

    public final org.jboss.weld.exceptions.DefinitionException noInterceptionType(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(noInterceptionType$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String noInterceptionType$str() {
        return noInterceptionType;
    }

    public final org.jboss.weld.exceptions.IllegalProductException nonSerializableProductError(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.IllegalProductException result = new org.jboss.weld.exceptions.IllegalProductException(java.text.MessageFormat.format(nonSerializableProductError$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nonSerializableProductError$str() {
        return nonSerializableProductError;
    }

    public final void createdNewClientProxyType(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, createdNewClientProxyType$str(), param1, param2, param3);
    }

    protected java.lang.String createdNewClientProxyType$str() {
        return createdNewClientProxyType;
    }

    public final org.jboss.weld.exceptions.DefinitionException beansWithDifferentBeanNamesCannotBeSpecialized(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beansWithDifferentBeanNamesCannotBeSpecialized$str(), param1, param2, param3));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beansWithDifferentBeanNamesCannotBeSpecialized$str() {
        return beansWithDifferentBeanNamesCannotBeSpecialized;
    }

    public final org.jboss.weld.exceptions.IllegalStateException statelessSessionBeanInjectionPointMetadataNotAvailable() {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(statelessSessionBeanInjectionPointMetadataNotAvailable$str());
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String statelessSessionBeanInjectionPointMetadataNotAvailable$str() {
        return statelessSessionBeanInjectionPointMetadataNotAvailable;
    }

    public final org.jboss.weld.exceptions.IllegalStateException nonContainerDecorator(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(nonContainerDecorator$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nonContainerDecorator$str() {
        return nonContainerDecorator;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unableToLoadMember(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unableToLoadMember$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToLoadMember$str() {
        return unableToLoadMember;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerMethodReturnTypeInvalidTypeVariable(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerMethodReturnTypeInvalidTypeVariable$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerMethodReturnTypeInvalidTypeVariable$str() {
        return producerMethodReturnTypeInvalidTypeVariable;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerFieldTypeInvalidTypeVariable(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerFieldTypeInvalidTypeVariable$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerFieldTypeInvalidTypeVariable$str() {
        return producerFieldTypeInvalidTypeVariable;
    }

    public final org.jboss.weld.exceptions.DefinitionException delegateNotOnDecorator(final java.lang.Object ip, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(delegateNotOnDecorator$str(), ip, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String delegateNotOnDecorator$str() {
        return delegateNotOnDecorator;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException interceptionModelNull() {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.lang.String.format(interceptionModelNull$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String interceptionModelNull$str() {
        return interceptionModelNull;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerMethodNotSpecializing(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerMethodNotSpecializing$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerMethodNotSpecializing$str() {
        return producerMethodNotSpecializing;
    }

    public final org.jboss.weld.exceptions.DefinitionException multipleDisposalMethods(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(multipleDisposalMethods$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String multipleDisposalMethods$str() {
        return multipleDisposalMethods;
    }

    public final org.jboss.weld.exceptions.DefinitionException specializingEnterpriseBeanMustExtendAnEnterpriseBean(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(specializingEnterpriseBeanMustExtendAnEnterpriseBean$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String specializingEnterpriseBeanMustExtendAnEnterpriseBean$str() {
        return specializingEnterpriseBeanMustExtendAnEnterpriseBean;
    }

    public final org.jboss.weld.exceptions.CreationException sessionBeanProxyInstantiationFailed(final java.lang.Object sessionBean, final java.lang.Object proxyClass, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.CreationException result = new org.jboss.weld.exceptions.CreationException(java.text.MessageFormat.format(sessionBeanProxyInstantiationFailed$str(), sessionBean, proxyClass), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String sessionBeanProxyInstantiationFailed$str() {
        return sessionBeanProxyInstantiationFailed;
    }

    public final void addingMethodToProxy(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, addingMethodToProxy$str(), param1);
    }

    protected java.lang.String addingMethodToProxy$str() {
        return addingMethodToProxy;
    }

    public final org.jboss.weld.exceptions.DefinitionException invalidResourceProducerType(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(invalidResourceProducerType$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidResourceProducerType$str() {
        return invalidResourceProducerType;
    }

    public final org.jboss.weld.exceptions.DefinitionException tooManyDelegateInjectionPoints(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(tooManyDelegateInjectionPoints$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String tooManyDelegateInjectionPoints$str() {
        return tooManyDelegateInjectionPoints;
    }

    public final void createdSessionBeanProxy(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, createdSessionBeanProxy$str(), param1);
    }

    protected java.lang.String createdSessionBeanProxy$str() {
        return createdSessionBeanProxy;
    }

    public final void usingName(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, usingName$str(), param1, param2);
    }

    protected java.lang.String usingName$str() {
        return usingName;
    }

    public final org.jboss.weld.exceptions.DeploymentException passivatingBeanNeedsSerializableImpl(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(passivatingBeanNeedsSerializableImpl$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String passivatingBeanNeedsSerializableImpl$str() {
        return passivatingBeanNeedsSerializableImpl;
    }

    public final org.jboss.weld.exceptions.WeldException producerCastError(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(producerCastError$str(), param1, param2), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerCastError$str() {
        return producerCastError;
    }

    public final org.jboss.weld.exceptions.CreationException injectionTargetCannotProduceInstance(final java.lang.Object param1) {
        org.jboss.weld.exceptions.CreationException result = new org.jboss.weld.exceptions.CreationException(java.text.MessageFormat.format(injectionTargetCannotProduceInstance$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String injectionTargetCannotProduceInstance$str() {
        return injectionTargetCannotProduceInstance;
    }

    public final org.jboss.weld.exceptions.DefinitionException genericSessionBeanMustBeDependent(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(genericSessionBeanMustBeDependent$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String genericSessionBeanMustBeDependent$str() {
        return genericSessionBeanMustBeDependent;
    }

    public final void createdContextInstance(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, createdContextInstance$str(), param1, param2);
    }

    protected java.lang.String createdContextInstance$str() {
        return createdContextInstance;
    }

    public final org.jboss.weld.exceptions.DefinitionException delegateMustSupportEveryDecoratedType(final java.lang.Object decoratedType, final java.lang.Object decorator) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(delegateMustSupportEveryDecoratedType$str(), decoratedType, decorator));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String delegateMustSupportEveryDecoratedType$str() {
        return delegateMustSupportEveryDecoratedType;
    }

    public final void usingScope(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, usingScope$str(), param1, param2);
    }

    protected java.lang.String usingScope$str() {
        return usingScope;
    }

    public final org.jboss.weld.exceptions.DefinitionException parameterAnnotationNotAllowedOnConstructor(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(parameterAnnotationNotAllowedOnConstructor$str(), param1, param2, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String parameterAnnotationNotAllowedOnConstructor$str() {
        return parameterAnnotationNotAllowedOnConstructor;
    }

    public final void methodHandlerProcessingCall(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, methodHandlerProcessingCall$str(), param1, param2);
    }

    protected java.lang.String methodHandlerProcessingCall$str() {
        return methodHandlerProcessingCall;
    }

    public final org.jboss.weld.exceptions.DefinitionException nonDependentResourceProducerField(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(nonDependentResourceProducerField$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nonDependentResourceProducerField$str() {
        return nonDependentResourceProducerField;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException interceptionTypeNotLifecycle(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(interceptionTypeNotLifecycle$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String interceptionTypeNotLifecycle$str() {
        return interceptionTypeNotLifecycle;
    }

    public final org.jboss.weld.exceptions.DefinitionException managedBeanWithParameterizedBeanClassMustBeDependent(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(managedBeanWithParameterizedBeanClassMustBeDependent$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String managedBeanWithParameterizedBeanClassMustBeDependent$str() {
        return managedBeanWithParameterizedBeanClassMustBeDependent;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException invalidAnnotatedCallable(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(invalidAnnotatedCallable$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidAnnotatedCallable$str() {
        return invalidAnnotatedCallable;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException methodNull() {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.lang.String.format(methodNull$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String methodNull$str() {
        return methodNull;
    }

    public final org.jboss.weld.exceptions.DefinitionException noDelegateInjectionPoint(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(noDelegateInjectionPoint$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String noDelegateInjectionPoint$str() {
        return noDelegateInjectionPoint;
    }

    public final org.jboss.weld.exceptions.WeldException proxyDeserializationFailure(final java.lang.Object param1) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(proxyDeserializationFailure$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String proxyDeserializationFailure$str() {
        return proxyDeserializationFailure;
    }

    public final void foundOnePreDestroyMethod(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, foundOnePreDestroyMethod$str(), param1, param2);
    }

    protected java.lang.String foundOnePreDestroyMethod$str() {
        return foundOnePreDestroyMethod;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unableToProcessDecoratedType(final java.lang.Object decoratedType) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unableToProcessDecoratedType$str(), decoratedType));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToProcessDecoratedType$str() {
        return unableToProcessDecoratedType;
    }

    public final org.jboss.weld.exceptions.DefinitionException ejbCannotBeDecorator(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(ejbCannotBeDecorator$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String ejbCannotBeDecorator$str() {
        return ejbCannotBeDecorator;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException cannotDestroyEnterpriseBeanNotCreated(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(cannotDestroyEnterpriseBeanNotCreated$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String cannotDestroyEnterpriseBeanNotCreated$str() {
        return cannotDestroyEnterpriseBeanNotCreated;
    }

    public final void catchingDebug(final java.lang.Throwable throwable) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.DEBUG), (throwable), catchingDebug$str());
    }

    protected java.lang.String catchingDebug$str() {
        return catchingDebug;
    }

    public final org.jboss.weld.exceptions.DeploymentException finalInterceptedBeanMethodNotAllowed(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(finalInterceptedBeanMethodNotAllowed$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String finalInterceptedBeanMethodNotAllowed$str() {
        return finalInterceptedBeanMethodNotAllowed;
    }

    public final void settingNewMethodHandler(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, settingNewMethodHandler$str(), param1, param2);
    }

    protected java.lang.String settingNewMethodHandler$str() {
        return settingNewMethodHandler;
    }

    public final org.jboss.weld.exceptions.DefinitionException ejbCannotBeInterceptor(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(ejbCannotBeInterceptor$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String ejbCannotBeInterceptor$str() {
        return ejbCannotBeInterceptor;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerFieldCannotHaveAWildcardBeanType(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerFieldCannotHaveAWildcardBeanType$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerFieldCannotHaveAWildcardBeanType$str() {
        return producerFieldCannotHaveAWildcardBeanType;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException declaringBeanMissing(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(declaringBeanMissing$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String declaringBeanMissing$str() {
        return declaringBeanMissing;
    }

    public final void activatedSessionBeanProxy(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, activatedSessionBeanProxy$str(), param1);
    }

    protected java.lang.String activatedSessionBeanProxy$str() {
        return activatedSessionBeanProxy;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unableToRestoreInjectionPointMultiple(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unableToRestoreInjectionPointMultiple$str(), param1, param2, param3));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToRestoreInjectionPointMultiple$str() {
        return unableToRestoreInjectionPointMultiple;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException dynamicLookupOfBuiltInNotAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(dynamicLookupOfBuiltInNotAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String dynamicLookupOfBuiltInNotAllowed$str() {
        return dynamicLookupOfBuiltInNotAllowed;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unableToRestoreInjectionPoint(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unableToRestoreInjectionPoint$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToRestoreInjectionPoint$str() {
        return unableToRestoreInjectionPoint;
    }

    public final void foundOneInjectableConstructor(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, foundOneInjectableConstructor$str(), param1, param2);
    }

    protected java.lang.String foundOneInjectableConstructor$str() {
        return foundOneInjectableConstructor;
    }

    public final void foundInjectableConstructors(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, foundInjectableConstructors$str(), param1, param2);
    }

    protected java.lang.String foundInjectableConstructors$str() {
        return foundInjectableConstructors;
    }

    public final org.jboss.weld.exceptions.DefinitionException decoratorMethodReturnsNull(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(decoratorMethodReturnsNull$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String decoratorMethodReturnsNull$str() {
        return decoratorMethodReturnsNull;
    }

    public final java.lang.String typeParameterMustBeConcrete(final java.lang.Object param1) {
        java.lang.String result = java.text.MessageFormat.format(typeParameterMustBeConcrete$str(), param1);
        return result;
    }

    protected java.lang.String typeParameterMustBeConcrete$str() {
        return typeParameterMustBeConcrete;
    }

    public final void directoryCannotBeCreated(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, directoryCannotBeCreated$str(), param1);
    }

    protected java.lang.String directoryCannotBeCreated$str() {
        return directoryCannotBeCreated;
    }

    public final void createdProxyClass(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, createdProxyClass$str(), param1, param2);
    }

    protected java.lang.String createdProxyClass$str() {
        return createdProxyClass;
    }

    public final org.jboss.weld.exceptions.DefinitionException specializingBeanMissingSpecializedType(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(specializingBeanMissingSpecializedType$str(), param1, param2, param3));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String specializingBeanMissingSpecializedType$str() {
        return specializingBeanMissingSpecializedType;
    }

    public final org.jboss.weld.exceptions.DefinitionException nameNotAllowedOnSpecialization(final java.lang.Object specializing, final java.lang.Object specialized) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(nameNotAllowedOnSpecialization$str(), specializing, specialized));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nameNotAllowedOnSpecialization$str() {
        return nameNotAllowedOnSpecialization;
    }

    public final java.lang.String proxyInstantiationFailed(final java.lang.Object param1) {
        java.lang.String result = java.text.MessageFormat.format(proxyInstantiationFailed$str(), param1);
        return result;
    }

    protected java.lang.String proxyInstantiationFailed$str() {
        return proxyInstantiationFailed;
    }

    public final org.jboss.weld.exceptions.DefinitionException publicFieldOnNormalScopedBeanNotAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(publicFieldOnNormalScopedBeanNotAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String publicFieldOnNormalScopedBeanNotAllowed$str() {
        return publicFieldOnNormalScopedBeanNotAllowed;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerMethodWithTypeVariableReturnTypeMustBeDependent(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerMethodWithTypeVariableReturnTypeMustBeDependent$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerMethodWithTypeVariableReturnTypeMustBeDependent$str() {
        return producerMethodWithTypeVariableReturnTypeMustBeDependent;
    }

    public final void generatingProxyClass(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, generatingProxyClass$str(), param1);
    }

    protected java.lang.String generatingProxyClass$str() {
        return generatingProxyClass;
    }

    public final void creatingBean(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, creatingBean$str(), param1);
    }

    protected java.lang.String creatingBean$str() {
        return creatingBean;
    }

    public final void finalMethodNotIntercepted(final java.lang.Object method, final java.lang.Object interceptor) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, finalMethodNotIntercepted$str(), method, interceptor);
    }

    protected java.lang.String finalMethodNotIntercepted$str() {
        return finalMethodNotIntercepted;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unableToCreateClassFile(final java.lang.Object name, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unableToCreateClassFile$str(), name), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToCreateClassFile$str() {
        return unableToCreateClassFile;
    }

    public final void foundOnePostConstructMethod(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, foundOnePostConstructMethod$str(), param1, param2);
    }

    protected java.lang.String foundOnePostConstructMethod$str() {
        return foundOnePostConstructMethod;
    }

    public final org.jboss.weld.exceptions.DeploymentException passivatingBeanHasNonPassivationCapableDecorator(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(passivatingBeanHasNonPassivationCapableDecorator$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String passivatingBeanHasNonPassivationCapableDecorator$str() {
        return passivatingBeanHasNonPassivationCapableDecorator;
    }

    public final org.jboss.weld.exceptions.IllegalStateException beanNotEeResourceProducer(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(beanNotEeResourceProducer$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanNotEeResourceProducer$str() {
        return beanNotEeResourceProducer;
    }

    public final org.jboss.weld.exceptions.WeldException invocationError(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(invocationError$str(), param1, param2), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invocationError$str() {
        return invocationError;
    }

    public final org.jboss.weld.exceptions.DefinitionException observerMethodMustBeStaticOrBusiness(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(observerMethodMustBeStaticOrBusiness$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String observerMethodMustBeStaticOrBusiness$str() {
        return observerMethodMustBeStaticOrBusiness;
    }

    public final org.jboss.weld.exceptions.UnsupportedOperationException destroyUnsupported(final java.lang.Object param1) {
        org.jboss.weld.exceptions.UnsupportedOperationException result = new org.jboss.weld.exceptions.UnsupportedOperationException(java.text.MessageFormat.format(destroyUnsupported$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String destroyUnsupported$str() {
        return destroyUnsupported;
    }

    public final org.jboss.weld.exceptions.DefinitionException injectionTargetCannotBeCreatedForInterface(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(injectionTargetCannotBeCreatedForInterface$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String injectionTargetCannotBeCreatedForInterface$str() {
        return injectionTargetCannotBeCreatedForInterface;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException invalidInjectionPointType(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(invalidInjectionPointType$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidInjectionPointType$str() {
        return invalidInjectionPointType;
    }

    public final void injectionTargetCreatedForAbstractClass(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.DEBUG), null, injectionTargetCreatedForAbstractClass$str(), param1);
    }

    protected java.lang.String injectionTargetCreatedForAbstractClass$str() {
        return injectionTargetCreatedForAbstractClass;
    }

    public final org.jboss.weld.exceptions.DefinitionException beanBuilderInvalidCreateCallback(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beanBuilderInvalidCreateCallback$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanBuilderInvalidCreateCallback$str() {
        return beanBuilderInvalidCreateCallback;
    }

    public final org.jboss.weld.exceptions.NullInstanceException nullInstance(final java.lang.Object param1) {
        org.jboss.weld.exceptions.NullInstanceException result = new org.jboss.weld.exceptions.NullInstanceException(java.text.MessageFormat.format(nullInstance$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nullInstance$str() {
        return nullInstance;
    }

    public final org.jboss.weld.exceptions.IllegalProductException nullNotAllowedFromProducer(final java.lang.Object param1, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.IllegalProductException result = new org.jboss.weld.exceptions.IllegalProductException(java.text.MessageFormat.format(nullNotAllowedFromProducer$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String nullNotAllowedFromProducer$str() {
        return nullNotAllowedFromProducer;
    }

    public final org.jboss.weld.exceptions.UnsupportedOperationException invalidRemoveMethodInvocation(final java.lang.Object param1) {
        org.jboss.weld.exceptions.UnsupportedOperationException result = new org.jboss.weld.exceptions.UnsupportedOperationException(java.text.MessageFormat.format(invalidRemoveMethodInvocation$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidRemoveMethodInvocation$str() {
        return invalidRemoveMethodInvocation;
    }

    public final org.jboss.weld.exceptions.DefinitionException onlyOneScopeAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(onlyOneScopeAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String onlyOneScopeAllowed$str() {
        return onlyOneScopeAllowed;
    }

    public final org.jboss.weld.exceptions.UnsupportedOperationException instanceIteratorRemoveUnsupported() {
        org.jboss.weld.exceptions.UnsupportedOperationException result = new org.jboss.weld.exceptions.UnsupportedOperationException(java.lang.String.format(instanceIteratorRemoveUnsupported$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String instanceIteratorRemoveUnsupported$str() {
        return instanceIteratorRemoveUnsupported;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException unableToDetermineParentCreationalContext(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(unableToDetermineParentCreationalContext$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToDetermineParentCreationalContext$str() {
        return unableToDetermineParentCreationalContext;
    }

    public final org.jboss.weld.exceptions.DefinitionException beanBuilderInvalidBeanManager(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beanBuilderInvalidBeanManager$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanBuilderInvalidBeanManager$str() {
        return beanBuilderInvalidBeanManager;
    }

    public final org.jboss.weld.exceptions.IllegalProductException unserializableProductInjectionError(final java.lang.Object producer, final java.lang.Object producerStackElement, final java.lang.Object ip, final java.lang.Object ipStackElement) {
        org.jboss.weld.exceptions.IllegalProductException result = new org.jboss.weld.exceptions.IllegalProductException(java.text.MessageFormat.format(unserializableProductInjectionError$str(), producer, producerStackElement, ip, ipStackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unserializableProductInjectionError$str() {
        return unserializableProductInjectionError;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerFieldOnSessionBeanMustBeStatic(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerFieldOnSessionBeanMustBeStatic$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerFieldOnSessionBeanMustBeStatic$str() {
        return producerFieldOnSessionBeanMustBeStatic;
    }

    public final org.jboss.weld.exceptions.DefinitionException beanMethodReturnsNull(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beanMethodReturnsNull$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanMethodReturnsNull$str() {
        return beanMethodReturnsNull;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException interceptionTypeNull() {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.lang.String.format(interceptionTypeNull$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String interceptionTypeNull$str() {
        return interceptionTypeNull;
    }

    public final org.jboss.weld.exceptions.DefinitionException multipleScopesFoundFromStereotypes(final java.lang.Object param1, final java.lang.Object stereotypes, final java.lang.Object possibleScopes, final java.lang.String stack) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(multipleScopesFoundFromStereotypes$str(), param1, stereotypes, possibleScopes, stack));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String multipleScopesFoundFromStereotypes$str() {
        return multipleScopesFoundFromStereotypes;
    }

    public final org.jboss.weld.exceptions.DefinitionException scopeNotAllowedOnSingletonBean(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(scopeNotAllowedOnSingletonBean$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String scopeNotAllowedOnSingletonBean$str() {
        return scopeNotAllowedOnSingletonBean;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException interceptionTypeLifecycle(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(interceptionTypeLifecycle$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String interceptionTypeLifecycle$str() {
        return interceptionTypeLifecycle;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException invalidAnnotatedOfInjectionPoint(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(invalidAnnotatedOfInjectionPoint$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidAnnotatedOfInjectionPoint$str() {
        return invalidAnnotatedOfInjectionPoint;
    }

    public final void invokingMethodDirectly(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, invokingMethodDirectly$str(), param1, param2);
    }

    protected java.lang.String invokingMethodDirectly$str() {
        return invokingMethodDirectly;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerFieldWithTypeVariableBeanTypeMustBeDependent(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerFieldWithTypeVariableBeanTypeMustBeDependent$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerFieldWithTypeVariableBeanTypeMustBeDependent$str() {
        return producerFieldWithTypeVariableBeanTypeMustBeDependent;
    }

    public final org.jboss.weld.exceptions.DefinitionException injectionTargetCreatedForClassWithoutAppropriateConstructorException(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(injectionTargetCreatedForClassWithoutAppropriateConstructorException$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String injectionTargetCreatedForClassWithoutAppropriateConstructorException$str() {
        return injectionTargetCreatedForClassWithoutAppropriateConstructorException;
    }

    public final void injectionTargetCreatedForNonStaticInnerClass(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.DEBUG), null, injectionTargetCreatedForNonStaticInnerClass$str(), param1);
    }

    protected java.lang.String injectionTargetCreatedForNonStaticInnerClass$str() {
        return injectionTargetCreatedForNonStaticInnerClass;
    }

    public final void methodHandlerProcessingReturningBeanInstance(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, methodHandlerProcessingReturningBeanInstance$str(), param1);
    }

    protected java.lang.String methodHandlerProcessingReturningBeanInstance$str() {
        return methodHandlerProcessingReturningBeanInstance;
    }

    public final org.jboss.weld.exceptions.WeldException beanInstanceNotSetOnProxy(final java.lang.Object param1) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(beanInstanceNotSetOnProxy$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanInstanceNotSetOnProxy$str() {
        return beanInstanceNotSetOnProxy;
    }

    public final java.lang.String conflictingInterceptorBindings(final java.lang.Object param1) {
        java.lang.String result = java.text.MessageFormat.format(conflictingInterceptorBindings$str(), param1);
        return result;
    }

    protected java.lang.String conflictingInterceptorBindings$str() {
        return conflictingInterceptorBindings;
    }

    public final void beanCannotBeDumped(final java.lang.Object param1, final java.lang.Throwable cause) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), (cause), beanCannotBeDumped$str(), param1);
    }

    protected java.lang.String beanCannotBeDumped$str() {
        return beanCannotBeDumped;
    }

    public final void foundDefaultConstructor(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, foundDefaultConstructor$str(), param1, param2);
    }

    protected java.lang.String foundDefaultConstructor$str() {
        return foundDefaultConstructor;
    }

    public final org.jboss.weld.exceptions.DefinitionException specializingManagedBeanCanExtendOnlyManagedBeans(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(specializingManagedBeanCanExtendOnlyManagedBeans$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String specializingManagedBeanCanExtendOnlyManagedBeans$str() {
        return specializingManagedBeanCanExtendOnlyManagedBeans;
    }

    public final org.jboss.weld.exceptions.DefinitionException abstractMethodMustMatchDecoratedType(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(abstractMethodMustMatchDecoratedType$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String abstractMethodMustMatchDecoratedType$str() {
        return abstractMethodMustMatchDecoratedType;
    }

    public final void injectionTargetCreatedForClassWithoutAppropriateConstructor(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.DEBUG), null, injectionTargetCreatedForClassWithoutAppropriateConstructor$str(), param1);
    }

    protected java.lang.String injectionTargetCreatedForClassWithoutAppropriateConstructor$str() {
        return injectionTargetCreatedForClassWithoutAppropriateConstructor;
    }

    public final org.jboss.weld.exceptions.WeldException proxyHandlerSerializedForNonSerializableBean() {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.lang.String.format(proxyHandlerSerializedForNonSerializableBean$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String proxyHandlerSerializedForNonSerializableBean$str() {
        return proxyHandlerSerializedForNonSerializableBean;
    }

    public final void invokingInterceptorChain(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, invokingInterceptorChain$str(), param1, param2);
    }

    protected java.lang.String invokingInterceptorChain$str() {
        return invokingInterceptorChain;
    }

    public final org.jboss.weld.exceptions.IllegalStateException invalidResourceProducerField(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(invalidResourceProducerField$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidResourceProducerField$str() {
        return invalidResourceProducerField;
    }

    public final org.jboss.weld.exceptions.DefinitionException inconsistentAnnotationsOnMethod(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3, final java.lang.Object stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(inconsistentAnnotationsOnMethod$str(), param1, param2, param3, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String inconsistentAnnotationsOnMethod$str() {
        return inconsistentAnnotationsOnMethod;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException invalidAnnotatedMember(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(invalidAnnotatedMember$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String invalidAnnotatedMember$str() {
        return invalidAnnotatedMember;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException cannotDestroyNullBean(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(cannotDestroyNullBean$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String cannotDestroyNullBean$str() {
        return cannotDestroyNullBean;
    }

    public final void lookedUpClientProxy(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, lookedUpClientProxy$str(), param1, param2);
    }

    protected java.lang.String lookedUpClientProxy$str() {
        return lookedUpClientProxy;
    }

    public final void circularCall(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, circularCall$str(), param1, param2);
    }

    protected java.lang.String circularCall$str() {
        return circularCall;
    }

    public final org.jboss.weld.exceptions.WeldException cannotLoadClass(final java.lang.Object param1, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(cannotLoadClass$str(), param1), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String cannotLoadClass$str() {
        return cannotLoadClass;
    }

    public final org.jboss.weld.exceptions.IllegalStateException transactionServicesNotAvailable() {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.lang.String.format(transactionServicesNotAvailable$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String transactionServicesNotAvailable$str() {
        return transactionServicesNotAvailable;
    }

    public final org.jboss.weld.exceptions.DeploymentException finalBeanClassWithDecoratorsNotAllowed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(finalBeanClassWithDecoratorsNotAllowed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String finalBeanClassWithDecoratorsNotAllowed$str() {
        return finalBeanClassWithDecoratorsNotAllowed;
    }

    public final org.jboss.weld.exceptions.InvalidObjectException serializationProxyRequired() {
        org.jboss.weld.exceptions.InvalidObjectException result = new org.jboss.weld.exceptions.InvalidObjectException(java.lang.String.format(serializationProxyRequired$str()));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String serializationProxyRequired$str() {
        return serializationProxyRequired;
    }

    public final org.jboss.weld.exceptions.WeldException unableToLoadProxyClass(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.WeldException result = new org.jboss.weld.exceptions.WeldException(java.text.MessageFormat.format(unableToLoadProxyClass$str(), param1, param2, param3), cause);
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unableToLoadProxyClass$str() {
        return unableToLoadProxyClass;
    }

    public final org.jboss.weld.exceptions.DefinitionException scopeNotAllowedOnStatelessSessionBean(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(scopeNotAllowedOnStatelessSessionBean$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String scopeNotAllowedOnStatelessSessionBean$str() {
        return scopeNotAllowedOnStatelessSessionBean;
    }

    public final org.jboss.weld.exceptions.IllegalStateException tooManyEjbsForClass(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(tooManyEjbsForClass$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String tooManyEjbsForClass$str() {
        return tooManyEjbsForClass;
    }

    public final org.jboss.weld.exceptions.DefinitionException messageDrivenBeansCannotBeManaged(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(messageDrivenBeansCannotBeManaged$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String messageDrivenBeansCannotBeManaged$str() {
        return messageDrivenBeansCannotBeManaged;
    }

    public final org.jboss.weld.exceptions.DefinitionException beanBuilderInvalidDestroyCallback(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beanBuilderInvalidDestroyCallback$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanBuilderInvalidDestroyCallback$str() {
        return beanBuilderInvalidDestroyCallback;
    }

    public final org.jboss.weld.exceptions.DefinitionException producerMethodCannotHaveAWildcardReturnType(final java.lang.Object param1, final java.lang.String stackElement) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(producerMethodCannotHaveAWildcardReturnType$str(), param1, stackElement));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String producerMethodCannotHaveAWildcardReturnType$str() {
        return producerMethodCannotHaveAWildcardReturnType;
    }

    public final void addingMethodToEnterpriseProxy(final java.lang.Object param1) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, addingMethodToEnterpriseProxy$str(), param1);
    }

    protected java.lang.String addingMethodToEnterpriseProxy$str() {
        return addingMethodToEnterpriseProxy;
    }

    public final void qualifiersUsed(final java.lang.Object param1, final java.lang.Object param2) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, qualifiersUsed$str(), param1, param2);
    }

    protected java.lang.String qualifiersUsed$str() {
        return qualifiersUsed;
    }

    public final org.jboss.weld.exceptions.IllegalArgumentException passivationCapableBeanHasNullId(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalArgumentException result = new org.jboss.weld.exceptions.IllegalArgumentException(java.text.MessageFormat.format(passivationCapableBeanHasNullId$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String passivationCapableBeanHasNullId$str() {
        return passivationCapableBeanHasNullId;
    }

    public final org.jboss.weld.exceptions.IllegalStateException unexpectedUnwrappedCustomDecorator(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(unexpectedUnwrappedCustomDecorator$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String unexpectedUnwrappedCustomDecorator$str() {
        return unexpectedUnwrappedCustomDecorator;
    }

    public final org.jboss.weld.exceptions.DefinitionException beanIdCreationFailed(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(beanIdCreationFailed$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String beanIdCreationFailed$str() {
        return beanIdCreationFailed;
    }

    public final org.jboss.weld.exceptions.DeploymentException passivatingBeanHasNonPassivationCapableInterceptor(final java.lang.Object param1, final java.lang.Object param2) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(passivatingBeanHasNonPassivationCapableInterceptor$str(), param1, param2));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String passivatingBeanHasNonPassivationCapableInterceptor$str() {
        return passivatingBeanHasNonPassivationCapableInterceptor;
    }

    public final void callProxiedMethod(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object param3, final java.lang.Object param4) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, callProxiedMethod$str(), param1, param2, param3, param4);
    }

    protected java.lang.String callProxiedMethod$str() {
        return callProxiedMethod;
    }

    public final org.jboss.weld.exceptions.DefinitionException specializingBeanMustExtendABean(final java.lang.Object param1) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(specializingBeanMustExtendABean$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String specializingBeanMustExtendABean$str() {
        return specializingBeanMustExtendABean;
    }

    public final org.jboss.weld.exceptions.IllegalStateException cannotCreateContextualInstanceOfBuilderInterceptor(final java.lang.Object param1) {
        org.jboss.weld.exceptions.IllegalStateException result = new org.jboss.weld.exceptions.IllegalStateException(java.text.MessageFormat.format(cannotCreateContextualInstanceOfBuilderInterceptor$str(), param1));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String cannotCreateContextualInstanceOfBuilderInterceptor$str() {
        return cannotCreateContextualInstanceOfBuilderInterceptor;
    }

    public final org.jboss.weld.exceptions.DefinitionException typedClassNotInHierarchy(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Object types) {
        org.jboss.weld.exceptions.DefinitionException result = new org.jboss.weld.exceptions.DefinitionException(java.text.MessageFormat.format(typedClassNotInHierarchy$str(), param1, param2, types));
        java.lang.StackTraceElement[] st = result.getStackTrace();
        result.setStackTrace(java.util.Arrays.copyOfRange(st, 1, st.length));
        return result;
    }

    protected java.lang.String typedClassNotInHierarchy$str() {
        return typedClassNotInHierarchy;
    }

}