All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

There is a newer version: 6.0.2.Final
Show newest version

package org.jboss.weld.logging;

import java.io.Serializable;
import javax.annotation.Generated;
import javax.enterprise.inject.spi.ObserverMethod;
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 BootstrapLogger_$logger
    extends DelegatingBasicLogger
    implements Serializable, BasicLogger, BootstrapLogger, WeldLogger
{

    private final static long serialVersionUID = 1L;
    private final static java.lang.String FQCN = BootstrapLogger_$logger.class.getName();
    private final static java.lang.String deprecatedAddAnnotatedTypeMethodUsed = "WELD-000146: BeforeBeanDiscovery.addAnnotatedType(AnnotatedType) used for {0} is deprecated from CDI 1.1!";
    private final static java.lang.String foundObserverMethod = "WELD-000109: ObserverMethod: {0}";
    private final static java.lang.String callingBootstrapMethodAfterContainerHasBeenInitialized = "WELD-000140: Calling Bootstrap method after container has already been initialized. For correct order, see CDI11Bootstrap's documentation.";
    private final static java.lang.String addObserverMethodCalled = "WELD-000155: AfterBeanDiscovery.addObserverMethod() called by {0} for {1}";
    private final static java.lang.String addScopeCalled = "WELD-000159: BeforeBeanDiscovery.addScope() called by {0} for {1}";
    private final static java.lang.String invalidThreadPoolType = "WELD-000127: Invalid thread pool type: {0}";
    private final static java.lang.String containerLifecycleEventMethodInvokedOutsideObserver = "WELD-000143: Container lifecycle event method invoked outside of extension observer method invocation.";
    private final static java.lang.String invalidThreadPoolSize = "WELD-000125: Invalid thread pool size: {0}";
    private final static java.lang.String legacyDeploymentMetadataProvided = "WELD-000135: Legacy deployment metadata provided by the integrator. Certain functionality will not be available.";
    private final static java.lang.String exceptionThrownDuringBeforeShutdownObserver = "WELD-000136: Exception(s) thrown during observer of BeforeShutdown: ";
    private final static java.lang.String addInterceptorBindingCalled = "WELD-000161: BeforeBeanDiscovery.addInterceptorBindingCalled() called by {0} for {1}";
    private final static java.lang.String notUsingFastResolver = "WELD-000141: Falling back to the default observer method resolver due to {0}";
    private final static java.lang.String enabledDecorators = "WELD-000104: Enabled decorator types for {0}: {1}";
    private final static java.lang.String patFastResolver = "Sending PAT using the fast event resolver: {0}";
    private final static java.lang.String exceptionLoadingAnnotatedType = "WELD-000142: Exception loading annotated type using ClassFileServices. Falling back to the default implementation. {0}";
    private final static java.lang.String addAnnotatedTypeCalledInBBD = "WELD-000162: BeforeBeanDiscovery.addAnnotatedType() called by {0} for {1}";
    private final static java.lang.String annotationTypeNull = "WELD-000110: Cannot set the annotation type to null (if you want to stop the type being used, call veto()):  {0}";
    private final static java.lang.String beanIsBothInterceptorAndDecorator = "WELD-000112: Class {0} has both @Interceptor and @Decorator annotations";
    private final static java.lang.String nonuniqueBeanDeploymentIdentifier = "WELD-000163: Non-unique bean deployment identifier detected: {0}";
    private final static java.lang.String cdiApiVersionMismatch = "WELD-000144: CDI API version mismatch. CDI 1.0 API detected on classpath. Weld requires version 1.1 or better.";
    private final static java.lang.String exceptionWhileLoadingClass = "WELD-000137: Exception while loading class '{0}' : {1}";
    private final static java.lang.String errorWhileLoadingClass = "WELD-000138: Error while loading class '{0}' : {1}";
    private final static java.lang.String setInjectionPointCalled = "WELD-000150: ProcessInjectionPoint.setInjectionPoint() called by {0}: {1} replaced by {2}";
    private final static java.lang.String setProducerCalled = "WELD-000152: ProcessProducer.setProducer() called by {0}: {1} replaced by {2}";
    private final static java.lang.String foundProducerOfSpecializedBean = "WELD-000134: Producer (method or field) of specialized bean (ignored): {0}";
    private final static java.lang.String setAnnotatedTypeCalled = "WELD-000148: ProcessAnnotatedType.setAnnotatedType() called by {0}: {1} replaced by {2}";
    private final static java.lang.String addContext = "WELD-000156: AfterBeanDiscovery.addContext() called by {0} for {1}";
    private final static java.lang.String extensionBeanDeployed = "WELD-000168: Extension bean deployed: {0}";
    private final static java.lang.String enabledAlternatives = "WELD-000103: Enabled alternatives for {0}: {1}";
    private final static java.lang.String ignoringClassDueToLoadingError = "WELD-000119: Not generating any bean definitions from {0} because of underlying class loading error: Type {1} not found.  If this is unexpected, enable DEBUG logging to see the full error.";
    private final static java.lang.String decoratorWithNonCdiConstructor = "WELD-000147: Decorator {0} declares inappropriate constructor therefore will not available as a managed bean!";
    private final static java.lang.String addAnnotatedTypeCalled = "WELD-000153: AfterTypeDiscovery.addAnnotatedType() called by {0} for {1}";
    private final static java.lang.String timeoutShuttingDownThreadPool = "WELD-000126: Timeout shutting down thread pool {0} at {1}";
    private final static java.lang.String foundDecorator = "WELD-000108: Decorator: {0}";
    private final static java.lang.String patSkipped = "No PAT observers resolved for {0}. Skipping.";
    private final static java.lang.String beanIdentifierIndexBuilt = "WELD-000145: Bean identifier index built:\n  {0}";
    private final static java.lang.String errorLoadingBeansXmlEntry = "WELD-000123: Error loading {0} defined in {1}";
    private final static java.lang.String ignoringExtensionClassDueToLoadingError = "WELD-000139: Ignoring portable extension class {0} because of underlying class loading error: Type {1} not found. Enable DEBUG logging level to see the full error.";
    private final static java.lang.String annotatedTypeJavaClassMismatch = "WELD-000130: Cannot replace AnnotatedType for {0} with AnnotatedType for {1}";
    private final static java.lang.String foundDisabledAlternative = "WELD-000132: Disabled alternative (ignored): {0}";
    private final static java.lang.String jtaUnavailable = "WELD-000101: Transactional services not available. Injection of @Inject UserTransaction not available. Transactional observers will be invoked synchronously.";
    private final static java.lang.String deploymentArchiveNull = "WELD-000113: BeanDeploymentArchive must not be null:  {0}";
    private final static java.lang.String enabledInterceptors = "WELD-000105: Enabled interceptor types for {0}: {1}";
    private final static java.lang.String unspecifiedRequiredService = "WELD-000117: Required service {0} has not been specified";
    private final static java.lang.String patDefaultResolver = "Sending PAT using the default event resolver: {0}";
    private final static java.lang.String managerNotInitialized = "WELD-000116: Manager has not been initialized";
    private final static java.lang.String typeModifiedInAfterTypeDiscovery = "WELD-000166: AfterTypeDiscovery.{3} modified by {0} {2} {1}";
    private final static java.lang.String passivatingNonNormalScopeIllegal = "WELD-000118: Only normal scopes can be passivating. Scope {0}";
    private final static java.lang.String addBeanCalled = "WELD-000154: AfterBeanDiscovery.addBean() called by {0} for {1}";
    private final static java.lang.String deploymentRequired = "WELD-000114: Must start the container with a deployment";
    private final static java.lang.String usingOldJandexVersion = "WELD-000169: Jandex cannot distinguish inner and static nested classes! Update Jandex to 2.0.3.Final version or newer to improve scanning performance.";
    private final static java.lang.String annotatedTypeNotRegisteredAsBeanDueToMissingAppropriateConstructor = "WELD-000167: Class {0} is annotated with @{1} but it does not declare an appropriate constructor therefore is not registered as a bean!";
    private final static java.lang.String beanAttributesVetoed = "WELD-000165: ProcessBeanAttributes.veto() called by {0} for {1}";
    private final static java.lang.String configuratorAndSetMethodBothCalled = "WELD-000170: {0} observer cannot call both the configurator and set methods. Extension {1} \nStackTrace:";
    private final static java.lang.String foundSpecializedBean = "WELD-000133: Specialized bean (ignored): {0}";
    private final static java.lang.String threadsInUse = "WELD-000124: Using {0} threads for bootstrap";
    private final static java.lang.String foundBean = "WELD-000106: Bean: {0}";
    private final static java.lang.String setBeanAttributesCalled = "WELD-000149: ProcessBeanAttributes.setBeanAttributes() called by {0}: {1} replaced by {2}";
    private final static java.lang.String catchingDebug = "Catching";
    private final static java.lang.String invalidPropertyValue = "WELD-000128: Invalid value for property {0}: {1}";
    private final static java.lang.String setInjectionTargetCalled = "WELD-000151: ProcessInjectionTarget.setInjectionTarget() called by {0}: {1} replaced by {2}";
    private final static java.lang.String annotatedTypeVetoed = "WELD-000164: ProcessAnnotatedType.veto() called by {0} for {1}";
    private final static java.lang.String addStereoTypeCalled = "WELD-000160: BeforeBeanDiscovery.addStereoType() called by {0} for {1}";
    private final static java.lang.String addDefinitionErrorCalled = "WELD-000157: AfterBeanDiscovery.addDefinitionError() called by {0} for {1}";
    private final static java.lang.String validatingBeans = "WELD-000100: Weld initialized. Validating beans";
    private final static java.lang.String beanTypeNotEjb = "WELD-000111: Bean type is not STATELESS, STATEFUL or SINGLETON:  {0}";
    private final static java.lang.String addQualifierCalled = "WELD-000158: BeforeBeanDiscovery.addQualifier() called by {0} for {1}";
    private final static java.lang.String foundInterceptor = "WELD-000107: Interceptor: {0}";

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

    public final void deprecatedAddAnnotatedTypeMethodUsed(final Class clazz) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, deprecatedAddAnnotatedTypeMethodUsed$str(), clazz);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public final void legacyDeploymentMetadataProvided() {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, legacyDeploymentMetadataProvided$str());
    }

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

    public final void exceptionThrownDuringBeforeShutdownObserver() {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), null, exceptionThrownDuringBeforeShutdownObserver$str());
    }

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

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

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

    public final void notUsingFastResolver(final ObserverMethod observer) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.INFO), null, notUsingFastResolver$str(), observer);
    }

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

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

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

    public final void patFastResolver(final org.jboss.weld.annotated.slim.SlimAnnotatedType type) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, patFastResolver$str(), type);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public final void patSkipped(final org.jboss.weld.annotated.slim.SlimAnnotatedType type) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, patSkipped$str(), type);
    }

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

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

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

    public final org.jboss.weld.exceptions.DeploymentException errorLoadingBeansXmlEntry(final java.lang.Object param1, final java.lang.Object param2, final java.lang.Throwable cause) {
        org.jboss.weld.exceptions.DeploymentException result = new org.jboss.weld.exceptions.DeploymentException(java.text.MessageFormat.format(errorLoadingBeansXmlEntry$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 errorLoadingBeansXmlEntry$str() {
        return errorLoadingBeansXmlEntry;
    }

    public final void ignoringExtensionClassDueToLoadingError(final java.lang.String className, final java.lang.String missingDependency) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, ignoringExtensionClassDueToLoadingError$str(), className, missingDependency);
    }

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

    public final org.jboss.weld.exceptions.IllegalArgumentException annotatedTypeJavaClassMismatch(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(annotatedTypeJavaClassMismatch$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 annotatedTypeJavaClassMismatch$str() {
        return annotatedTypeJavaClassMismatch;
    }

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

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

    public final void jtaUnavailable() {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, jtaUnavailable$str());
    }

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

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

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

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

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

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

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

    public final void patDefaultResolver(final org.jboss.weld.annotated.slim.SlimAnnotatedType type) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.TRACE), null, patDefaultResolver$str(), type);
    }

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

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

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

    public final void typeModifiedInAfterTypeDiscovery(final java.lang.Object extensionName, final java.lang.Object type, final java.lang.Object operation, final java.lang.Object types) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.DEBUG), null, typeModifiedInAfterTypeDiscovery$str(), extensionName, type, operation, types);
    }

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

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

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

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

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

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

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

    public final void usingOldJandexVersion() {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, usingOldJandexVersion$str());
    }

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

    public final void annotatedTypeNotRegisteredAsBeanDueToMissingAppropriateConstructor(final java.lang.String clazzName, final java.lang.String annotationName) {
        super.log.logv(FQCN, (org.jboss.logging.Logger.Level.WARN), null, annotatedTypeNotRegisteredAsBeanDueToMissingAppropriateConstructor$str(), clazzName, annotationName);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    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 invalidPropertyValue(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(invalidPropertyValue$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 invalidPropertyValue$str() {
        return invalidPropertyValue;
    }

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

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

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

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

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

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

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

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

    public final void validatingBeans() {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.DEBUG), null, validatingBeans$str());
    }

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

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

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

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

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

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

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

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy