io.undertow.UndertowMessages_$bundle Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.ops4j.pax.tipi.undertow.core
Show all versions of org.ops4j.pax.tipi.undertow.core
This OSGi bundle wraps ${tipi.orig.artifactId}-${tipi.orig.version}.
The newest version!
package io.undertow;
import java.lang.IllegalStateException;
import java.nio.channels.ClosedChannelException;
import java.io.Serializable;
import javax.annotation.Generated;
import io.undertow.protocols.http2.HpackException;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.lang.String;
import java.io.IOException;
import java.lang.Exception;
import java.lang.RuntimeException;
import java.lang.Class;
import java.lang.Object;
import java.util.Arrays;
import java.net.SocketAddress;
import java.lang.IllegalArgumentException;
/**
* Warning this class consists of generated code.
*/
@Generated(value = "org.jboss.logging.processor.generator.model.MessageBundleImplementor", date = "2016-09-16T15:20:18+1000")
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 String maximumConcurrentRequestsMustBeLargerThanZero = "UT000001: Maximum concurrent requests must be larger than zero.";
protected String maximumConcurrentRequestsMustBeLargerThanZero$str() {
return maximumConcurrentRequestsMustBeLargerThanZero;
}
@Override
public final IllegalArgumentException maximumConcurrentRequestsMustBeLargerThanZero() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(maximumConcurrentRequestsMustBeLargerThanZero$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String responseAlreadyStarted = "UT000002: The response has already been started";
protected String responseAlreadyStarted$str() {
return responseAlreadyStarted;
}
@Override
public final IllegalStateException responseAlreadyStarted() {
final IllegalStateException result = new IllegalStateException(String.format(responseAlreadyStarted$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String responseChannelAlreadyProvided = "UT000004: getResponseChannel() has already been called";
protected String responseChannelAlreadyProvided$str() {
return responseChannelAlreadyProvided;
}
@Override
public final IllegalStateException responseChannelAlreadyProvided() {
final IllegalStateException result = new IllegalStateException(String.format(responseChannelAlreadyProvided$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String requestChannelAlreadyProvided = "UT000005: getRequestChannel() has already been called";
protected String requestChannelAlreadyProvided$str() {
return requestChannelAlreadyProvided;
}
@Override
public final IllegalStateException requestChannelAlreadyProvided() {
final IllegalStateException result = new IllegalStateException(String.format(requestChannelAlreadyProvided$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String handlerCannotBeNull = "UT000008: Handler cannot be null";
protected String handlerCannotBeNull$str() {
return handlerCannotBeNull;
}
@Override
public final IllegalArgumentException handlerCannotBeNull() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(handlerCannotBeNull$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String pathMustBeSpecified = "UT000009: Path must be specified";
protected String pathMustBeSpecified$str() {
return pathMustBeSpecified;
}
@Override
public final IllegalArgumentException pathMustBeSpecified() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(pathMustBeSpecified$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sessionNotFound = "UT000010: Session not found %s";
protected String sessionNotFound$str() {
return sessionNotFound;
}
@Override
public final IllegalStateException sessionNotFound(final String session) {
final IllegalStateException result = new IllegalStateException(String.format(sessionNotFound$str(), session));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sessionManagerMustNotBeNull = "UT000011: Session manager must not be null";
protected String sessionManagerMustNotBeNull$str() {
return sessionManagerMustNotBeNull;
}
@Override
public final IllegalStateException sessionManagerMustNotBeNull() {
final IllegalStateException result = new IllegalStateException(String.format(sessionManagerMustNotBeNull$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sessionManagerNotFound = "UT000012: Session manager was not attached to the request. Make sure that the SessionAttachmentHandler is installed in the handler chain";
protected String sessionManagerNotFound$str() {
return sessionManagerNotFound;
}
@Override
public final IllegalStateException sessionManagerNotFound() {
final IllegalStateException result = new IllegalStateException(String.format(sessionManagerNotFound$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String argumentCannotBeNull = "UT000013: Argument %s cannot be null";
protected String argumentCannotBeNull$str() {
return argumentCannotBeNull;
}
@Override
public final IllegalArgumentException argumentCannotBeNull(final String argument) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(argumentCannotBeNull$str(), argument));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String closeCalledWithDataStillToBeFlushed = "UT000014: close() called with data still to be flushed. Please call shutdownWrites() and then call flush() until it returns true before calling close()";
protected String closeCalledWithDataStillToBeFlushed$str() {
return closeCalledWithDataStillToBeFlushed;
}
@Override
public final IOException closeCalledWithDataStillToBeFlushed() {
final IOException result = new IOException(String.format(closeCalledWithDataStillToBeFlushed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String cookieHandlerNotPresent = "UT000016: Could not add cookie as cookie handler was not present in the handler chain";
protected String cookieHandlerNotPresent$str() {
return cookieHandlerNotPresent;
}
@Override
public final IllegalStateException cookieHandlerNotPresent() {
final IllegalStateException result = new IllegalStateException(String.format(cookieHandlerNotPresent$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String formValueIsAFile = "UT000017: Form value is a file, use getFile() instead";
protected String formValueIsAFile$str() {
return formValueIsAFile;
}
@Override
public final IllegalStateException formValueIsAFile() {
final IllegalStateException result = new IllegalStateException(String.format(formValueIsAFile$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String formValueIsAString = "UT000018: Form value is a String, use getValue() instead";
protected String formValueIsAString$str() {
return formValueIsAString;
}
@Override
public final IllegalStateException formValueIsAString() {
final IllegalStateException result = new IllegalStateException(String.format(formValueIsAString$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String requestEntityWasTooLarge2 = "UT000019: Connection from %s terminated as request entity was larger than %s";
protected String requestEntityWasTooLarge2$str() {
return requestEntityWasTooLarge2;
}
@Override
public final IOException requestEntityWasTooLarge(final SocketAddress address, final long size) {
final IOException result = new IOException(String.format(requestEntityWasTooLarge2$str(), address, size));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String requestEntityWasTooLarge1 = "UT000020: Connection terminated as request was larger than %s";
protected String requestEntityWasTooLarge1$str() {
return requestEntityWasTooLarge1;
}
@Override
public final IOException requestEntityWasTooLarge(final long size) {
final IOException result = new IOException(String.format(requestEntityWasTooLarge1$str(), size));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sessionAlreadyInvalidated = "UT000021: Session already invalidated";
protected String sessionAlreadyInvalidated$str() {
return sessionAlreadyInvalidated;
}
@Override
public final IllegalStateException sessionAlreadyInvalidated() {
final IllegalStateException result = new IllegalStateException(String.format(sessionAlreadyInvalidated$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String hashAlgorithmNotFound = "UT000022: The specified hash algorithm '%s' can not be found.";
protected String hashAlgorithmNotFound$str() {
return hashAlgorithmNotFound;
}
@Override
public final IllegalArgumentException hashAlgorithmNotFound(final String algorithmName) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(hashAlgorithmNotFound$str(), algorithmName));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidBase64Token = "UT000023: An invalid Base64 token has been received.";
protected String invalidBase64Token$str() {
return invalidBase64Token;
}
@Override
public final IllegalArgumentException invalidBase64Token(final IOException cause) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(invalidBase64Token$str()), cause);
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidNonceReceived = "UT000024: An invalidly formatted nonce has been received.";
protected String invalidNonceReceived$str() {
return invalidNonceReceived;
}
@Override
public final IllegalArgumentException invalidNonceReceived() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(invalidNonceReceived$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String unexpectedTokenInHeader = "UT000025: Unexpected token '%s' within header.";
protected String unexpectedTokenInHeader$str() {
return unexpectedTokenInHeader;
}
@Override
public final IllegalArgumentException unexpectedTokenInHeader(final String name) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(unexpectedTokenInHeader$str(), name));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidHeader = "UT000026: Invalid header received.";
protected String invalidHeader$str() {
return invalidHeader;
}
@Override
public final IllegalArgumentException invalidHeader() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(invalidHeader$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotFindSessionCookieConfig = "UT000027: Could not find session cookie config in the request";
protected String couldNotFindSessionCookieConfig$str() {
return couldNotFindSessionCookieConfig;
}
@Override
public final IllegalStateException couldNotFindSessionCookieConfig() {
final IllegalStateException result = new IllegalStateException(String.format(couldNotFindSessionCookieConfig$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sessionAlreadyExists = "UT000028: Session %s already exists";
protected String sessionAlreadyExists$str() {
return sessionAlreadyExists;
}
@Override
public final IllegalStateException sessionAlreadyExists(final String id) {
final IllegalStateException result = new IllegalStateException(String.format(sessionAlreadyExists$str(), id));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String chunkedChannelClosedMidChunk = "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.";
protected String chunkedChannelClosedMidChunk$str() {
return chunkedChannelClosedMidChunk;
}
@Override
public final IOException chunkedChannelClosedMidChunk() {
final IOException result = new IOException(String.format(chunkedChannelClosedMidChunk$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String userAuthenticated = "UT000030: User %s successfully authenticated.";
protected String userAuthenticated$str() {
return userAuthenticated;
}
@Override
public final String userAuthenticated(final String userName) {
return String.format(userAuthenticated$str(), userName);
}
private static final String userLoggedOut = "UT000031: User %s has logged out.";
protected String userLoggedOut$str() {
return userLoggedOut;
}
@Override
public final String userLoggedOut(final String userName) {
return String.format(userLoggedOut$str(), userName);
}
private static final String authTypeCannotBeCombined = "UT000033: Authentication type %s cannot be combined with %s";
protected String authTypeCannotBeCombined$str() {
return authTypeCannotBeCombined;
}
@Override
public final IllegalStateException authTypeCannotBeCombined(final String type, final String existing) {
final IllegalStateException result = new IllegalStateException(String.format(authTypeCannotBeCombined$str(), type, existing));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String streamIsClosed = "UT000034: Stream is closed";
protected String streamIsClosed$str() {
return streamIsClosed;
}
@Override
public final IOException streamIsClosed() {
final IOException result = new IOException(String.format(streamIsClosed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String startBlockingHasNotBeenCalled = "UT000035: Cannot get stream as startBlocking has not been invoked";
protected String startBlockingHasNotBeenCalled$str() {
return startBlockingHasNotBeenCalled;
}
@Override
public final IllegalStateException startBlockingHasNotBeenCalled() {
final IllegalStateException result = new IllegalStateException(String.format(startBlockingHasNotBeenCalled$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String connectionTerminatedReadingMultiPartData = "UT000036: Connection terminated parsing multipart data";
protected String connectionTerminatedReadingMultiPartData$str() {
return connectionTerminatedReadingMultiPartData;
}
@Override
public final IOException connectionTerminatedReadingMultiPartData() {
final IOException result = new IOException(String.format(connectionTerminatedReadingMultiPartData$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String failedToParsePath = "UT000037: Failed to parse path in HTTP request";
protected String failedToParsePath$str() {
return failedToParsePath;
}
@Override
public final RuntimeException failedToParsePath() {
final RuntimeException result = new RuntimeException(String.format(failedToParsePath$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String authenticationFailed = "UT000038: Authentication failed, requested user name '%s'";
protected String authenticationFailed$str() {
return authenticationFailed;
}
@Override
public final String authenticationFailed(final String userName) {
return String.format(authenticationFailed$str(), userName);
}
private static final String tooManyQueryParameters = "UT000039: To many query parameters, cannot have more than %s query parameters";
protected String tooManyQueryParameters$str() {
return tooManyQueryParameters;
}
@Override
public final RuntimeException tooManyQueryParameters(final int noParams) {
final RuntimeException result = new RuntimeException(String.format(tooManyQueryParameters$str(), noParams));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String tooManyHeaders = "UT000040: To many headers, cannot have more than %s header";
protected String tooManyHeaders$str() {
return tooManyHeaders;
}
@Override
public final RuntimeException tooManyHeaders(final int noParams) {
final RuntimeException result = new RuntimeException(String.format(tooManyHeaders$str(), noParams));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String channelIsClosed = "UT000041: Channel is closed";
protected String channelIsClosed$str() {
return channelIsClosed;
}
@Override
public final ClosedChannelException channelIsClosed() {
final ClosedChannelException result = new ClosedChannelException();
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotDecodeTrailers = "UT000042: Could not decode trailers in HTTP request";
protected String couldNotDecodeTrailers$str() {
return couldNotDecodeTrailers;
}
@Override
public final IOException couldNotDecodeTrailers() {
final IOException result = new IOException(String.format(couldNotDecodeTrailers$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String dataAlreadyQueued = "UT000043: Data is already being sent. You must wait for the completion callback to be be invoked before calling send() again";
protected String dataAlreadyQueued$str() {
return dataAlreadyQueued;
}
@Override
public final IllegalStateException dataAlreadyQueued() {
final IllegalStateException result = new IllegalStateException(String.format(dataAlreadyQueued$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String moreThanOnePredicateWithName = "UT000044: More than one predicate with name %s. Builder class %s and %s";
protected String moreThanOnePredicateWithName$str() {
return moreThanOnePredicateWithName;
}
@Override
public final IllegalStateException moreThanOnePredicateWithName(final String name, final Class aClass, final Class existing) {
final IllegalStateException result = new IllegalStateException(String.format(moreThanOnePredicateWithName$str(), name, aClass, existing));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String errorParsingPredicateString = "UT000045: Error parsing predicated handler string %s:%n%s";
protected String errorParsingPredicateString$str() {
return errorParsingPredicateString;
}
@Override
public final IllegalArgumentException errorParsingPredicateString(final String reason, final String s) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(errorParsingPredicateString$str(), reason, s));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String tooManyCookies = "UT000046: The number of cookies sent exceeded the maximum of %s";
protected String tooManyCookies$str() {
return tooManyCookies;
}
@Override
public final IllegalStateException tooManyCookies(final int maxCookies) {
final IllegalStateException result = new IllegalStateException(String.format(tooManyCookies$str(), maxCookies));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String tooManyParameters = "UT000047: The number of parameters exceeded the maximum of %s";
protected String tooManyParameters$str() {
return tooManyParameters;
}
@Override
public final IllegalStateException tooManyParameters(final int maxValues) {
final IllegalStateException result = new IllegalStateException(String.format(tooManyParameters$str(), maxValues));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String noRequestActive = "UT000048: No request is currently active";
protected String noRequestActive$str() {
return noRequestActive;
}
@Override
public final IllegalStateException noRequestActive() {
final IllegalStateException result = new IllegalStateException(String.format(noRequestActive$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String authMechanismOutcomeNull = "UT000050: AuthenticationMechanism Outcome is null";
protected String authMechanismOutcomeNull$str() {
return authMechanismOutcomeNull;
}
@Override
public final IllegalStateException authMechanismOutcomeNull() {
final IllegalStateException result = new IllegalStateException(String.format(authMechanismOutcomeNull$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notAValidIpPattern = "UT000051: Not a valid IP pattern %s";
protected String notAValidIpPattern$str() {
return notAValidIpPattern;
}
@Override
public final IllegalArgumentException notAValidIpPattern(final String peer) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(notAValidIpPattern$str(), peer));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String noSessionData = "UT000052: Session data requested when non session based authentication in use";
protected String noSessionData$str() {
return noSessionData;
}
@Override
public final IllegalStateException noSessionData() {
final IllegalStateException result = new IllegalStateException(String.format(noSessionData$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String listenerAlreadyRegistered = "UT000053: Listener %s already registered";
protected String listenerAlreadyRegistered$str() {
return listenerAlreadyRegistered;
}
@Override
public final IllegalArgumentException listenerAlreadyRegistered(final String name) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(listenerAlreadyRegistered$str(), name));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String maxFileSizeExceeded = "UT000054: The maximum size %s for an individual file in a multipart request was exceeded";
protected String maxFileSizeExceeded$str() {
return maxFileSizeExceeded;
}
@Override
public final IOException maxFileSizeExceeded(final long maxIndividualFileSize) {
final IOException result = new IOException(String.format(maxFileSizeExceeded$str(), maxIndividualFileSize));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotSetAttribute = "UT000055: Could not set attribute %s to %s as it is read only";
protected String couldNotSetAttribute$str() {
return couldNotSetAttribute;
}
@Override
public final String couldNotSetAttribute(final String attributeName, final String newValue) {
return String.format(couldNotSetAttribute$str(), attributeName, newValue);
}
private static final String couldNotParseUriTemplate = "UT000056: Could not parse URI template %s, exception at char %s";
protected String couldNotParseUriTemplate$str() {
return couldNotParseUriTemplate;
}
@Override
public final RuntimeException couldNotParseUriTemplate(final String path, final int i) {
final RuntimeException result = new RuntimeException(String.format(couldNotParseUriTemplate$str(), path, i));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String mismatchedBraces = "UT000057: Mismatched braces in attribute string %s";
protected String mismatchedBraces$str() {
return mismatchedBraces;
}
@Override
public final RuntimeException mismatchedBraces(final String valueString) {
final RuntimeException result = new RuntimeException(String.format(mismatchedBraces$str(), valueString));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String moreThanOneHandlerWithName = "UT000058: More than one handler with name %s. Builder class %s and %s";
protected String moreThanOneHandlerWithName$str() {
return moreThanOneHandlerWithName;
}
@Override
public final IllegalStateException moreThanOneHandlerWithName(final String name, final Class aClass, final Class existing) {
final IllegalStateException result = new IllegalStateException(String.format(moreThanOneHandlerWithName$str(), name, aClass, existing));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidSyntax = "UT000059: Invalid syntax %s";
protected String invalidSyntax$str() {
return invalidSyntax;
}
@Override
public final IllegalArgumentException invalidSyntax(final String line) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(invalidSyntax$str(), line));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String errorParsingHandlerString = "UT000060: Error parsing handler string %s:%n%s";
protected String errorParsingHandlerString$str() {
return errorParsingHandlerString;
}
@Override
public final IllegalArgumentException errorParsingHandlerString(final String reason, final String s) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(errorParsingHandlerString$str(), reason, s));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String outOfBandResponseOnlyAllowedFor100Continue = "UT000061: Out of band responses only allowed for 100-continue requests";
protected String outOfBandResponseOnlyAllowedFor100Continue$str() {
return outOfBandResponseOnlyAllowedFor100Continue;
}
@Override
public final IllegalArgumentException outOfBandResponseOnlyAllowedFor100Continue() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(outOfBandResponseOnlyAllowedFor100Continue$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String ajpDoesNotSupportHTTPUpgrade = "UT000062: AJP does not support HTTP upgrade";
protected String ajpDoesNotSupportHTTPUpgrade$str() {
return ajpDoesNotSupportHTTPUpgrade;
}
@Override
public final IllegalStateException ajpDoesNotSupportHTTPUpgrade() {
final IllegalStateException result = new IllegalStateException(String.format(ajpDoesNotSupportHTTPUpgrade$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String fileSystemWatcherAlreadyStarted = "UT000063: File system watcher already started";
protected String fileSystemWatcherAlreadyStarted$str() {
return fileSystemWatcherAlreadyStarted;
}
@Override
public final IllegalStateException fileSystemWatcherAlreadyStarted() {
final IllegalStateException result = new IllegalStateException(String.format(fileSystemWatcherAlreadyStarted$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String fileSystemWatcherNotStarted = "UT000064: File system watcher not started";
protected String fileSystemWatcherNotStarted$str() {
return fileSystemWatcherNotStarted;
}
@Override
public final IllegalStateException fileSystemWatcherNotStarted() {
final IllegalStateException result = new IllegalStateException(String.format(fileSystemWatcherNotStarted$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String sslWasNull = "UT000065: SSL must be specified to connect to a https URL";
protected String sslWasNull$str() {
return sslWasNull;
}
@Override
public final IOException sslWasNull() {
final IOException result = new IOException(String.format(sslWasNull$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String wrongMagicNumber = "UT000066: Incorrect magic number %s for AJP packet header";
protected String wrongMagicNumber$str() {
return wrongMagicNumber;
}
@Override
public final IOException wrongMagicNumber(final int number) {
final IOException result = new IOException(String.format(wrongMagicNumber$str(), number));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String peerUnverified = "UT000067: No client cert was provided";
protected String peerUnverified$str() {
return peerUnverified;
}
@Override
public final SSLPeerUnverifiedException peerUnverified() {
final SSLPeerUnverifiedException result = new SSLPeerUnverifiedException(String.format(peerUnverified$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String servletPathMatchFailed = "UT000068: Servlet path match failed";
protected String servletPathMatchFailed$str() {
return servletPathMatchFailed;
}
@Override
public final IllegalArgumentException servletPathMatchFailed() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(servletPathMatchFailed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotParseCookie = "UT000069: Could not parse set cookie header %s";
protected String couldNotParseCookie$str() {
return couldNotParseCookie;
}
@Override
public final IllegalArgumentException couldNotParseCookie(final String headerValue) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(couldNotParseCookie$str(), headerValue));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String canOnlyBeCalledByIoThread = "UT000070: method can only be called by IO thread";
protected String canOnlyBeCalledByIoThread$str() {
return canOnlyBeCalledByIoThread;
}
@Override
public final IllegalStateException canOnlyBeCalledByIoThread() {
final IllegalStateException result = new IllegalStateException(String.format(canOnlyBeCalledByIoThread$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String matcherAlreadyContainsTemplate = "UT000071: Cannot add path template %s, matcher already contains an equivalent pattern %s";
protected String matcherAlreadyContainsTemplate$str() {
return matcherAlreadyContainsTemplate;
}
@Override
public final IllegalStateException matcherAlreadyContainsTemplate(final String templateString, final String templateString1) {
final IllegalStateException result = new IllegalStateException(String.format(matcherAlreadyContainsTemplate$str(), templateString, templateString1));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String failedToDecodeURL = "UT000072: Failed to decode url %s to charset %s";
protected String failedToDecodeURL$str() {
return failedToDecodeURL;
}
@Override
public final IllegalArgumentException failedToDecodeURL(final String s, final String enc, final Exception e) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(failedToDecodeURL$str(), s, enc), e);
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String resourceChangeListenerNotSupported = "UT000073: Resource change listeners are not supported";
protected String resourceChangeListenerNotSupported$str() {
return resourceChangeListenerNotSupported;
}
@Override
public final IllegalArgumentException resourceChangeListenerNotSupported() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(resourceChangeListenerNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotRenegotiate = "UT000074: Could not renegotiate SSL connection to require client certificate, as client had sent more data";
protected String couldNotRenegotiate$str() {
return couldNotRenegotiate;
}
@Override
public final IllegalStateException couldNotRenegotiate() {
final IllegalStateException result = new IllegalStateException(String.format(couldNotRenegotiate$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String objectWasFreed = "UT000075: Object was freed";
protected String objectWasFreed$str() {
return objectWasFreed;
}
@Override
public final IllegalStateException objectWasFreed() {
final IllegalStateException result = new IllegalStateException(String.format(objectWasFreed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String handlerNotShutdown = "UT000076: Handler not shutdown";
protected String handlerNotShutdown$str() {
return handlerNotShutdown;
}
@Override
public final IllegalStateException handlerNotShutdown() {
final IllegalStateException result = new IllegalStateException(String.format(handlerNotShutdown$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String upgradeNotSupported = "UT000077: The underlying transport does not support HTTP upgrade";
protected String upgradeNotSupported$str() {
return upgradeNotSupported;
}
@Override
public final IllegalStateException upgradeNotSupported() {
final IllegalStateException result = new IllegalStateException(String.format(upgradeNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String renegotiationNotSupported = "UT000078: Renegotiation not supported";
protected String renegotiationNotSupported$str() {
return renegotiationNotSupported;
}
@Override
public final IOException renegotiationNotSupported() {
final IOException result = new IOException(String.format(renegotiationNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notAValidUserAgentPattern = "UT000079: Not a valid user agent pattern %s";
protected String notAValidUserAgentPattern$str() {
return notAValidUserAgentPattern;
}
@Override
public final IllegalArgumentException notAValidUserAgentPattern(final String userAgent) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(notAValidUserAgentPattern$str(), userAgent));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notAValidRegularExpressionPattern = "UT000080: Not a valid regular expression pattern %s";
protected String notAValidRegularExpressionPattern$str() {
return notAValidRegularExpressionPattern;
}
@Override
public final IllegalArgumentException notAValidRegularExpressionPattern(final String pattern) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(notAValidRegularExpressionPattern$str(), pattern));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String badRequest = "UT000081: Bad request";
protected String badRequest$str() {
return badRequest;
}
@Override
public final RuntimeException badRequest() {
final RuntimeException result = new RuntimeException(String.format(badRequest$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String hostAlreadyRegistered = "UT000082: Host %s already registered";
protected String hostAlreadyRegistered$str() {
return hostAlreadyRegistered;
}
@Override
public final RuntimeException hostAlreadyRegistered(final Object host) {
final RuntimeException result = new RuntimeException(String.format(hostAlreadyRegistered$str(), host));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String hostHasNotBeenRegistered = "UT000083: Host %s has not been registered";
protected String hostHasNotBeenRegistered$str() {
return hostHasNotBeenRegistered;
}
@Override
public final RuntimeException hostHasNotBeenRegistered(final Object host) {
final RuntimeException result = new RuntimeException(String.format(hostHasNotBeenRegistered$str(), host));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String extraDataWrittenAfterChunkEnd = "UT000084: Attempted to write additional data after the last chunk";
protected String extraDataWrittenAfterChunkEnd$str() {
return extraDataWrittenAfterChunkEnd;
}
@Override
public final IOException extraDataWrittenAfterChunkEnd() {
final IOException result = new IOException(String.format(extraDataWrittenAfterChunkEnd$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotGenerateUniqueSessionId = "UT000085: Could not generate unique session id";
protected String couldNotGenerateUniqueSessionId$str() {
return couldNotGenerateUniqueSessionId;
}
@Override
public final RuntimeException couldNotGenerateUniqueSessionId() {
final RuntimeException result = new RuntimeException(String.format(couldNotGenerateUniqueSessionId$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String mustProvideHeapBuffer = "UT000086: SPDY needs to be provided with a heap buffer pool, for use in compressing and decompressing headers.";
protected String mustProvideHeapBuffer$str() {
return mustProvideHeapBuffer;
}
@Override
public final IllegalArgumentException mustProvideHeapBuffer() {
final IllegalArgumentException result = new IllegalArgumentException(String.format(mustProvideHeapBuffer$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String unexpectedFrameType = "UT000087: Unexpected SPDY frame type %s";
protected String unexpectedFrameType$str() {
return unexpectedFrameType;
}
@Override
public final IOException unexpectedFrameType(final int type) {
final IOException result = new IOException(String.format(unexpectedFrameType$str(), type));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String controlFrameCannotHaveBodyContent = "UT000088: SPDY control frames cannot have body content";
protected String controlFrameCannotHaveBodyContent$str() {
return controlFrameCannotHaveBodyContent;
}
@Override
public final IOException controlFrameCannotHaveBodyContent() {
final IOException result = new IOException(String.format(controlFrameCannotHaveBodyContent$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String spdyNotSupported = "UT000089: SPDY not supported";
protected String spdyNotSupported$str() {
return spdyNotSupported;
}
@Override
public final IOException spdyNotSupported() {
final IOException result = new IOException(String.format(spdyNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String alpnNotAvailable = "UT000090: No ALPN implementation available (tried Jetty ALPN and JDK9)";
protected String alpnNotAvailable$str() {
return alpnNotAvailable;
}
@Override
public final IOException alpnNotAvailable() {
final IOException result = new IOException(String.format(alpnNotAvailable$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String bufferAlreadyFreed = "UT000091: Buffer has already been freed";
protected String bufferAlreadyFreed$str() {
return bufferAlreadyFreed;
}
@Override
public final IllegalStateException bufferAlreadyFreed() {
final IllegalStateException result = new IllegalStateException(String.format(bufferAlreadyFreed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String headersTooLargeToFitInHeapBuffer = "UT000092: A SPDY header was too large to fit in a response buffer, if you want to support larger headers please increase the buffer size";
protected String headersTooLargeToFitInHeapBuffer$str() {
return headersTooLargeToFitInHeapBuffer;
}
@Override
public final IllegalStateException headersTooLargeToFitInHeapBuffer() {
final IllegalStateException result = new IllegalStateException(String.format(headersTooLargeToFitInHeapBuffer$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String spdyStreamWasReset = "UT000093: A SPDY stream was reset by the remote endpoint";
protected String spdyStreamWasReset$str() {
return spdyStreamWasReset;
}
@Override
public final IOException spdyStreamWasReset() {
final IOException result = new IOException(String.format(spdyStreamWasReset$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String awaitCalledFromIoThread = "UT000094: Blocking await method called from IO thread. Blocking IO must be dispatched to a worker thread or deadlocks will result.";
protected String awaitCalledFromIoThread$str() {
return awaitCalledFromIoThread;
}
@Override
public final IOException awaitCalledFromIoThread() {
final IOException result = new IOException(String.format(awaitCalledFromIoThread$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String recursiveCallToFlushingSenders = "UT000095: Recursive call to flushSenders()";
protected String recursiveCallToFlushingSenders$str() {
return recursiveCallToFlushingSenders;
}
@Override
public final RuntimeException recursiveCallToFlushingSenders() {
final RuntimeException result = new RuntimeException(String.format(recursiveCallToFlushingSenders$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String fixedLengthOverflow = "UT000096: More data was written to the channel than specified in the content-length";
protected String fixedLengthOverflow$str() {
return fixedLengthOverflow;
}
@Override
public final IllegalStateException fixedLengthOverflow() {
final IllegalStateException result = new IllegalStateException(String.format(fixedLengthOverflow$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String ajpRequestAlreadyInProgress = "UT000097: AJP request already in progress";
protected String ajpRequestAlreadyInProgress$str() {
return ajpRequestAlreadyInProgress;
}
@Override
public final IllegalStateException ajpRequestAlreadyInProgress() {
final IllegalStateException result = new IllegalStateException(String.format(ajpRequestAlreadyInProgress$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String httpPingDataMustBeLength8 = "UT000098: HTTP ping data must be 8 bytes in length";
protected String httpPingDataMustBeLength8$str() {
return httpPingDataMustBeLength8;
}
@Override
public final String httpPingDataMustBeLength8() {
return String.format(httpPingDataMustBeLength8$str());
}
private static final String invalidPingSize = "UT000099: Received a ping of size other than 8";
protected String invalidPingSize$str() {
return invalidPingSize;
}
@Override
public final String invalidPingSize() {
return String.format(invalidPingSize$str());
}
private static final String streamIdMustBeZeroForFrameType = "UT000100: stream id must be zero for frame type %s";
protected String streamIdMustBeZeroForFrameType$str() {
return streamIdMustBeZeroForFrameType;
}
@Override
public final String streamIdMustBeZeroForFrameType(final int frameType) {
return String.format(streamIdMustBeZeroForFrameType$str(), frameType);
}
private static final String streamIdMustNotBeZeroForFrameType = "UT000101: stream id must not be zero for frame type %s";
protected String streamIdMustNotBeZeroForFrameType$str() {
return streamIdMustNotBeZeroForFrameType;
}
@Override
public final String streamIdMustNotBeZeroForFrameType(final int frameType) {
return String.format(streamIdMustNotBeZeroForFrameType$str(), frameType);
}
private static final String rstStreamReceivedForIdleStream = "UT000102: RST_STREAM received for idle stream";
protected String rstStreamReceivedForIdleStream$str() {
return rstStreamReceivedForIdleStream;
}
@Override
public final String rstStreamReceivedForIdleStream() {
return String.format(rstStreamReceivedForIdleStream$str());
}
private static final String http2StreamWasReset = "UT000103: Http2 stream was reset";
protected String http2StreamWasReset$str() {
return http2StreamWasReset;
}
@Override
public final IOException http2StreamWasReset() {
final IOException result = new IOException(String.format(http2StreamWasReset$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String incorrectHttp2Preface = "UT000104: Incorrect HTTP2 preface";
protected String incorrectHttp2Preface$str() {
return incorrectHttp2Preface;
}
@Override
public final IOException incorrectHttp2Preface() {
final IOException result = new IOException(String.format(incorrectHttp2Preface$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String http2FrameTooLarge = "UT000105: HTTP2 frame to large";
protected String http2FrameTooLarge$str() {
return http2FrameTooLarge;
}
@Override
public final IOException http2FrameTooLarge() {
final IOException result = new IOException(String.format(http2FrameTooLarge$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String http2ContinuationFrameNotExpected = "UT000106: HTTP2 continuation frame received without a corresponding headers or push promise frame";
protected String http2ContinuationFrameNotExpected$str() {
return http2ContinuationFrameNotExpected;
}
@Override
public final IOException http2ContinuationFrameNotExpected() {
final IOException result = new IOException(String.format(http2ContinuationFrameNotExpected$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String huffmanEncodedHpackValueDidNotEndWithEOS = "UT000107: Huffman encoded value in HPACK headers did not end with EOS padding";
protected String huffmanEncodedHpackValueDidNotEndWithEOS$str() {
return huffmanEncodedHpackValueDidNotEndWithEOS;
}
@Override
public final HpackException huffmanEncodedHpackValueDidNotEndWithEOS() {
final HpackException result = new HpackException();
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String integerEncodedOverTooManyOctets = "UT000108: HPACK variable length integer encoded over too many octects, max is %s";
protected String integerEncodedOverTooManyOctets$str() {
return integerEncodedOverTooManyOctets;
}
@Override
public final HpackException integerEncodedOverTooManyOctets(final int maxIntegerOctets) {
final HpackException result = new HpackException();
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String zeroNotValidHeaderTableIndex = "UT000109: Zero is not a valid header table index";
protected String zeroNotValidHeaderTableIndex$str() {
return zeroNotValidHeaderTableIndex;
}
@Override
public final HpackException zeroNotValidHeaderTableIndex() {
final HpackException result = new HpackException();
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String cannotSendContinueResponse = "UT000110: Cannot send 100-Continue, getResponseChannel() has already been called";
protected String cannotSendContinueResponse$str() {
return cannotSendContinueResponse;
}
@Override
public final IOException cannotSendContinueResponse() {
final IOException result = new IOException(String.format(cannotSendContinueResponse$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String parserDidNotMakeProgress = "UT000111: Parser did not make progress";
protected String parserDidNotMakeProgress$str() {
return parserDidNotMakeProgress;
}
@Override
public final IOException parserDidNotMakeProgress() {
final IOException result = new IOException(String.format(parserDidNotMakeProgress$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String headersStreamCanOnlyBeCreatedByClient = "UT000112: Only client side can call createStream, if you wish to send a PUSH_PROMISE frame use createPushPromiseStream instead";
protected String headersStreamCanOnlyBeCreatedByClient$str() {
return headersStreamCanOnlyBeCreatedByClient;
}
@Override
public final IOException headersStreamCanOnlyBeCreatedByClient() {
final IOException result = new IOException(String.format(headersStreamCanOnlyBeCreatedByClient$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String pushPromiseCanOnlyBeCreatedByServer = "UT000113: Only the server side can send a push promise stream";
protected String pushPromiseCanOnlyBeCreatedByServer$str() {
return pushPromiseCanOnlyBeCreatedByServer;
}
@Override
public final IOException pushPromiseCanOnlyBeCreatedByServer() {
final IOException result = new IOException(String.format(pushPromiseCanOnlyBeCreatedByServer$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String invalidAclRule = "UT000114: Invalid IP access control rule %s. Format is: [ip-match] allow|deny";
protected String invalidAclRule$str() {
return invalidAclRule;
}
@Override
public final IllegalArgumentException invalidAclRule(final String rule) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(invalidAclRule$str(), rule));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String serverReceivedPushPromise = "UT000115: Server received PUSH_PROMISE frame from client";
protected String serverReceivedPushPromise$str() {
return serverReceivedPushPromise;
}
@Override
public final IOException serverReceivedPushPromise() {
final IOException result = new IOException(String.format(serverReceivedPushPromise$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String connectNotSupported = "UT000116: CONNECT not supported by this connector";
protected String connectNotSupported$str() {
return connectNotSupported;
}
@Override
public final IllegalStateException connectNotSupported() {
final IllegalStateException result = new IllegalStateException(String.format(connectNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notAConnectRequest = "UT000117: Request was not a CONNECT request";
protected String notAConnectRequest$str() {
return notAConnectRequest;
}
@Override
public final IllegalStateException notAConnectRequest() {
final IllegalStateException result = new IllegalStateException(String.format(notAConnectRequest$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String cannotResetBuffer = "UT000118: Cannot reset buffer, response has already been commited";
protected String cannotResetBuffer$str() {
return cannotResetBuffer;
}
@Override
public final IllegalStateException cannotResetBuffer() {
final IllegalStateException result = new IllegalStateException(String.format(cannotResetBuffer$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String http2PriRequestFailed = "UT000119: HTTP2 via prior knowledge failed";
protected String http2PriRequestFailed$str() {
return http2PriRequestFailed;
}
@Override
public final IOException http2PriRequestFailed() {
final IOException result = new IOException(String.format(http2PriRequestFailed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String outOfBandResponseNotSupported = "UT000120: Out of band responses are not allowed for this connector";
protected String outOfBandResponseNotSupported$str() {
return outOfBandResponseNotSupported;
}
@Override
public final IllegalStateException outOfBandResponseNotSupported() {
final IllegalStateException result = new IllegalStateException(String.format(outOfBandResponseNotSupported$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String tooManySessions = "UT000121: Session was rejected as the maximum number of sessions (%s) has been hit";
protected String tooManySessions$str() {
return tooManySessions;
}
@Override
public final IllegalStateException tooManySessions(final int maxSessions) {
final IllegalStateException result = new IllegalStateException(String.format(tooManySessions$str(), maxSessions));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String proxyConnectionFailed = "UT000122: CONNECT attempt failed as target proxy returned %s";
protected String proxyConnectionFailed$str() {
return proxyConnectionFailed;
}
@Override
public final IOException proxyConnectionFailed(final int responseCode) {
final IOException result = new IOException(String.format(proxyConnectionFailed$str(), responseCode));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String mcmpMessageRejectedDueToSuspiciousCharacters = "UT000123: MCMP message %s rejected due to suspicious characters";
protected String mcmpMessageRejectedDueToSuspiciousCharacters$str() {
return mcmpMessageRejectedDueToSuspiciousCharacters;
}
@Override
public final RuntimeException mcmpMessageRejectedDueToSuspiciousCharacters(final String data) {
final RuntimeException result = new RuntimeException(String.format(mcmpMessageRejectedDueToSuspiciousCharacters$str(), data));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String rengotiationTimedOut = "UT000124: renegotiation timed out";
protected String rengotiationTimedOut$str() {
return rengotiationTimedOut;
}
@Override
public final IllegalStateException rengotiationTimedOut() {
final IllegalStateException result = new IllegalStateException(String.format(rengotiationTimedOut$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String requestBodyAlreadyRead = "UT000125: Request body already read";
protected String requestBodyAlreadyRead$str() {
return requestBodyAlreadyRead;
}
@Override
public final IllegalStateException requestBodyAlreadyRead() {
final IllegalStateException result = new IllegalStateException(String.format(requestBodyAlreadyRead$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String blockingIoFromIOThread = "UT000126: Attempted to do blocking IO from the IO thread. This is prohibited as it may result in deadlocks";
protected String blockingIoFromIOThread$str() {
return blockingIoFromIOThread;
}
@Override
public final IllegalStateException blockingIoFromIOThread() {
final IllegalStateException result = new IllegalStateException(String.format(blockingIoFromIOThread$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String responseComplete = "UT000127: Response has already been sent";
protected String responseComplete$str() {
return responseComplete;
}
@Override
public final IllegalStateException responseComplete() {
final IllegalStateException result = new IllegalStateException(String.format(responseComplete$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String couldNotReadContentLengthData = "UT000128: Remote peer closed connection before all data could be read";
protected String couldNotReadContentLengthData$str() {
return couldNotReadContentLengthData;
}
@Override
public final IOException couldNotReadContentLengthData() {
final IOException result = new IOException(String.format(couldNotReadContentLengthData$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String failedToSendAfterBeingSafe = "UT000129: Failed to send after being safe to send";
protected String failedToSendAfterBeingSafe$str() {
return failedToSendAfterBeingSafe;
}
@Override
public final IllegalStateException failedToSendAfterBeingSafe() {
final IllegalStateException result = new IllegalStateException(String.format(failedToSendAfterBeingSafe$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String reasonPhraseToLargeForBuffer = "UT000130: HTTP reason phrase was too large for the buffer. Either provide a smaller message or a bigger buffer. Phrase: %s";
protected String reasonPhraseToLargeForBuffer$str() {
return reasonPhraseToLargeForBuffer;
}
@Override
public final IllegalStateException reasonPhraseToLargeForBuffer(final String phrase) {
final IllegalStateException result = new IllegalStateException(String.format(reasonPhraseToLargeForBuffer$str(), phrase));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String poolIsClosed = "UT000131: Buffer pool is closed";
protected String poolIsClosed$str() {
return poolIsClosed;
}
@Override
public final IllegalStateException poolIsClosed() {
final IllegalStateException result = new IllegalStateException(String.format(poolIsClosed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String hpackFailed = "UT000132: HPACK decode failed";
protected String hpackFailed$str() {
return hpackFailed;
}
@Override
public final HpackException hpackFailed() {
final HpackException result = new HpackException();
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String notAnUpgradeRequest = "UT000133: Request did not contain an Upgrade header, upgrade is not permitted";
protected String notAnUpgradeRequest$str() {
return notAnUpgradeRequest;
}
@Override
public final IllegalStateException notAnUpgradeRequest() {
final IllegalStateException result = new IllegalStateException(String.format(notAnUpgradeRequest$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String authenticationPropertyNotSet = "UT000134: Authentication mechanism %s requires property %s to be set";
protected String authenticationPropertyNotSet$str() {
return authenticationPropertyNotSet;
}
@Override
public final IllegalStateException authenticationPropertyNotSet(final String name, final String header) {
final IllegalStateException result = new IllegalStateException(String.format(authenticationPropertyNotSet$str(), name, header));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String rengotiationFailed = "UT000135: renegotiation failed";
protected String rengotiationFailed$str() {
return rengotiationFailed;
}
@Override
public final IllegalStateException rengotiationFailed() {
final IllegalStateException result = new IllegalStateException(String.format(rengotiationFailed$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String userAgentCharsetMustHaveEvenNumberOfItems = "UT000136: User agent charset string must have an even number of items, in the form pattern,charset,pattern,charset,... Instead got: %s";
protected String userAgentCharsetMustHaveEvenNumberOfItems$str() {
return userAgentCharsetMustHaveEvenNumberOfItems;
}
@Override
public final IllegalArgumentException userAgentCharsetMustHaveEvenNumberOfItems(final String supplied) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(userAgentCharsetMustHaveEvenNumberOfItems$str(), supplied));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String datasourceNotFound = "UT000137: Could not find the datasource called %s";
protected String datasourceNotFound$str() {
return datasourceNotFound;
}
@Override
public final IllegalArgumentException datasourceNotFound(final String ds) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(datasourceNotFound$str(), ds));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String exchangeAlreadyComplete = "UT000139: Exchange already complete";
protected String exchangeAlreadyComplete$str() {
return exchangeAlreadyComplete;
}
@Override
public final IllegalStateException exchangeAlreadyComplete() {
final IllegalStateException result = new IllegalStateException(String.format(exchangeAlreadyComplete$str()));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
private static final String newlineNotSupportedInHttpString = "UT000149: HttpString is not allowed to contain newlines. value: %s";
protected String newlineNotSupportedInHttpString$str() {
return newlineNotSupportedInHttpString;
}
@Override
public final IllegalArgumentException newlineNotSupportedInHttpString(final String value) {
final IllegalArgumentException result = new IllegalArgumentException(String.format(newlineNotSupportedInHttpString$str(), value));
final StackTraceElement[] st = result.getStackTrace();
result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
return result;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy