package io.undertow;

import java.util.Locale;
import java.lang.IllegalStateException;
import java.io.Serializable;
import io.undertow.util.ParameterLimitException;
import io.undertow.protocols.http2.HpackException;
import org.xnio.channels.ReadTimeoutException;
import java.lang.String;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.xnio.channels.WriteTimeoutException;
import java.lang.RuntimeException;
import java.lang.NullPointerException;
import io.undertow.server.handlers.form.MultiPartParserDefinition.FileTooLargeException;
import io.undertow.util.UrlDecodeException;
import java.lang.IllegalArgumentException;
import java.nio.channels.ClosedChannelException;
import javax.annotation.Generated;
import io.undertow.security.api.AuthenticationMechanism;
import io.undertow.server.RequestTooBigException;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.io.IOException;
import java.lang.Exception;
import java.lang.Long;
import io.undertow.util.BadRequestException;
import java.lang.Class;
import java.lang.Object;
import java.util.Arrays;
import io.undertow.util.HttpString;

Warning this class consists of generated code.
/**
 * Warning this class consists of generated code.
 */
@Generated(value = "org.jboss.logging.processor.generator.model.MessageBundleImplementor", date = "2020-12-07T05:26:57-0300")
public class UndertowMessages_$bundle implements UndertowMessages, Serializable {
    private static final long serialVersionUID = 1L;
    protected UndertowMessages_$bundle() {}
    public static final UndertowMessages_$bundle INSTANCE = new UndertowMessages_$bundle();
    protected Object readResolve() {
        return INSTANCE;
    }
    private static final Locale LOCALE = Locale.ROOT;
    protected Locale getLoggingLocale() {
        return LOCALE;
    }
    protected String maximumConcurrentRequestsMustBeLargerThanZero$str() {
        return "UT000001: Maximum concurrent requests must be larger than zero.";
    }
    @Override
    public final IllegalArgumentException maximumConcurrentRequestsMustBeLargerThanZero() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), maximumConcurrentRequestsMustBeLargerThanZero$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    private static void _copyStackTraceMinusOne(final Throwable e) {
        final StackTraceElement[] st = e.getStackTrace();
        e.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
    }
    protected String responseAlreadyStarted$str() {
        return "UT000002: The response has already been started";
    }
    @Override
    public final IllegalStateException responseAlreadyStarted() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), responseAlreadyStarted$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String responseChannelAlreadyProvided$str() {
        return "UT000004: getResponseChannel() has already been called";
    }
    @Override
    public final IllegalStateException responseChannelAlreadyProvided() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), responseChannelAlreadyProvided$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String requestChannelAlreadyProvided$str() {
        return "UT000005: getRequestChannel() has already been called";
    }
    @Override
    public final IllegalStateException requestChannelAlreadyProvided() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), requestChannelAlreadyProvided$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String handlerCannotBeNull$str() {
        return "UT000008: Handler cannot be null";
    }
    @Override
    public final IllegalArgumentException handlerCannotBeNull() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), handlerCannotBeNull$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String pathMustBeSpecified$str() {
        return "UT000009: Path must be specified";
    }
    @Override
    public final IllegalArgumentException pathMustBeSpecified() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), pathMustBeSpecified$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sessionIsInvalid$str() {
        return "UT000010: Session is invalid %s";
    }
    @Override
    public final IllegalStateException sessionIsInvalid(final String sessionId) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), sessionIsInvalid$str(), sessionId));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sessionManagerMustNotBeNull$str() {
        return "UT000011: Session manager must not be null";
    }
    @Override
    public final IllegalStateException sessionManagerMustNotBeNull() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), sessionManagerMustNotBeNull$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sessionManagerNotFound$str() {
        return "UT000012: Session manager was not attached to the request. Make sure that the SessionAttachmentHandler is installed in the handler chain";
    }
    @Override
    public final IllegalStateException sessionManagerNotFound() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), sessionManagerNotFound$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String argumentCannotBeNull$str() {
        return "UT000013: Argument %s cannot be null";
    }
    @Override
    public final IllegalArgumentException argumentCannotBeNull(final String argument) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), argumentCannotBeNull$str(), argument));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String formValueIsAFile$str() {
        return "UT000017: Form value is a file, use getFileItem() instead";
    }
    @Override
    public final IllegalStateException formValueIsAFile() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), formValueIsAFile$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String formValueIsAString$str() {
        return "UT000018: Form value is a String, use getValue() instead";
    }
    @Override
    public final IllegalStateException formValueIsAString() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), formValueIsAString$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String requestEntityWasTooLarge$str() {
        return "UT000020: Connection terminated as request was larger than %s";
    }
    @Override
    public final RequestTooBigException requestEntityWasTooLarge(final long size) {
        final RequestTooBigException result = new RequestTooBigException(String.format(getLoggingLocale(), requestEntityWasTooLarge$str(), size));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sessionAlreadyInvalidated$str() {
        return "UT000021: Session already invalidated";
    }
    @Override
    public final IllegalStateException sessionAlreadyInvalidated() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), sessionAlreadyInvalidated$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String hashAlgorithmNotFound$str() {
        return "UT000022: The specified hash algorithm '%s' can not be found.";
    }
    @Override
    public final IllegalArgumentException hashAlgorithmNotFound(final String algorithmName) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), hashAlgorithmNotFound$str(), algorithmName));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidBase64Token$str() {
        return "UT000023: An invalid Base64 token has been received.";
    }
    @Override
    public final IllegalArgumentException invalidBase64Token(final IOException cause) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidBase64Token$str()), cause);
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidNonceReceived$str() {
        return "UT000024: An invalidly formatted nonce has been received.";
    }
    @Override
    public final IllegalArgumentException invalidNonceReceived() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidNonceReceived$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String unexpectedTokenInHeader$str() {
        return "UT000025: Unexpected token '%s' within header.";
    }
    @Override
    public final IllegalArgumentException unexpectedTokenInHeader(final String name) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), unexpectedTokenInHeader$str(), name));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidHeader$str() {
        return "UT000026: Invalid header received.";
    }
    @Override
    public final IllegalArgumentException invalidHeader() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidHeader$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotFindSessionCookieConfig$str() {
        return "UT000027: Could not find session cookie config in the request";
    }
    @Override
    public final IllegalStateException couldNotFindSessionCookieConfig() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), couldNotFindSessionCookieConfig$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String chunkedChannelClosedMidChunk$str() {
        return "UT000029: Channel was closed mid chunk, if you have attempted to write chunked data you cannot shutdown the channel until after it has all been written.";
    }
    @Override
    public final IOException chunkedChannelClosedMidChunk() {
        final IOException result = new IOException(String.format(getLoggingLocale(), chunkedChannelClosedMidChunk$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String userAuthenticated$str() {
        return "UT000030: User %s successfully authenticated.";
    }
    @Override
    public final String userAuthenticated(final String userName) {
        return String.format(getLoggingLocale(), userAuthenticated$str(), userName);
    }
    protected String userLoggedOut$str() {
        return "UT000031: User %s has logged out.";
    }
    @Override
    public final String userLoggedOut(final String userName) {
        return String.format(getLoggingLocale(), userLoggedOut$str(), userName);
    }
    protected String streamIsClosed$str() {
        return "UT000034: Stream is closed";
    }
    @Override
    public final IOException streamIsClosed() {
        final IOException result = new IOException(String.format(getLoggingLocale(), streamIsClosed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String startBlockingHasNotBeenCalled$str() {
        return "UT000035: Cannot get stream as startBlocking has not been invoked";
    }
    @Override
    public final IllegalStateException startBlockingHasNotBeenCalled() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), startBlockingHasNotBeenCalled$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String connectionTerminatedReadingMultiPartData$str() {
        return "UT000036: Connection terminated parsing multipart data";
    }
    @Override
    public final IOException connectionTerminatedReadingMultiPartData() {
        final IOException result = new IOException(String.format(getLoggingLocale(), connectionTerminatedReadingMultiPartData$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String failedToParsePath$str() {
        return "UT000037: Failed to parse path in HTTP request";
    }
    @Override
    public final RuntimeException failedToParsePath() {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), failedToParsePath$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String authenticationFailed$str() {
        return "UT000038: Authentication failed, requested user name '%s'";
    }
    @Override
    public final String authenticationFailed(final String userName) {
        return String.format(getLoggingLocale(), authenticationFailed$str(), userName);
    }
    protected String tooManyQueryParameters$str() {
        return "UT000039: Too many query parameters, cannot have more than %s query parameters";
    }
    @Override
    public final BadRequestException tooManyQueryParameters(final int noParams) {
        final BadRequestException result = new BadRequestException(String.format(getLoggingLocale(), tooManyQueryParameters$str(), noParams));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String tooManyHeaders$str() {
        return "UT000040: Too many headers, cannot have more than %s header";
    }
    @Override
    public final String tooManyHeaders(final int noParams) {
        return String.format(getLoggingLocale(), tooManyHeaders$str(), noParams);
    }
    protected String channelIsClosed$str() {
        return "UT000041: Channel is closed";
    }
    @Override
    public final ClosedChannelException channelIsClosed() {
        final ClosedChannelException result = new ClosedChannelException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotDecodeTrailers$str() {
        return "UT000042: Could not decode trailers in HTTP request";
    }
    @Override
    public final IOException couldNotDecodeTrailers() {
        final IOException result = new IOException(String.format(getLoggingLocale(), couldNotDecodeTrailers$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String dataAlreadyQueued$str() {
        return "UT000043: Data is already being sent. You must wait for the completion callback to be be invoked before calling send() again";
    }
    @Override
    public final IllegalStateException dataAlreadyQueued() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), dataAlreadyQueued$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String moreThanOnePredicateWithName$str() {
        return "UT000044: More than one predicate with name %s. Builder class %s and %s";
    }
    @Override
    public final IllegalStateException moreThanOnePredicateWithName(final String name, final Class<? extends io.undertow.predicate.PredicateBuilder> aClass, final Class<? extends io.undertow.predicate.PredicateBuilder> existing) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), moreThanOnePredicateWithName$str(), name, aClass, existing));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String errorParsingPredicateString$str() {
        return "UT000045: Error parsing predicated handler string %s:%n%s";
    }
    @Override
    public final IllegalArgumentException errorParsingPredicateString(final String reason, final String s) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), errorParsingPredicateString$str(), reason, s));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String tooManyCookies$str() {
        return "UT000046: The number of cookies sent exceeded the maximum of %s";
    }
    @Override
    public final IllegalStateException tooManyCookies(final int maxCookies) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), tooManyCookies$str(), maxCookies));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String tooManyParameters$str() {
        return "UT000047: The number of parameters exceeded the maximum of %s";
    }
    @Override
    public final ParameterLimitException tooManyParameters(final int maxValues) {
        final ParameterLimitException result = new ParameterLimitException(String.format(getLoggingLocale(), tooManyParameters$str(), maxValues));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String noRequestActive$str() {
        return "UT000048: No request is currently active";
    }
    @Override
    public final IllegalStateException noRequestActive() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), noRequestActive$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String authMechanismOutcomeNull$str() {
        return "UT000050: AuthenticationMechanism Outcome is null";
    }
    @Override
    public final IllegalStateException authMechanismOutcomeNull() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), authMechanismOutcomeNull$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notAValidIpPattern$str() {
        return "UT000051: Not a valid IP pattern %s";
    }
    @Override
    public final IllegalArgumentException notAValidIpPattern(final String peer) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), notAValidIpPattern$str(), peer));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String noSessionData$str() {
        return "UT000052: Session data requested when non session based authentication in use";
    }
    @Override
    public final IllegalStateException noSessionData() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), noSessionData$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String listenerAlreadyRegistered$str() {
        return "UT000053: Listener %s already registered";
    }
    @Override
    public final IllegalArgumentException listenerAlreadyRegistered(final String name) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), listenerAlreadyRegistered$str(), name));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String maxFileSizeExceeded$str() {
        return "UT000054: The maximum size %s for an individual file in a multipart request was exceeded";
    }
    @Override
    public final FileTooLargeException maxFileSizeExceeded(final long maxIndividualFileSize) {
        final FileTooLargeException result = new FileTooLargeException(String.format(getLoggingLocale(), maxFileSizeExceeded$str(), maxIndividualFileSize));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotSetAttribute$str() {
        return "UT000055: Could not set attribute %s to %s as it is read only";
    }
    @Override
    public final String couldNotSetAttribute(final String attributeName, final String newValue) {
        return String.format(getLoggingLocale(), couldNotSetAttribute$str(), attributeName, newValue);
    }
    protected String couldNotParseUriTemplate$str() {
        return "UT000056: Could not parse URI template %s, exception at char %s";
    }
    @Override
    public final RuntimeException couldNotParseUriTemplate(final String path, final int i) {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), couldNotParseUriTemplate$str(), path, i));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String mismatchedBraces$str() {
        return "UT000057: Mismatched braces in attribute string %s";
    }
    @Override
    public final RuntimeException mismatchedBraces(final String valueString) {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), mismatchedBraces$str(), valueString));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String moreThanOneHandlerWithName$str() {
        return "UT000058: More than one handler with name %s. Builder class %s and %s";
    }
    @Override
    public final IllegalStateException moreThanOneHandlerWithName(final String name, final Class<? extends io.undertow.server.handlers.builder.HandlerBuilder> aClass, final Class<? extends io.undertow.server.handlers.builder.HandlerBuilder> existing) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), moreThanOneHandlerWithName$str(), name, aClass, existing));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String outOfBandResponseOnlyAllowedFor100Continue$str() {
        return "UT000061: Out of band responses only allowed for 100-continue requests";
    }
    @Override
    public final IllegalArgumentException outOfBandResponseOnlyAllowedFor100Continue() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), outOfBandResponseOnlyAllowedFor100Continue$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sslWasNull$str() {
        return "UT000065: SSL must be specified to connect to a https URL";
    }
    @Override
    public final IOException sslWasNull() {
        final IOException result = new IOException(String.format(getLoggingLocale(), sslWasNull$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String wrongMagicNumber$str() {
        return "UT000066: Incorrect magic number %s for AJP packet header";
    }
    @Override
    public final IOException wrongMagicNumber(final int number) {
        final IOException result = new IOException(String.format(getLoggingLocale(), wrongMagicNumber$str(), number));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String peerUnverified$str() {
        return "UT000067: No client cert was provided";
    }
    @Override
    public final SSLPeerUnverifiedException peerUnverified() {
        final SSLPeerUnverifiedException result = new SSLPeerUnverifiedException(String.format(getLoggingLocale(), peerUnverified$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String servletPathMatchFailed$str() {
        return "UT000068: Servlet path match failed";
    }
    @Override
    public final IllegalArgumentException servletPathMatchFailed() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), servletPathMatchFailed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotParseCookie$str() {
        return "UT000069: Could not parse set cookie header %s";
    }
    @Override
    public final IllegalArgumentException couldNotParseCookie(final String headerValue) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), couldNotParseCookie$str(), headerValue));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String canOnlyBeCalledByIoThread$str() {
        return "UT000070: method can only be called by IO thread";
    }
    @Override
    public final IllegalStateException canOnlyBeCalledByIoThread() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), canOnlyBeCalledByIoThread$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String matcherAlreadyContainsTemplate$str() {
        return "UT000071: Cannot add path template %s, matcher already contains an equivalent pattern %s";
    }
    @Override
    public final IllegalStateException matcherAlreadyContainsTemplate(final String templateString, final String templateString1) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), matcherAlreadyContainsTemplate$str(), templateString, templateString1));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String failedToDecodeURL$str() {
        return "UT000072: Failed to decode url %s to charset %s";
    }
    @Override
    public final UrlDecodeException failedToDecodeURL(final String s, final String enc, final Exception e) {
        final UrlDecodeException result = new UrlDecodeException(String.format(getLoggingLocale(), failedToDecodeURL$str(), s, enc), e);
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String resourceChangeListenerNotSupported$str() {
        return "UT000073: Resource change listeners are not supported";
    }
    @Override
    public final IllegalArgumentException resourceChangeListenerNotSupported() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), resourceChangeListenerNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String objectWasFreed$str() {
        return "UT000075: Object was freed";
    }
    @Override
    public final IllegalStateException objectWasFreed() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), objectWasFreed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String handlerNotShutdown$str() {
        return "UT000076: Handler not shutdown";
    }
    @Override
    public final IllegalStateException handlerNotShutdown() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), handlerNotShutdown$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String upgradeNotSupported$str() {
        return "UT000077: The underlying transport does not support HTTP upgrade";
    }
    @Override
    public final IllegalStateException upgradeNotSupported() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), upgradeNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String renegotiationNotSupported$str() {
        return "UT000078: Renegotiation not supported";
    }
    @Override
    public final IOException renegotiationNotSupported() {
        final IOException result = new IOException(String.format(getLoggingLocale(), renegotiationNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notAValidRegularExpressionPattern$str() {
        return "UT000080: Not a valid regular expression pattern %s";
    }
    @Override
    public final IllegalArgumentException notAValidRegularExpressionPattern(final String pattern) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), notAValidRegularExpressionPattern$str(), pattern));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String badRequest$str() {
        return "UT000081: Bad request";
    }
    @Override
    public final BadRequestException badRequest() {
        final BadRequestException result = new BadRequestException(String.format(getLoggingLocale(), badRequest$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String hostAlreadyRegistered$str() {
        return "UT000082: Host %s already registered";
    }
    @Override
    public final RuntimeException hostAlreadyRegistered(final Object host) {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), hostAlreadyRegistered$str(), host));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String hostHasNotBeenRegistered$str() {
        return "UT000083: Host %s has not been registered";
    }
    @Override
    public final RuntimeException hostHasNotBeenRegistered(final Object host) {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), hostHasNotBeenRegistered$str(), host));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String extraDataWrittenAfterChunkEnd$str() {
        return "UT000084: Attempted to write additional data after the last chunk";
    }
    @Override
    public final IOException extraDataWrittenAfterChunkEnd() {
        final IOException result = new IOException(String.format(getLoggingLocale(), extraDataWrittenAfterChunkEnd$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotGenerateUniqueSessionId$str() {
        return "UT000085: Could not generate unique session id";
    }
    @Override
    public final RuntimeException couldNotGenerateUniqueSessionId() {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), couldNotGenerateUniqueSessionId$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String controlFrameCannotHaveBodyContent$str() {
        return "UT000088: SPDY control frames cannot have body content";
    }
    @Override
    public final IOException controlFrameCannotHaveBodyContent() {
        final IOException result = new IOException(String.format(getLoggingLocale(), controlFrameCannotHaveBodyContent$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String bufferAlreadyFreed$str() {
        return "UT000091: Buffer has already been freed";
    }
    @Override
    public final IllegalStateException bufferAlreadyFreed() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), bufferAlreadyFreed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String awaitCalledFromIoThread$str() {
        return "UT000094: Blocking await method called from IO thread. Blocking IO must be dispatched to a worker thread or deadlocks will result.";
    }
    @Override
    public final IOException awaitCalledFromIoThread() {
        final IOException result = new IOException(String.format(getLoggingLocale(), awaitCalledFromIoThread$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String recursiveCallToFlushingSenders$str() {
        return "UT000095: Recursive call to flushSenders()";
    }
    @Override
    public final RuntimeException recursiveCallToFlushingSenders() {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), recursiveCallToFlushingSenders$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String fixedLengthOverflow$str() {
        return "UT000096: More data was written to the channel than specified in the content-length";
    }
    @Override
    public final IllegalStateException fixedLengthOverflow() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), fixedLengthOverflow$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String ajpRequestAlreadyInProgress$str() {
        return "UT000097: AJP request already in progress";
    }
    @Override
    public final IllegalStateException ajpRequestAlreadyInProgress() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), ajpRequestAlreadyInProgress$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String httpPingDataMustBeLength8$str() {
        return "UT000098: HTTP ping data must be 8 bytes in length";
    }
    @Override
    public final String httpPingDataMustBeLength8() {
        return String.format(getLoggingLocale(), httpPingDataMustBeLength8$str());
    }
    protected String invalidPingSize$str() {
        return "UT000099: Received a ping of size other than 8";
    }
    @Override
    public final String invalidPingSize() {
        return String.format(getLoggingLocale(), invalidPingSize$str());
    }
    protected String streamIdMustBeZeroForFrameType$str() {
        return "UT000100: stream id must be zero for frame type %s";
    }
    @Override
    public final String streamIdMustBeZeroForFrameType(final int frameType) {
        return String.format(getLoggingLocale(), streamIdMustBeZeroForFrameType$str(), frameType);
    }
    protected String streamIdMustNotBeZeroForFrameType$str() {
        return "UT000101: stream id must not be zero for frame type %s";
    }
    @Override
    public final String streamIdMustNotBeZeroForFrameType(final int frameType) {
        return String.format(getLoggingLocale(), streamIdMustNotBeZeroForFrameType$str(), frameType);
    }
    protected String http2StreamWasReset$str() {
        return "UT000103: Http2 stream was reset";
    }
    @Override
    public final IOException http2StreamWasReset() {
        final IOException result = new IOException(String.format(getLoggingLocale(), http2StreamWasReset$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String incorrectHttp2Preface$str() {
        return "UT000104: Incorrect HTTP2 preface";
    }
    @Override
    public final IOException incorrectHttp2Preface() {
        final IOException result = new IOException(String.format(getLoggingLocale(), incorrectHttp2Preface$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String http2FrameTooLarge$str() {
        return "UT000105: HTTP2 frame to large";
    }
    @Override
    public final IOException http2FrameTooLarge() {
        final IOException result = new IOException(String.format(getLoggingLocale(), http2FrameTooLarge$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String http2ContinuationFrameNotExpected$str() {
        return "UT000106: HTTP2 continuation frame received without a corresponding headers or push promise frame";
    }
    @Override
    public final IOException http2ContinuationFrameNotExpected() {
        final IOException result = new IOException(String.format(getLoggingLocale(), http2ContinuationFrameNotExpected$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String huffmanEncodedHpackValueDidNotEndWithEOS$str() {
        return "UT000107: Huffman encoded value in HPACK headers did not end with EOS padding";
    }
    @Override
    public final HpackException huffmanEncodedHpackValueDidNotEndWithEOS() {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String integerEncodedOverTooManyOctets$str() {
        return "UT000108: HPACK variable length integer encoded over too many octects, max is %s";
    }
    @Override
    public final HpackException integerEncodedOverTooManyOctets(final int maxIntegerOctets) {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String zeroNotValidHeaderTableIndex$str() {
        return "UT000109: Zero is not a valid header table index";
    }
    @Override
    public final HpackException zeroNotValidHeaderTableIndex() {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String cannotSendContinueResponse$str() {
        return "UT000110: Cannot send 100-Continue, getResponseChannel() has already been called";
    }
    @Override
    public final IOException cannotSendContinueResponse() {
        final IOException result = new IOException(String.format(getLoggingLocale(), cannotSendContinueResponse$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String parserDidNotMakeProgress$str() {
        return "UT000111: Parser did not make progress";
    }
    @Override
    public final IOException parserDidNotMakeProgress() {
        final IOException result = new IOException(String.format(getLoggingLocale(), parserDidNotMakeProgress$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String headersStreamCanOnlyBeCreatedByClient$str() {
        return "UT000112: Only client side can call createStream, if you wish to send a PUSH_PROMISE frame use createPushPromiseStream instead";
    }
    @Override
    public final IOException headersStreamCanOnlyBeCreatedByClient() {
        final IOException result = new IOException(String.format(getLoggingLocale(), headersStreamCanOnlyBeCreatedByClient$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String pushPromiseCanOnlyBeCreatedByServer$str() {
        return "UT000113: Only the server side can send a push promise stream";
    }
    @Override
    public final IOException pushPromiseCanOnlyBeCreatedByServer() {
        final IOException result = new IOException(String.format(getLoggingLocale(), pushPromiseCanOnlyBeCreatedByServer$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidAclRule$str() {
        return "UT000114: Invalid IP access control rule %s. Format is: [ip-match] allow|deny";
    }
    @Override
    public final IllegalArgumentException invalidAclRule(final String rule) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidAclRule$str(), rule));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String serverReceivedPushPromise$str() {
        return "UT000115: Server received PUSH_PROMISE frame from client";
    }
    @Override
    public final IOException serverReceivedPushPromise() {
        final IOException result = new IOException(String.format(getLoggingLocale(), serverReceivedPushPromise$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String connectNotSupported$str() {
        return "UT000116: CONNECT not supported by this connector";
    }
    @Override
    public final IllegalStateException connectNotSupported() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), connectNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notAConnectRequest$str() {
        return "UT000117: Request was not a CONNECT request";
    }
    @Override
    public final IllegalStateException notAConnectRequest() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), notAConnectRequest$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String cannotResetBuffer$str() {
        return "UT000118: Cannot reset buffer, response has already been commited";
    }
    @Override
    public final IllegalStateException cannotResetBuffer() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), cannotResetBuffer$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String http2PriRequestFailed$str() {
        return "UT000119: HTTP2 via prior knowledge failed";
    }
    @Override
    public final IOException http2PriRequestFailed() {
        final IOException result = new IOException(String.format(getLoggingLocale(), http2PriRequestFailed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String outOfBandResponseNotSupported$str() {
        return "UT000120: Out of band responses are not allowed for this connector";
    }
    @Override
    public final IllegalStateException outOfBandResponseNotSupported() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), outOfBandResponseNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String tooManySessions$str() {
        return "UT000121: Session was rejected as the maximum number of sessions (%s) has been hit";
    }
    @Override
    public final IllegalStateException tooManySessions(final int maxSessions) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), tooManySessions$str(), maxSessions));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String proxyConnectionFailed$str() {
        return "UT000122: CONNECT attempt failed as target proxy returned %s";
    }
    @Override
    public final IOException proxyConnectionFailed(final int responseCode) {
        final IOException result = new IOException(String.format(getLoggingLocale(), proxyConnectionFailed$str(), responseCode));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String mcmpMessageRejectedDueToSuspiciousCharacters$str() {
        return "UT000123: MCMP message %s rejected due to suspicious characters";
    }
    @Override
    public final RuntimeException mcmpMessageRejectedDueToSuspiciousCharacters(final String data) {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), mcmpMessageRejectedDueToSuspiciousCharacters$str(), data));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String rengotiationTimedOut$str() {
        return "UT000124: renegotiation timed out";
    }
    @Override
    public final IllegalStateException rengotiationTimedOut() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), rengotiationTimedOut$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String requestBodyAlreadyRead$str() {
        return "UT000125: Request body already read";
    }
    @Override
    public final IllegalStateException requestBodyAlreadyRead() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), requestBodyAlreadyRead$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String blockingIoFromIOThread$str() {
        return "UT000126: Attempted to do blocking IO from the IO thread. This is prohibited as it may result in deadlocks";
    }
    @Override
    public final IllegalStateException blockingIoFromIOThread() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), blockingIoFromIOThread$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String responseComplete$str() {
        return "UT000127: Response has already been sent";
    }
    @Override
    public final IllegalStateException responseComplete() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), responseComplete$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String couldNotReadContentLengthData$str() {
        return "UT000128: Remote peer closed connection before all data could be read";
    }
    @Override
    public final IOException couldNotReadContentLengthData() {
        final IOException result = new IOException(String.format(getLoggingLocale(), couldNotReadContentLengthData$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String failedToSendAfterBeingSafe$str() {
        return "UT000129: Failed to send after being safe to send";
    }
    @Override
    public final IllegalStateException failedToSendAfterBeingSafe() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), failedToSendAfterBeingSafe$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String reasonPhraseToLargeForBuffer$str() {
        return "UT000130: HTTP reason phrase was too large for the buffer. Either provide a smaller message or a bigger buffer. Phrase: %s";
    }
    @Override
    public final IllegalStateException reasonPhraseToLargeForBuffer(final String phrase) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), reasonPhraseToLargeForBuffer$str(), phrase));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String poolIsClosed$str() {
        return "UT000131: Buffer pool is closed";
    }
    @Override
    public final IllegalStateException poolIsClosed() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), poolIsClosed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String hpackFailed$str() {
        return "UT000132: HPACK decode failed";
    }
    @Override
    public final HpackException hpackFailed() {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notAnUpgradeRequest$str() {
        return "UT000133: Request did not contain an Upgrade header, upgrade is not permitted";
    }
    @Override
    public final IllegalStateException notAnUpgradeRequest() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), notAnUpgradeRequest$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String authenticationPropertyNotSet$str() {
        return "UT000134: Authentication mechanism %s requires property %s to be set";
    }
    @Override
    public final IllegalStateException authenticationPropertyNotSet(final String name, final String header) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), authenticationPropertyNotSet$str(), name, header));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String rengotiationFailed$str() {
        return "UT000135: renegotiation failed";
    }
    @Override
    public final IllegalStateException rengotiationFailed() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), rengotiationFailed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String userAgentCharsetMustHaveEvenNumberOfItems$str() {
        return "UT000136: User agent charset string must have an even number of items, in the form pattern,charset,pattern,charset,... Instead got: %s";
    }
    @Override
    public final IllegalArgumentException userAgentCharsetMustHaveEvenNumberOfItems(final String supplied) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), userAgentCharsetMustHaveEvenNumberOfItems$str(), supplied));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String datasourceNotFound$str() {
        return "UT000137: Could not find the datasource called %s";
    }
    @Override
    public final IllegalArgumentException datasourceNotFound(final String ds) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), datasourceNotFound$str(), ds));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String serverNotStarted$str() {
        return "UT000138: Server not started";
    }
    @Override
    public final IllegalStateException serverNotStarted() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), serverNotStarted$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String exchangeAlreadyComplete$str() {
        return "UT000139: Exchange already complete";
    }
    @Override
    public final IllegalStateException exchangeAlreadyComplete() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), exchangeAlreadyComplete$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notHandshakeRecord$str() {
        return "UT000140: Initial SSL/TLS data is not a handshake record";
    }
    @Override
    public final SSLHandshakeException notHandshakeRecord() {
        final SSLHandshakeException result = new SSLHandshakeException(String.format(getLoggingLocale(), notHandshakeRecord$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidHandshakeRecord$str() {
        return "UT000141: Initial SSL/TLS handshake record is invalid";
    }
    @Override
    public final SSLHandshakeException invalidHandshakeRecord() {
        final SSLHandshakeException result = new SSLHandshakeException(String.format(getLoggingLocale(), invalidHandshakeRecord$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String multiRecordSSLHandshake$str() {
        return "UT000142: Initial SSL/TLS handshake spans multiple records";
    }
    @Override
    public final SSLHandshakeException multiRecordSSLHandshake() {
        final SSLHandshakeException result = new SSLHandshakeException(String.format(getLoggingLocale(), multiRecordSSLHandshake$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String expectedClientHello$str() {
        return "UT000143: Expected \"client hello\" record";
    }
    @Override
    public final SSLHandshakeException expectedClientHello() {
        final SSLHandshakeException result = new SSLHandshakeException(String.format(getLoggingLocale(), expectedClientHello$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String expectedServerHello$str() {
        return "UT000144: Expected server hello";
    }
    @Override
    public final SSLHandshakeException expectedServerHello() {
        final SSLHandshakeException result = new SSLHandshakeException(String.format(getLoggingLocale(), expectedServerHello$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String tooManyRedirects$str() {
        return "UT000145: Too many redirects";
    }
    @Override
    public final IOException tooManyRedirects(final IOException exception) {
        final IOException result = new IOException(String.format(getLoggingLocale(), tooManyRedirects$str()), exception);
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String resumedAndDispatched$str() {
        return "UT000146: HttpServerExchange cannot have both async IO resumed and dispatch() called in the same cycle";
    }
    @Override
    public final IllegalStateException resumedAndDispatched() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), resumedAndDispatched$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String noHostInHttp11Request$str() {
        return "UT000147: No host header in a HTTP/1.1 request";
    }
    @Override
    public final IOException noHostInHttp11Request() {
        final IOException result = new IOException(String.format(getLoggingLocale(), noHostInHttp11Request$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidHpackEncoding$str() {
        return "UT000148: Invalid HPack encoding. First byte: %s";
    }
    @Override
    public final HpackException invalidHpackEncoding(final byte b) {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String newlineNotSupportedInHttpString$str() {
        return "UT000149: HttpString is not allowed to contain newlines. value: %s";
    }
    @Override
    public final IllegalArgumentException newlineNotSupportedInHttpString(final String value) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), newlineNotSupportedInHttpString$str(), value));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String pseudoHeaderInWrongOrder$str() {
        return "UT000150: Pseudo header %s received after receiving normal headers. Pseudo headers must be the first headers in a HTTP/2 header block.";
    }
    @Override
    public final String pseudoHeaderInWrongOrder(final HttpString header) {
        return String.format(getLoggingLocale(), pseudoHeaderInWrongOrder$str(), header);
    }
    protected String expectedContinuationFrame$str() {
        return "UT000151: Expected to receive a continuation frame";
    }
    @Override
    public final String expectedContinuationFrame() {
        return String.format(getLoggingLocale(), expectedContinuationFrame$str());
    }
    protected String incorrectFrameSize$str() {
        return "UT000152: Incorrect frame size";
    }
    @Override
    public final String incorrectFrameSize() {
        return String.format(getLoggingLocale(), incorrectFrameSize$str());
    }
    protected String streamNotRegistered$str() {
        return "UT000153: Stream id not registered";
    }
    @Override
    public final IllegalStateException streamNotRegistered() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), streamNotRegistered$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sendChallengeReturnedNull$str() {
        return "UT000154: Mechanism %s returned a null result from sendChallenge()";
    }
    @Override
    public final NullPointerException sendChallengeReturnedNull(final AuthenticationMechanism mechanism) {
        final NullPointerException result = new NullPointerException(String.format(getLoggingLocale(), sendChallengeReturnedNull$str(), mechanism));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String bodyIsSetAndNotReadyForFlush$str() {
        return "UT000155: Framed channel body was set when it was not ready for flush";
    }
    @Override
    public final IllegalStateException bodyIsSetAndNotReadyForFlush() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), bodyIsSetAndNotReadyForFlush$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidGzipHeader$str() {
        return "UT000156: Invalid GZIP header";
    }
    @Override
    public final IOException invalidGzipHeader() {
        final IOException result = new IOException(String.format(getLoggingLocale(), invalidGzipHeader$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidGZIPFooter$str() {
        return "UT000157: Invalid GZIP footer";
    }
    @Override
    public final IOException invalidGZIPFooter() {
        final IOException result = new IOException(String.format(getLoggingLocale(), invalidGZIPFooter$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String responseTooLargeToBuffer$str() {
        return "UT000158: Response of length %s is too large to buffer";
    }
    @Override
    public final IllegalStateException responseTooLargeToBuffer(final Long length) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), responseTooLargeToBuffer$str(), length));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String headerBlockTooLarge$str() {
        return "UT000161: HTTP/2 header block is too large";
    }
    @Override
    public final String headerBlockTooLarge() {
        return String.format(getLoggingLocale(), headerBlockTooLarge$str());
    }
    protected String invalidSameSiteMode$str() {
        return "UT000162: An invalid SameSite attribute [%s] is specified. It must be one of %s";
    }
    @Override
    public final IllegalArgumentException invalidSameSiteMode(final String mode, final String validAttributes) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidSameSiteMode$str(), mode, validAttributes));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidToken$str() {
        return "UT000163: Invalid token %s";
    }
    @Override
    public final IllegalArgumentException invalidToken(final byte c) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidToken$str(), c));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidHeaders$str() {
        return "UT000164: Request contained invalid headers";
    }
    @Override
    public final IllegalArgumentException invalidHeaders() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidHeaders$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidCharacterInRequestTarget$str() {
        return "UT000165: Invalid character %s in request-target";
    }
    @Override
    public final String invalidCharacterInRequestTarget(final char next) {
        return String.format(getLoggingLocale(), invalidCharacterInRequestTarget$str(), next);
    }
    protected String objectIsClosed$str() {
        return "UT000166: Pooled object is closed";
    }
    @Override
    public final IllegalStateException objectIsClosed() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), objectIsClosed$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String moreThanOneHostHeader$str() {
        return "UT000167: More than one host header in request";
    }
    @Override
    public final IOException moreThanOneHostHeader() {
        final IOException result = new IOException(String.format(getLoggingLocale(), moreThanOneHostHeader$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidCookieValue$str() {
        return "UT000168: An invalid character [ASCII code: %s] was present in the cookie value";
    }
    @Override
    public final IllegalArgumentException invalidCookieValue(final String value) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidCookieValue$str(), value));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidCookieDomain$str() {
        return "UT000169: An invalid domain [%s] was specified for this cookie";
    }
    @Override
    public final IllegalArgumentException invalidCookieDomain(final String value) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidCookieDomain$str(), value));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidCookiePath$str() {
        return "UT000170: An invalid path [%s] was specified for this cookie";
    }
    @Override
    public final IllegalArgumentException invalidCookiePath(final String value) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidCookiePath$str(), value));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidControlCharacter$str() {
        return "UT000173: An invalid control character [%s] was present in the cookie value or attribute";
    }
    @Override
    public final IllegalArgumentException invalidControlCharacter(final String value) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidControlCharacter$str(), value));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidEscapeCharacter$str() {
        return "UT000174: An invalid escape character in cookie value";
    }
    @Override
    public final IllegalArgumentException invalidEscapeCharacter() {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), invalidEscapeCharacter$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidHpackIndex$str() {
        return "UT000175: Invalid Hpack index %s";
    }
    @Override
    public final HpackException invalidHpackIndex(final int index) {
        final HpackException result = new HpackException();
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String bufferPoolTooSmall$str() {
        return "UT000178: Buffer pool is too small, min size is %s";
    }
    @Override
    public final IllegalArgumentException bufferPoolTooSmall(final int minSize) {
        final IllegalArgumentException result = new IllegalArgumentException(String.format(getLoggingLocale(), bufferPoolTooSmall$str(), minSize));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidProxyHeader$str() {
        return "UT000179: Invalid PROXY protocol header";
    }
    @Override
    public final IOException invalidProxyHeader() {
        final IOException result = new IOException(String.format(getLoggingLocale(), invalidProxyHeader$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String headerSizeToLarge$str() {
        return "UT000180: PROXY protocol header exceeded max size of 107 bytes";
    }
    @Override
    public final IOException headerSizeToLarge() {
        final IOException result = new IOException(String.format(getLoggingLocale(), headerSizeToLarge$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String http2TrailerToLargeForSingleBuffer$str() {
        return "UT000181: HTTP/2 trailers too large for single buffer";
    }
    @Override
    public final RuntimeException http2TrailerToLargeForSingleBuffer() {
        final RuntimeException result = new RuntimeException(String.format(getLoggingLocale(), http2TrailerToLargeForSingleBuffer$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String pingNotSupported$str() {
        return "UT000182: Ping not supported";
    }
    @Override
    public final IOException pingNotSupported() {
        final IOException result = new IOException(String.format(getLoggingLocale(), pingNotSupported$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String pingTimeout$str() {
        return "UT000183: Ping timed out";
    }
    @Override
    public final IOException pingTimeout() {
        final IOException result = new IOException(String.format(getLoggingLocale(), pingTimeout$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String streamLimitExceeded$str() {
        return "UT000184: Stream limit exceeded";
    }
    @Override
    public final IOException streamLimitExceeded() {
        final IOException result = new IOException(String.format(getLoggingLocale(), streamLimitExceeded$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidIpAddress$str() {
        return "UT000185: Invalid IP address %s";
    }
    @Override
    public final IOException invalidIpAddress(final String addressString) {
        final IOException result = new IOException(String.format(getLoggingLocale(), invalidIpAddress$str(), addressString));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String invalidTlsExt$str() {
        return "UT000186: Invalid TLS extension";
    }
    @Override
    public final SSLException invalidTlsExt() {
        final SSLException result = new SSLException(String.format(getLoggingLocale(), invalidTlsExt$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String notEnoughData$str() {
        return "UT000187: Not enough data";
    }
    @Override
    public final SSLException notEnoughData() {
        final SSLException result = new SSLException(String.format(getLoggingLocale(), notEnoughData$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String emptyHostNameSni$str() {
        return "UT000188: Empty host name in SNI extension";
    }
    @Override
    public final SSLException emptyHostNameSni() {
        final SSLException result = new SSLException(String.format(getLoggingLocale(), emptyHostNameSni$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String duplicatedSniServerName$str() {
        return "UT000189: Duplicated host name of type %s";
    }
    @Override
    public final SSLException duplicatedSniServerName(final int type) {
        final SSLException result = new SSLException(String.format(getLoggingLocale(), duplicatedSniServerName$str(), type));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String noContextForSslConnection$str() {
        return "UT000190: No context for SSL connection";
    }
    @Override
    public final SSLException noContextForSslConnection() {
        final SSLException result = new SSLException(String.format(getLoggingLocale(), noContextForSslConnection$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String defaultContextCannotBeNull$str() {
        return "UT000191: Default context cannot be null";
    }
    @Override
    public final IllegalStateException defaultContextCannotBeNull() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), defaultContextCannotBeNull$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String formValueIsInMemoryFile$str() {
        return "UT000192: Form value is a in-memory file, use getFileItem() instead";
    }
    @Override
    public final IllegalStateException formValueIsInMemoryFile() {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), formValueIsInMemoryFile$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String failedToDecodeParameterValue$str() {
        return "UT000193: Character decoding failed. Parameter [%s] with value [%s] has been ignored. Note: further occurrences of Parameter errors will be logged at DEBUG level.";
    }
    @Override
    public final String failedToDecodeParameterValue(final String parameter, final String value, final Exception e) {
        return String.format(getLoggingLocale(), failedToDecodeParameterValue$str(), parameter, value);
    }
    protected String failedToDecodeParameterName$str() {
        return "UT000194: Character decoding failed. Parameter with name [%s] has been ignored. Note: further occurrences of Parameter errors will be logged at DEBUG level.";
    }
    @Override
    public final String failedToDecodeParameterName(final String parameter, final Exception e) {
        return String.format(getLoggingLocale(), failedToDecodeParameterName$str(), parameter);
    }
    protected String chunkSizeTooLarge$str() {
        return "UT000195: Chunk size too large";
    }
    @Override
    public final IOException chunkSizeTooLarge() {
        final IOException result = new IOException(String.format(getLoggingLocale(), chunkSizeTooLarge$str()));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String sessionWithIdAlreadyExists$str() {
        return "UT000196: Session with id %s already exists";
    }
    @Override
    public final IllegalStateException sessionWithIdAlreadyExists(final String sessionID) {
        final IllegalStateException result = new IllegalStateException(String.format(getLoggingLocale(), sessionWithIdAlreadyExists$str(), sessionID));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String blockingReadTimedOut$str() {
        return "UT000197: Blocking read timed out after %s nanoseconds.";
    }
    @Override
    public final ReadTimeoutException blockingReadTimedOut(final long timeoutNanoseconds) {
        final ReadTimeoutException result = new ReadTimeoutException(String.format(getLoggingLocale(), blockingReadTimedOut$str(), timeoutNanoseconds));
        _copyStackTraceMinusOne(result);
        return result;
    }
    protected String blockingWriteTimedOut$str() {
        return "UT000198: Blocking write timed out after %s nanoseconds.";
    }
    @Override
    public final WriteTimeoutException blockingWriteTimedOut(final long timeoutNanoseconds) {
        final WriteTimeoutException result = new WriteTimeoutException(String.format(getLoggingLocale(), blockingWriteTimedOut$str(), timeoutNanoseconds));
        _copyStackTraceMinusOne(result);
        return result;
    }
}