
package org.jboss.jca.core;

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 = "2021-01-27T17:45:46+0100")
public class CoreLogger_$logger
    extends DelegatingBasicLogger
    implements Serializable, CoreLogger, BasicLogger
{

    private final static long serialVersionUID = 1L;
    private final static java.lang.String FQCN = CoreLogger_$logger.class.getName();
    private final static java.lang.String exceptionDuringConnectionClose = "IJ000901: Error during connection close";
    private final static java.lang.String securityContextSetupFailedCallbackSecurityNull = "IJ000202: SecurityContext setup failed since CallbackSecurity was null";
    private final static java.lang.String beforeCompletionErrorOccured = "IJ000314: Error during beforeCompletion: %s";
    private final static java.lang.String nullSubjectCrashRecovery = "IJ000905: Subject for crash recovery was null: %s";
    private final static java.lang.String throwableFromUnregisterConnection = "IJ000311: Throwable from unregister connection";
    private final static java.lang.String errorWhileLoadingUsersProperties = "IJ001002: Error while loading users.properties";
    private final static java.lang.String returningConnectionValidatorInterrupted = "IJ000601: ConnectionValidator has been interrupted";
    private final static java.lang.String multipleLocalTransactionConnectionListenerEnlisted = "IJ000405: Multiple LocalTransaction connection listeners enlisted for %s, cl=%s";
    private final static java.lang.String noUsersPropertiesFound = "IJ001001: No users.properties were found";
    private final static java.lang.String prepareCalledOnLocaltx = "IJ001101: Prepare called on a local tx. Use of local transactions on a JTA transaction with more than one branch may result in inconsistent data in some cases of failure";
    private final static java.lang.String invalidCapacityOption = "IJ000619: Invalid property '%s' with value '%s' for %s";
    private final static java.lang.String uncheckedThrowableInManagedConnectionDisconnected = "IJ000404: Unchecked throwable in managedConnectionDisconnected() cl=%s";
    private final static java.lang.String connectionErrorOccured = "IJ000305: Connection error occured: %s";
    private final static java.lang.String errorWhileClosingConnectionHandle = "IJ000312: Error while closing connection handle";
    private final static java.lang.String noLazyEnlistmentAvailable = "IJ000407: No lazy enlistment available for %s";
    private final static java.lang.String closingConnection = "IJ000100: Closing a connection for you. Please close them yourself: %s";
    private final static java.lang.String txConnectionListenerBoundary = "IJ000317: Transaction boundary";
    private final static java.lang.String deprecatedPool = "IJ000408: Deprecated pool: %s, using %s instead";
    private final static java.lang.String closingConnectionThrowable = "IJ000102: Throwable trying to close a connection for you, please close it yourself";
    private final static java.lang.String notifiedErrorDifferentManagedConnection = "IJ000307: Notified of error on a different managed connection";
    private final static java.lang.String backgroundValidationNonCompliantManagedConnectionFactory = "IJ000611: Warning: Background validation was specified with a non compliant ManagedConnectionFactory interface";
    private final static java.lang.String connectionLeak = "IJ000616: Leak detected in pool: %s (%s) (%d)";
    private final static java.lang.String unregisteredNullHandleManagedConnection = "IJ000303: Unregistered a null handle for managed connection: %s";
    private final static java.lang.String exceptionDuringCrashRecovery = "IJ000906: Error during crash recovery: %s (%s)";
    private final static java.lang.String noRolesPropertiesFound = "IJ001003: No roles.properties were found";
    private final static java.lang.String throwableWhileAttemptingGetNewGonnection = "IJ000604: Throwable while attempting to get a new connection: %s";
    private final static java.lang.String exceptionDuringCrashRecoveryInflow = "IJ000902: Error during inflow crash recovery for '%s' (%s)";
    private final static java.lang.String attemptReturnConnectionTwice = "IJ000609: Attempt to return connection twice: %s";
    private final static java.lang.String unableFillPool = "IJ000610: Unable to fill pool: %s";
    private final static java.lang.String noCallbackPropertiesFound = "IJ001005: No callback.properties were found";
    private final static java.lang.String activeHandles = "IJ000315: Pool %s has %d active handles";
    private final static java.lang.String noCrashRecoverySecurityDomain = "IJ000904: No security domain defined for crash recovery: %s";
    private final static java.lang.String destroyingConnectionNotValidated = "IJ000621: Destroying connection that could not be validated: %s";
    private final static java.lang.String unknownConnectionErrorOccured = "IJ000306: Unknown connection error occured: %s";
    private final static java.lang.String activeHandle = "IJ000316: Handle allocation: %s";
    private final static java.lang.String resourceExceptionCleaningUpManagedConnection = "IJ000607: ResourceException cleaning up managed connection: %s";
    private final static java.lang.String errorWhileLoadingCallbackProperties = "IJ001006: Error while loading callback.properties";
    private final static java.lang.String transactionNotFound = "IJ000504: Transaction not found: %s";
    private final static java.lang.String destroyingActiveConnection = "IJ000615: Destroying active connection in pool: %s (%s)";
    private final static java.lang.String throwableWhileTryingMatchManagedConnection = "IJ000606: Throwable while trying to match managed connection, destroying connection: %s";
    private final static java.lang.String registeredNullHandleManagedConnection = "IJ000301: Registered a null handle for managed connection: %s";
    private final static java.lang.String reconnectingConnectionHandleHasManagedConnection = "IJ000403: Reconnecting a connection handle that still has a managed connection: %s %s";
    private final static java.lang.String connectionValidatorIgnoredUnexpectedError = "IJ000603: ConnectionValidator ignored unexpected error";
    private final static java.lang.String throwableReturningConnection = "IJ000406: Throwable in returning connection: %s";
    private final static java.lang.String threadIsnotEnlistingThread = "IJ000501: Thread %s is not the enlisting thread %s";
    private final static java.lang.String delistingFailed = "IJ000318: Delisting resource in pool %s failed";
    private final static java.lang.String somethingWrongWithPooling = "IJ000313: There is something wrong with the pooling";
    private final static java.lang.String unsupportedPoolImplementation = "IJ000622: Unsupported pool implementation: %s";
    private final static java.lang.String closingConnectionNoClose = "IJ000103: Could not find a close method on alleged connection object (%s). Please close your own connections";
    private final static java.lang.String resourceExceptionReturningConnection = "IJ000402: ResourceException in returning connection: %s";
    private final static java.lang.String connectionValidatorIgnoredUnexpectedRuntimeException = "IJ000602: ConnectionValidator ignored unexpected runtime exception";
    private final static java.lang.String exceptionDuringCreateSubject = "IJ000614: Exception during createSubject() for %s: %s";
    private final static java.lang.String errorWhileLoadingRolesProperties = "IJ001004: Error while loading roles.properties";
    private final static java.lang.String unregisteredHandleNotRegistered = "IJ000302: Unregistered handle that was not registered: %s for managed connection: %s";
    private final static java.lang.String exceptionDuringCrashRecoverySubject = "IJ000903: Error creating Subject for crash recovery: %s (%s)";
    private final static java.lang.String transactionErrorInAfterCompletion = "IJ000503: Transaction %s error in afterCompletion %s";
    private final static java.lang.String destroyingConnectionNotSuccessfullyMatched2 = "IJ000605: Destroying connection that could not be successfully matched %s for %s";
    private final static java.lang.String securityContextSetupFailed = "IJ000201: SecurityContext setup failed: %s";
    private final static java.lang.String errorDuringTidyUpConnection = "IJ000401: Error during tidy up connection: %s";
    private final static java.lang.String invalidCapacityIncrementer = "IJ000617: Invalid incrementer capacity policy: %s";
    private final static java.lang.String exceptionDuringUnbind = "IJ000701: Exception during unbind";
    private final static java.lang.String throwableWhileTryingMatchManagedConnectionThenDestroyingConnection = "IJ000613: Throwable while trying to match managed connection, destroying connection: %s";
    private final static java.lang.String destroyingConnectionNotSuccessfullyMatched1 = "IJ000612: Destroying connection that could not be successfully matched: %s";
    private final static java.lang.String validateOnMatchNonCompliantManagedConnectionFactory = "IJ000620: Warning: ValidateOnMatch validation was specified with a non compliant ManagedConnectionFactory: %s";
    private final static java.lang.String transactionErrorInBeforeCompletion = "IJ000502: Transaction %s error in beforeCompletion %s";
    private final static java.lang.String destroyingReturnedConnectionMaximumPoolSizeExceeded = "IJ000608: Destroying returned connection, maximum pool size exceeded %s";
    private final static java.lang.String invalidCapacityDecrementer = "IJ000618: Invalid decrementer capacity policy: %s";

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

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

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

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

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

    public final void beforeCompletionErrorOccured(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), beforeCompletionErrorOccured$str(), cl);
    }

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

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

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

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

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

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

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

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

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

    public final void multipleLocalTransactionConnectionListenerEnlisted(final java.lang.String name, final java.lang.Object cl) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, multipleLocalTransactionConnectionListenerEnlisted$str(), name, cl);
    }

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

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

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

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

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

    public final void invalidCapacityOption(final java.lang.String key, final java.lang.String value, final java.lang.String policy) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, invalidCapacityOption$str(), key, value, policy);
    }

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

    public final void uncheckedThrowableInManagedConnectionDisconnected(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), uncheckedThrowableInManagedConnectionDisconnected$str(), cl);
    }

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

    public final void connectionErrorOccured(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), connectionErrorOccured$str(), cl);
    }

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

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

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

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

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

    public final void closingConnection(final java.lang.Object handle) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, closingConnection$str(), handle);
    }

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

    public final void txConnectionListenerBoundary(final java.lang.Exception e) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (e), txConnectionListenerBoundary$str());
    }

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

    public final void deprecatedPool(final java.lang.String oldPool, final java.lang.String newPool) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, deprecatedPool$str(), oldPool, newPool);
    }

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

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

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

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

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

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

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

    public final void connectionLeak(final java.lang.String poolName, final java.lang.String id, final long time, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), connectionLeak$str(), poolName, id, time);
    }

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

    public final void unregisteredNullHandleManagedConnection(final java.lang.Object managedConnection) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, unregisteredNullHandleManagedConnection$str(), managedConnection);
    }

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

    public final void exceptionDuringCrashRecovery(final java.lang.String jndiName, final java.lang.String reason, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), exceptionDuringCrashRecovery$str(), jndiName, reason);
    }

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

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

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

    public final void throwableWhileAttemptingGetNewGonnection(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), throwableWhileAttemptingGetNewGonnection$str(), cl);
    }

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

    public final void exceptionDuringCrashRecoveryInflow(final java.lang.String rar, final java.lang.Object as, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), exceptionDuringCrashRecoveryInflow$str(), rar, as);
    }

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

    public final void attemptReturnConnectionTwice(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), attemptReturnConnectionTwice$str(), cl);
    }

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

    public final void unableFillPool(final java.lang.Throwable t, final java.lang.String jndiName) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), unableFillPool$str(), jndiName);
    }

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

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

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

    public final void activeHandles(final java.lang.String pool, final int number) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), null, activeHandles$str(), pool, number);
    }

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

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

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

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

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

    public final void unknownConnectionErrorOccured(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), unknownConnectionErrorOccured$str(), cl);
    }

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

    public final void activeHandle(final java.lang.Object handle, final java.lang.Exception e) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (e), activeHandle$str(), handle);
    }

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

    public final void resourceExceptionCleaningUpManagedConnection(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), resourceExceptionCleaningUpManagedConnection$str(), cl);
    }

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

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

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

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

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

    public final void destroyingActiveConnection(final java.lang.String poolName, final java.lang.Object mc) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, destroyingActiveConnection$str(), poolName, mc);
    }

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

    public final void throwableWhileTryingMatchManagedConnection(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), throwableWhileTryingMatchManagedConnection$str(), cl);
    }

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

    public final void registeredNullHandleManagedConnection(final java.lang.Object managedConnection) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, registeredNullHandleManagedConnection$str(), managedConnection);
    }

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

    public final void reconnectingConnectionHandleHasManagedConnection(final java.lang.Object mc, final java.lang.Object connection) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, reconnectingConnectionHandleHasManagedConnection$str(), mc, connection);
    }

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

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

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

    public final void throwableReturningConnection(final java.lang.Object mc, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), throwableReturningConnection$str(), mc);
    }

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

    public final void threadIsnotEnlistingThread(final java.lang.Object currentThread, final java.lang.Object enlistingThread, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), threadIsnotEnlistingThread$str(), currentThread, enlistingThread);
    }

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

    public final void delistingFailed(final java.lang.String pool, final java.lang.Exception e) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (e), delistingFailed$str(), pool);
    }

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

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

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

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

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

    public final void closingConnectionNoClose(final java.lang.String clz) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, closingConnectionNoClose$str(), clz);
    }

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

    public final void closingConnection(final java.lang.Object handle, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), (t), closingConnection$str(), handle);
    }

    public final void resourceExceptionReturningConnection(final java.lang.Object mc, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), resourceExceptionReturningConnection$str(), mc);
    }

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

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

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

    public final void exceptionDuringCreateSubject(final java.lang.String jndiName, final java.lang.String description, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), exceptionDuringCreateSubject$str(), jndiName, description);
    }

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

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

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

    public final void unregisteredHandleNotRegistered(final java.lang.Object handle, final java.lang.Object managedConnection) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.INFO), null, unregisteredHandleNotRegistered$str(), handle, managedConnection);
    }

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

    public final void exceptionDuringCrashRecoverySubject(final java.lang.String jndiName, final java.lang.String reason, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), exceptionDuringCrashRecoverySubject$str(), jndiName, reason);
    }

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

    public final void transactionErrorInAfterCompletion(final java.lang.Object transaction, final java.lang.Object synch, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), transactionErrorInAfterCompletion$str(), transaction, synch);
    }

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

    public final void destroyingConnectionNotSuccessfullyMatched(final java.lang.Object cl, final java.lang.Object mcf) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, destroyingConnectionNotSuccessfullyMatched2$str(), cl, mcf);
    }

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

    public final void securityContextSetupFailed(final java.lang.String description, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.ERROR), (t), securityContextSetupFailed$str(), description);
    }

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

    public final void errorDuringTidyUpConnection(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), errorDuringTidyUpConnection$str(), cl);
    }

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

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

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

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

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

    public final void throwableWhileTryingMatchManagedConnectionThenDestroyingConnection(final java.lang.Object cl, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), throwableWhileTryingMatchManagedConnectionThenDestroyingConnection$str(), cl);
    }

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

    public final void destroyingConnectionNotSuccessfullyMatched(final java.lang.Object cl) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), null, destroyingConnectionNotSuccessfullyMatched1$str(), cl);
    }

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

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

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

    public final void transactionErrorInBeforeCompletion(final java.lang.Object transaction, final java.lang.Object synch, final java.lang.Throwable t) {
        super.log.logf(FQCN, (org.jboss.logging.Logger.Level.WARN), (t), transactionErrorInBeforeCompletion$str(), transaction, synch);
    }

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

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

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

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

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

}
