package org.jboss.resteasy.resteasy_jaxrs.i18n;
import java.util.Locale;
import javax.validation.ElementKind;
import javax.ws.rs.core.Response.Status;
import java.io.Serializable;
import javax.annotation.Generated;
import org.jboss.resteasy.annotations.Stream.MODE;
import java.lang.String;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URL;
import org.jboss.resteasy.util.WeightedLanguage;
import org.jboss.resteasy.api.validation.ConstraintType.Type;
import org.jboss.resteasy.logging.Logger.LoggerType;
import javax.ws.rs.core.MediaType;
import java.lang.Object;
import java.lang.reflect.AccessibleObject;
@Generated(value = "org.jboss.logging.processor.generator.model.MessageBundleImplementor", date = "2018-08-06T12:00:03+0200")
public class Messages_$bundle implements Messages, Serializable {
private static final long serialVersionUID = 1L;
protected Messages_$bundle() {}
public static final Messages_$bundle INSTANCE = new Messages_$bundle();
protected Object readResolve() {
return INSTANCE;
}
private static final Locale LOCALE = Locale.ROOT;
protected Locale getLoggingLocale() {
return LOCALE;
}
private static final String exceptionHasInvalidFormat = "RESTEASY008500: ResteasyViolationException has invalid format: %s";
protected String exceptionHasInvalidFormat$str() {
return exceptionHasInvalidFormat;
}
@Override
public final String exceptionHasInvalidFormat(final String line) {
return String.format(getLoggingLocale(), exceptionHasInvalidFormat$str(), line);
}
private static final String unableToParseException = "RESTEASY008525: Unable to parse ResteasyViolationException";
protected String unableToParseException$str() {
return unableToParseException;
}
@Override
public final String unableToParseException() {
return String.format(getLoggingLocale(), unableToParseException$str());
}
private static final String unexpectedPathNode = "RESTEASY008530: unexpected path node type: %s";
protected String unexpectedPathNode$str() {
return unexpectedPathNode;
}
@Override
public final String unexpectedPathNode(final ElementKind kind) {
return String.format(getLoggingLocale(), unexpectedPathNode$str(), kind);
}
private static final String unexpectedPathNodeViolation = "RESTEASY008535: unexpected path node type in method violation: %s";
protected String unexpectedPathNodeViolation$str() {
return unexpectedPathNodeViolation;
}
@Override
public final String unexpectedPathNodeViolation(final ElementKind kind) {
return String.format(getLoggingLocale(), unexpectedPathNodeViolation$str(), kind);
}
private static final String unexpectedViolationType = "RESTEASY008540: unexpected violation type: %s";
protected String unexpectedViolationType$str() {
return unexpectedViolationType;
}
@Override
public final String unexpectedViolationType(final Type type) {
return String.format(getLoggingLocale(), unexpectedViolationType$str(), type);
}
private static final String unknownObjectPassedAsConstraintViolation = "RESTEASY008545: unknown object passed as constraint violation: %s";
protected String unknownObjectPassedAsConstraintViolation$str() {
return unknownObjectPassedAsConstraintViolation;
}
@Override
public final String unknownObjectPassedAsConstraintViolation(final Object o) {
return String.format(getLoggingLocale(), unknownObjectPassedAsConstraintViolation$str(), o);
}
private static final String alreadyCanceled = "RESTEASY009500: -- already canceled";
protected String alreadyCanceled$str() {
return alreadyCanceled;
}
@Override
public final String alreadyCanceled() {
return String.format(getLoggingLocale(), alreadyCanceled$str());
}
private static final String alreadyDone = "RESTEASY009505: -- already done";
protected String alreadyDone$str() {
return alreadyDone;
}
@Override
public final String alreadyDone() {
return String.format(getLoggingLocale(), alreadyDone$str());
}
private static final String alreadySuspended = "RESTEASY009510: Already suspended";
protected String alreadySuspended$str() {
return alreadySuspended;
}
@Override
public final String alreadySuspended() {
return String.format(getLoggingLocale(), alreadySuspended$str());
}
private static final String cancel = "RESTEASY009515: cancel()";
protected String cancel$str() {
return cancel;
}
@Override
public final String cancel() {
return String.format(getLoggingLocale(), cancel$str());
}
private static final String cancellingWith503 = "RESTEASY009520: -- cancelling with 503";
protected String cancellingWith503$str() {
return cancellingWith503;
}
@Override
public final String cancellingWith503() {
return String.format(getLoggingLocale(), cancellingWith503$str());
}
private static final String onComplete = "RESTEASY009525: onComplete";
protected String onComplete$str() {
return onComplete;
}
@Override
public final String onComplete() {
return String.format(getLoggingLocale(), onComplete$str());
}
private static final String onTimeout = "RESTEASY009530: onTimeout";
protected String onTimeout$str() {
return onTimeout;
}
@Override
public final String onTimeout() {
return String.format(getLoggingLocale(), onTimeout$str());
}
private static final String requestNotSuspended = "RESTEASY009535: Request not suspended";
protected String requestNotSuspended$str() {
return requestNotSuspended;
}
@Override
public final String requestNotSuspended() {
return String.format(getLoggingLocale(), requestNotSuspended$str());
}
private static final String scheduledTimeout = "RESTEASY009540: scheduled timeout";
protected String scheduledTimeout$str() {
return scheduledTimeout;
}
@Override
public final String scheduledTimeout() {
return String.format(getLoggingLocale(), scheduledTimeout$str());
}
private static final String schedulingTimeout = "RESTEASY009545: scheduling timeout";
protected String schedulingTimeout$str() {
return schedulingTimeout;
}
@Override
public final String schedulingTimeout() {
return String.format(getLoggingLocale(), schedulingTimeout$str());
}
private static final String alwaysMarkedAtIndex0 = "RESTEASY003000: SelfExpandingBufferredInputStream is always marked at index 0.";
protected String alwaysMarkedAtIndex0$str() {
return alwaysMarkedAtIndex0;
}
@Override
public final String alwaysMarkedAtIndex0() {
return String.format(getLoggingLocale(), alwaysMarkedAtIndex0$str());
}
private static final String ambiguousInheritedAnnotations = "RESTEASY003005: Ambiguous inherited JAX-RS annotations applied to method: %s";
protected String ambiguousInheritedAnnotations$str() {
return ambiguousInheritedAnnotations;
}
@Override
public final String ambiguousInheritedAnnotations(final Method method) {
return String.format(getLoggingLocale(), ambiguousInheritedAnnotations$str(), method);
}
private static final String annotationsParamNull = "RESTEASY003010: annotations param was null";
protected String annotationsParamNull$str() {
return annotationsParamNull;
}
@Override
public final String annotationsParamNull() {
return String.format(getLoggingLocale(), annotationsParamNull$str());
}
private static final String applicationParamNull = "RESTEASY003015: application param was null";
protected String applicationParamNull$str() {
return applicationParamNull;
}
@Override
public final String applicationParamNull() {
return String.format(getLoggingLocale(), applicationParamNull$str());
}
private static final String attemptingToCast = "RESTEASY003017: ClassCastException: attempting to cast {0} to {1}";
protected String attemptingToCast$str() {
return attemptingToCast;
}
@Override
public final String attemptingToCast(final URL from, final URL to) {
return _formatMessage(attemptingToCast$str(), from, to);
}
private String _formatMessage(final String format, final Object... args) {
final java.text.MessageFormat formatter = new java.text.MessageFormat(format, getLoggingLocale());
return formatter.format(args, new StringBuffer(), new java.text.FieldPosition(0)).toString();
}
private static final String badArguments = "RESTEASY003020: Bad arguments passed to %s";
protected String badArguments$str() {
return badArguments;
}
@Override
public final String badArguments(final String methodName) {
return String.format(getLoggingLocale(), badArguments$str(), methodName);
}
private static final String badBase64Character = "RESTEASY003025: Bad Base64 input character decimal {0} in array position {1}";
protected String badBase64Character$str() {
return badBase64Character;
}
@Override
public final String badBase64Character(final int c, final int pos) {
return _formatMessage(badBase64Character$str(), c, pos);
}
private static final String base64InputNotProperlyPadded = "RESTEASY003030: Base64 input not properly padded.";
protected String base64InputNotProperlyPadded$str() {
return base64InputNotProperlyPadded;
}
@Override
public final String base64InputNotProperlyPadded() {
return String.format(getLoggingLocale(), base64InputNotProperlyPadded$str());
}
private static final String base64StringMustHaveFourCharacters = "RESTEASY003035: Base64-encoded string must have at least four characters, but length specified was %s";
protected String base64StringMustHaveFourCharacters$str() {
return base64StringMustHaveFourCharacters;
}
@Override
public final String base64StringMustHaveFourCharacters(final int len) {
return String.format(getLoggingLocale(), base64StringMustHaveFourCharacters$str(), len);
}
private static final String baseURINotSetForClientProxy = "RESTEASY003040: You have not set a base URI for the client proxy";
protected String baseURINotSetForClientProxy$str() {
return baseURINotSetForClientProxy;
}
@Override
public final String baseURINotSetForClientProxy() {
return String.format(getLoggingLocale(), baseURINotSetForClientProxy$str());
}
private static final String = "RESTEASY003045: CacheControl max-age header does not have a value: %s.";
protected String () {
return cacheControlMaxAgeHeader;
}
@Override
public final String (final String value) {
return String.format(getLoggingLocale(), cacheControlMaxAgeHeader$str(), value);
}
private static final String = "RESTEASY003050: CacheControl s-maxage header does not have a value: %s.";
protected String () {
return cacheControlSMaxAgeHeader;
}
@Override
public final String (final String value) {
return String.format(getLoggingLocale(), cacheControlSMaxAgeHeader$str(), value);
}
private static final String cacheControlValueNull = "RESTEASY003055: Cache-Control value is null";
protected String cacheControlValueNull$str() {
return cacheControlValueNull;
}
@Override
public final String cacheControlValueNull() {
return String.format(getLoggingLocale(), cacheControlValueNull$str());
}
private static final String callbackWasNull = "RESTEASY003060: Callback was null";
protected String callbackWasNull$str() {
return callbackWasNull;
}
@Override
public final String callbackWasNull() {
return String.format(getLoggingLocale(), callbackWasNull$str());
}
private static final String cannotConsumeContentType = "RESTEASY003065: Cannot consume content type";
protected String cannotConsumeContentType$str() {
return cannotConsumeContentType;
}
@Override
public final String cannotConsumeContentType() {
return String.format(getLoggingLocale(), cannotConsumeContentType$str());
}
private static final String cannotDecodeNullSourceArray = "RESTEASY003070: Cannot decode null source array.";
protected String cannotDecodeNullSourceArray$str() {
return cannotDecodeNullSourceArray;
}
@Override
public final String cannotDecodeNullSourceArray() {
return String.format(getLoggingLocale(), cannotDecodeNullSourceArray$str());
}
private static final String cannotHaveLengthOffset = "RESTEASY003075: Cannot have length offset: %s";
protected String cannotHaveLengthOffset$str() {
return cannotHaveLengthOffset;
}
@Override
public final String cannotHaveLengthOffset(final int len) {
return String.format(getLoggingLocale(), cannotHaveLengthOffset$str(), len);
}
private static final String cannotHaveNegativeOffset = "RESTEASY003080: Cannot have negative offset: %s";
protected String cannotHaveNegativeOffset$str() {
return cannotHaveNegativeOffset;
}
@Override
public final String cannotHaveNegativeOffset(final int off) {
return String.format(getLoggingLocale(), cannotHaveNegativeOffset$str(), off);
}
private static final String cannotHaveOffset = "RESTEASY003085: Cannot have offset of {0} and length of {1} with array of length {2}";
protected String cannotHaveOffset$str() {
return cannotHaveOffset;
}
@Override
public final String cannotHaveOffset(final int off, final int len, final int srcLen) {
return _formatMessage(cannotHaveOffset$str(), off, len, srcLen);
}
private static final String cannotInjectAsynchronousResponse = "RESTEASY003090: You cannot inject AsynchronousResponse outside the scope of an HTTP request";
protected String cannotInjectAsynchronousResponse$str() {
return cannotInjectAsynchronousResponse;
}
@Override
public final String cannotInjectAsynchronousResponse() {
return String.format(getLoggingLocale(), cannotInjectAsynchronousResponse$str());
}
private static final String cannotInjectIntoForm = "RESTEASY003095: You cannot inject into a form outside the scope of an HTTP request";
protected String cannotInjectIntoForm$str() {
return cannotInjectIntoForm;
}
@Override
public final String cannotInjectIntoForm() {
return String.format(getLoggingLocale(), cannotInjectIntoForm$str());
}
private static final String cannotSendFormParametersAndEntity = "RESTEASY003100: You cannot send both form parameters and an entity body";
protected String cannotSendFormParametersAndEntity$str() {
return cannotSendFormParametersAndEntity;
}
@Override
public final String cannotSendFormParametersAndEntity() {
return String.format(getLoggingLocale(), cannotSendFormParametersAndEntity$str());
}
private static final String cannotSerializeNullArray = "RESTEASY003105: Cannot serialize a null array.";
protected String cannotSerializeNullArray$str() {
return cannotSerializeNullArray;
}
@Override
public final String cannotSerializeNullArray() {
return String.format(getLoggingLocale(), cannotSerializeNullArray$str());
}
private static final String cannotSerializeNullObject = "RESTEASY003110: Cannot serialize a null object.";
protected String cannotSerializeNullObject$str() {
return cannotSerializeNullObject;
}
@Override
public final String cannotSerializeNullObject() {
return String.format(getLoggingLocale(), cannotSerializeNullObject$str());
}
private static final String = "RESTEASY003115: You can only set one of LinkHeaderParam.rel() and LinkHeaderParam.title() for on {0}.{1}";
protected String () {
return canOnlySetLinkHeaderRelOrTitle;
}
@Override
public final String (final String className, final String methodName) {
return _formatMessage(canOnlySetLinkHeaderRelOrTitle$str(), className, methodName);
}
private static final String cantSetMethod = "RESTEASY003120: Can't set method after match";
protected String cantSetMethod$str() {
return cantSetMethod;
}
@Override
public final String cantSetMethod() {
return String.format(getLoggingLocale(), cantSetMethod$str());
}
private static final String cantSetURI = "RESTEASY003125: Can't set URI after match";
protected String cantSetURI$str() {
return cantSetURI;
}
@Override
public final String cantSetURI() {
return String.format(getLoggingLocale(), cantSetURI$str());
}
private static final String classIsNotRootResource = "RESTEASY003130: Class is not a root resource. It, or one of its interfaces must be annotated with @Path: %s implements: ";
protected String classIsNotRootResource$str() {
return classIsNotRootResource;
}
@Override
public final String classIsNotRootResource(final String className) {
return String.format(getLoggingLocale(), classIsNotRootResource$str(), className);
}
private static final String classMustBeAnnotatedWithPath = "RESTEASY003135: Class must be annotated with @Path to invoke path(Class)";
protected String classMustBeAnnotatedWithPath$str() {
return classMustBeAnnotatedWithPath;
}
@Override
public final String classMustBeAnnotatedWithPath() {
return String.format(getLoggingLocale(), classMustBeAnnotatedWithPath$str());
}
private static final String clientRequestDoesntSupportClonable = "RESTEASY003140: ClientRequest doesn't implement Clonable. Notify the RESTEasy staff right away.";
protected String clientRequestDoesntSupportClonable$str() {
return clientRequestDoesntSupportClonable;
}
@Override
public final String clientRequestDoesntSupportClonable() {
return String.format(getLoggingLocale(), clientRequestDoesntSupportClonable$str());
}
private static final String clientResponseFailureMediaType = "RESTEASY003145: Unable to find a MessageBodyReader of content-type {0} and type {1}";
protected String clientResponseFailureMediaType$str() {
return clientResponseFailureMediaType;
}
@Override
public final String clientResponseFailureMediaType(final MediaType mediaType, final java.lang.reflect.Type type) {
return _formatMessage(clientResponseFailureMediaType$str(), mediaType, type);
}
private static final String clientResponseFailureStatus = "RESTEASY003150: Error status {0} {1} returned";
protected String clientResponseFailureStatus$str() {
return clientResponseFailureStatus;
}
@Override
public final String clientResponseFailureStatus(final int status, final Status responseStatus) {
return _formatMessage(clientResponseFailureStatus$str(), status, responseStatus);
}
private static final String constructorMappingInvalid = "RESTEASY003155: Constructor arg paramMapping is invalid";
protected String constructorMappingInvalid$str() {
return constructorMappingInvalid;
}
@Override
public final String constructorMappingInvalid() {
return String.format(getLoggingLocale(), constructorMappingInvalid$str());
}
private static final String controlCharacterInCookieValue = "RESTEASY003160: Control character in cookie value, consider BASE64 encoding your value";
protected String controlCharacterInCookieValue$str() {
return controlCharacterInCookieValue;
}
@Override
public final String controlCharacterInCookieValue() {
return String.format(getLoggingLocale(), controlCharacterInCookieValue$str());
}
private static final String = "RESTEASY003165: Cookie header value was null";
protected String () {
return cookieHeaderValueNull;
}
@Override
public final String () {
return String.format(getLoggingLocale(), cookieHeaderValueNull$str());
}
private static final String couldNotCreateEntityFactory = "RESTEASY003170: Could not create a default entity type factory of type {0}";
protected String couldNotCreateEntityFactory$str() {
return couldNotCreateEntityFactory;
}
@Override
public final String couldNotCreateEntityFactory(final String className) {
return _formatMessage(couldNotCreateEntityFactory$str(), className);
}
private static final String couldNotCreateEntityFactoryMessage = "RESTEASY003175: Could not create a default entity type factory of type {0}. {1}";
protected String couldNotCreateEntityFactoryMessage$str() {
return couldNotCreateEntityFactoryMessage;
}
@Override
public final String couldNotCreateEntityFactoryMessage(final String className, final String message) {
return _formatMessage(couldNotCreateEntityFactoryMessage$str(), className, message);
}
private static final String couldNotCreateURI = "RESTEASY003180: Could not create a URI for {0} in {1}.{2}";
protected String couldNotCreateURI$str() {
return couldNotCreateURI;
}
@Override
public final String couldNotCreateURI(final String uri, final String className, final String methodName) {
return _formatMessage(couldNotCreateURI$str(), uri, className, methodName);
}
private static final String couldNotFindClassJndi = "RESTEASY003185: Could not find class %s provided to JNDI Component Resource";
protected String couldNotFindClassJndi$str() {
return couldNotFindClassJndi;
}
@Override
public final String couldNotFindClassJndi(final String className) {
return String.format(getLoggingLocale(), couldNotFindClassJndi$str(), className);
}
private static final String couldNotFindConstructor = "RESTEASY003190: Could not find constructor for class: %s";
protected String couldNotFindConstructor$str() {
return couldNotFindConstructor;
}
@Override
public final String couldNotFindConstructor(final String className) {
return String.format(getLoggingLocale(), couldNotFindConstructor$str(), className);
}
private static final String couldNotFindGetterForParam = "RESTEASY003195: URITemplateAnnotationResolver could not find a getter for param %s";
protected String couldNotFindGetterForParam$str() {
return couldNotFindGetterForParam;
}
@Override
public final String couldNotFindGetterForParam(final String param) {
return String.format(getLoggingLocale(), couldNotFindGetterForParam$str(), param);
}
private static final String couldNotFindMessageBodyReader = "RESTEASY003200: Could not find message body reader for type: {0} of content type: {1}";
protected String couldNotFindMessageBodyReader$str() {
return couldNotFindMessageBodyReader;
}
@Override
public final String couldNotFindMessageBodyReader(final java.lang.reflect.Type type, final MediaType mediaType) {
return _formatMessage(couldNotFindMessageBodyReader$str(), type, mediaType);
}
private static final String couldNotFindMethod = "RESTEASY003205: Could not find a method for: %s";
protected String couldNotFindMethod$str() {
return couldNotFindMethod;
}
@Override
public final String couldNotFindMethod(final Method method) {
return String.format(getLoggingLocale(), couldNotFindMethod$str(), method);
}
private static final String couldNotFindResourceForFullPath = "RESTEASY003210: Could not find resource for full path: %s";
protected String couldNotFindResourceForFullPath$str() {
return couldNotFindResourceForFullPath;
}
@Override
public final String couldNotFindResourceForFullPath(final URI uri) {
return String.format(getLoggingLocale(), couldNotFindResourceForFullPath$str(), uri);
}
private static final String couldNotFindWriterForContentType = "RESTEASY003215: could not find writer for content-type {0} type: {1}";
protected String couldNotFindWriterForContentType$str() {
return couldNotFindWriterForContentType;
}
@Override
public final String couldNotFindWriterForContentType(final MediaType mediaType, final String className) {
return _formatMessage(couldNotFindWriterForContentType$str(), mediaType, className);
}
private static final String couldNotGetAValue = "RESTEASY003220: URITemplateAnnotationResolver could not get a value for %s";
protected String couldNotGetAValue$str() {
return couldNotGetAValue;
}
@Override
public final String couldNotGetAValue(final String param) {
return String.format(getLoggingLocale(), couldNotGetAValue$str(), param);
}
private static final String couldNotIntrospectClass = "RESTEASY003225: URITemplateAnnotationResolver could not introspect class %s";
protected String couldNotIntrospectClass$str() {
return couldNotIntrospectClass;
}
@Override
public final String couldNotIntrospectClass(final String className) {
return String.format(getLoggingLocale(), couldNotIntrospectClass$str(), className);
}
private static final String couldNotMatchUpLoggerTypeImplementation = "RESTEASY003230: Could not match up an implementation for LoggerType: %s";
protected String couldNotMatchUpLoggerTypeImplementation$str() {
return couldNotMatchUpLoggerTypeImplementation;
}
@Override
public final String couldNotMatchUpLoggerTypeImplementation(final LoggerType loggerType) {
return String.format(getLoggingLocale(), couldNotMatchUpLoggerTypeImplementation$str(), loggerType);
}
private static final String couldNotProcessMethod = "RESTEASY003235: Could not process method %s";
protected String couldNotProcessMethod$str() {
return couldNotProcessMethod;
}
@Override
public final String couldNotProcessMethod(final Method method) {
return String.format(getLoggingLocale(), couldNotProcessMethod$str(), method);
}
private static final String couldNotReadType = "RESTEASY003240: Could not read type {0} for media type {1}";
protected String couldNotReadType$str() {
return couldNotReadType;
}
@Override
public final String couldNotReadType(final java.lang.reflect.Type type, final MediaType mediaType) {
return _formatMessage(couldNotReadType$str(), type, mediaType);
}
private static final String dateInstancesNotSupported = "RESTEASY003245: Date instances are not supported by this class.";
protected String dateInstancesNotSupported$str() {
return dateInstancesNotSupported;
}
@Override
public final String dateInstancesNotSupported() {
return String.format(getLoggingLocale(), dateInstancesNotSupported$str());
}
private static final String dateNull = "RESTEASY003250: date is null";
protected String dateNull$str() {
return dateNull;
}
@Override
public final String dateNull() {
return String.format(getLoggingLocale(), dateNull$str());
}
private static final String dataToEncodeNull = "RESTEASY003255: Data to encode was null.";
protected String dataToEncodeNull$str() {
return dataToEncodeNull;
}
@Override
public final String dataToEncodeNull() {
return String.format(getLoggingLocale(), dataToEncodeNull$str());
}
private static final String dateValueNull = "RESTEASY003260: dateValue is null";
protected String dateValueNull$str() {
return dateValueNull;
}
@Override
public final String dateValueNull() {
return String.format(getLoggingLocale(), dateValueNull$str());
}
private static final String destinationArrayCannotStoreThreeBytes = "RESTEASY003265: Destination array with length {0} cannot have offset of {1} and still store three bytes.";
protected String destinationArrayCannotStoreThreeBytes$str() {
return destinationArrayCannotStoreThreeBytes;
}
@Override
public final String destinationArrayCannotStoreThreeBytes(final int len, final int off) {
return _formatMessage(destinationArrayCannotStoreThreeBytes$str(), len, off);
}
private static final String destinationArrayNull = "RESTEASY003270: Destination array was null.";
protected String destinationArrayNull$str() {
return destinationArrayNull;
}
@Override
public final String destinationArrayNull() {
return String.format(getLoggingLocale(), destinationArrayNull$str());
}
private static final String = "RESTEASY003275: Empty field in: %s.";
protected String () {
return emptyFieldInHeader;
}
@Override
public final String (final String header) {
return String.format(getLoggingLocale(), emptyFieldInHeader$str(), header);
}
private static final String emptyHostName = "RESTEASY003280: empty host name";
protected String emptyHostName$str() {
return emptyHostName;
}
@Override
public final String emptyHostName() {
return String.format(getLoggingLocale(), emptyHostName$str());
}
private static final String entityAlreadyRead = "RESTEASY003285: The entity was already read, and it was of type %s";
protected String entityAlreadyRead$str() {
return entityAlreadyRead;
}
@Override
public final String entityAlreadyRead(final Class<?> clazz) {
return String.format(getLoggingLocale(), entityAlreadyRead$str(), clazz);
}
private static final String entityNotBackedByInputStream = "RESTEASY003290: Entity is not backed by an input stream";
protected String entityNotBackedByInputStream$str() {
return entityNotBackedByInputStream;
}
@Override
public final String entityNotBackedByInputStream() {
return String.format(getLoggingLocale(), entityNotBackedByInputStream$str());
}
private static final String entityNotOfUnderstoodType = "RESTEASY003295: The object you supplied to registerInterceptor is not of an understood type";
protected String entityNotOfUnderstoodType$str() {
return entityNotOfUnderstoodType;
}
@Override
public final String entityNotOfUnderstoodType() {
return String.format(getLoggingLocale(), entityNotOfUnderstoodType$str());
}
private static final String entityTagValueNull = "RESTEASY003300: value of EntityTag is null";
protected String entityTagValueNull$str() {
return entityTagValueNull;
}
@Override
public final String entityTagValueNull() {
return String.format(getLoggingLocale(), entityTagValueNull$str());
}
private static final String errorInBase64Stream = "RESTEASY003305: Error in Base64 code reading stream.";
protected String errorInBase64Stream$str() {
return errorInBase64Stream;
}
@Override
public final String errorInBase64Stream() {
return String.format(getLoggingLocale(), errorInBase64Stream$str());
}
private static final String eTagParamNull = "RESTEASY003310: eTag param null";
protected String eTagParamNull$str() {
return eTagParamNull;
}
@Override
public final String eTagParamNull() {
return String.format(getLoggingLocale(), eTagParamNull$str());
}
private static final String excededMaximumForwards = "RESTEASY003315: You have exceeded your maximum forwards ResteasyProviderFactory allows. Last good uri: %s";
protected String excededMaximumForwards$str() {
return excededMaximumForwards;
}
@Override
public final String excededMaximumForwards(final String uri) {
return String.format(getLoggingLocale(), excededMaximumForwards$str(), uri);
}
private static final String failedProcessingArguments = "RESTEASY003320: Failed processing arguments of %s";
protected String failedProcessingArguments$str() {
return failedProcessingArguments;
}
@Override
public final String failedProcessingArguments(final String constructor) {
return String.format(getLoggingLocale(), failedProcessingArguments$str(), constructor);
}
private static final String expectedExcapedCharacter = "RESTEASY003316: Expected '', '\n', or '\r', got %s";
protected String expectedExcapedCharacter$str() {
return expectedExcapedCharacter;
}
@Override
public final String expectedExcapedCharacter(final int n) {
return String.format(getLoggingLocale(), expectedExcapedCharacter$str(), n);
}
private static final String expectedStreamModeGeneralOrRaw = "RESTEASY003317: Expected Stream.MODE.GENERAL or Stream.MODE.RAW, got %s";
protected String expectedStreamModeGeneralOrRaw$str() {
return expectedStreamModeGeneralOrRaw;
}
@Override
public final String expectedStreamModeGeneralOrRaw(final MODE mode) {
return String.format(getLoggingLocale(), expectedStreamModeGeneralOrRaw$str(), mode);
}
private static final String = "RESTEASY003318: Expected @Stream or @Produces(\"text/event-stream\")";
protected String () {
return expectedStreamOrSseMediaType;
}
@Override
public final String () {
return String.format(getLoggingLocale(), expectedStreamOrSseMediaType$str());
}
private static final String expectedStringOrMediaType = "RESTEASY003319: Expected String or MediaType, got %s";
protected String expectedStringOrMediaType$str() {
return expectedStringOrMediaType;
}
@Override
public final String expectedStringOrMediaType(final Object o) {
return String.format(getLoggingLocale(), expectedStringOrMediaType$str(), o);
}
private static final String failedToConstruct = "RESTEASY003325: Failed to construct %s";
protected String failedToConstruct$str() {
return failedToConstruct;
}
@Override
public final String failedToConstruct(final String constructor) {
return String.format(getLoggingLocale(), failedToConstruct$str(), constructor);
}
private static final String failedToCreateUri = "RESTEASY003330: Failed to create URI: %s";
protected String failedToCreateUri$str() {
return failedToCreateUri;
}
@Override
public final String failedToCreateUri(final String buf) {
return String.format(getLoggingLocale(), failedToCreateUri$str(), buf);
}
private static final String failedToParseCookie = "RESTEASY003335: Failed to parse cookie string '%s'";
protected String failedToParseCookie$str() {
return failedToParseCookie;
}
@Override
public final String failedToParseCookie(final String value) {
return String.format(getLoggingLocale(), failedToParseCookie$str(), value);
}
private static final String failureParsingMediaType = "RESTEASY003340: Failure parsing MediaType string: %s";
protected String failureParsingMediaType$str() {
return failureParsingMediaType;
}
@Override
public final String failureParsingMediaType(final String type) {
return String.format(getLoggingLocale(), failureParsingMediaType$str(), type);
}
private static final String fileTooBig = "RESTEASY003345: File is too big for this convenience method (%s bytes).";
protected String fileTooBig$str() {
return fileTooBig;
}
@Override
public final String fileTooBig(final long len) {
return String.format(getLoggingLocale(), fileTooBig$str(), len);
}
private static final String garbageAfterQuotedString = "RESTEASY003350: Garbage after quoted string: %s";
protected String garbageAfterQuotedString$str() {
return garbageAfterQuotedString;
}
@Override
public final String garbageAfterQuotedString(final String header) {
return String.format(getLoggingLocale(), garbageAfterQuotedString$str(), header);
}
private static final String getRequestCannotHaveBody = "RESTEASY003355: A GET request cannot have a body.";
protected String getRequestCannotHaveBody$str() {
return getRequestCannotHaveBody;
}
@Override
public final String getRequestCannotHaveBody() {
return String.format(getLoggingLocale(), getRequestCannotHaveBody$str());
}
private static final String gzipExceedsMaxSize = "RESTEASY003357: GZIP input exceeds max size: %s";
protected String gzipExceedsMaxSize$str() {
return gzipExceedsMaxSize;
}
@Override
public final String gzipExceedsMaxSize(final int size) {
return String.format(getLoggingLocale(), gzipExceedsMaxSize$str(), size);
}
private static final String hasNoStringConstructor = "RESTEASY003360: %s has no String constructor";
protected String hasNoStringConstructor$str() {
return hasNoStringConstructor;
}
@Override
public final String hasNoStringConstructor(final String className) {
return String.format(getLoggingLocale(), hasNoStringConstructor$str(), className);
}
private static final String illegalHexadecimalCharacter = "RESTEASY003365: Illegal hexadecimal character {0} at index {1}";
protected String illegalHexadecimalCharacter$str() {
return illegalHexadecimalCharacter;
}
@Override
public final String illegalHexadecimalCharacter(final char ch, final int index) {
return _formatMessage(illegalHexadecimalCharacter$str(), ch, index);
}
private static final String illegalResponseMediaType = "RESTEASY003370: Illegal response media type: %s";
protected String illegalResponseMediaType$str() {
return illegalResponseMediaType;
}
@Override
public final String illegalResponseMediaType(final String mediaType) {
return String.format(getLoggingLocale(), illegalResponseMediaType$str(), mediaType);
}
private static final String illegalToInjectCookieParam = "RESTEASY003375: It is illegal to inject a @CookieParam into a singleton";
protected String illegalToInjectCookieParam$str() {
return illegalToInjectCookieParam;
}
@Override
public final String illegalToInjectCookieParam() {
return String.format(getLoggingLocale(), illegalToInjectCookieParam$str());
}
private static final String illegalToInjectFormParam = "RESTEASY003380: It is illegal to inject a @FormParam into a singleton";
protected String illegalToInjectFormParam$str() {
return illegalToInjectFormParam;
}
@Override
public final String illegalToInjectFormParam() {
return String.format(getLoggingLocale(), illegalToInjectFormParam$str());
}
private static final String = "RESTEASY003385: It is illegal to inject a @HeaderParam into a singleton";
protected String () {
return illegalToInjectHeaderParam;
}
@Override
public final String () {
return String.format(getLoggingLocale(), illegalToInjectHeaderParam$str());
}
private static final String illegalToInjectMatrixParam = "RESTEASY003390: It is illegal to inject a @MatrixParam into a singleton";
protected String illegalToInjectMatrixParam$str() {
return illegalToInjectMatrixParam;
}
@Override
public final String illegalToInjectMatrixParam() {
return String.format(getLoggingLocale(), illegalToInjectMatrixParam$str());
}
private static final String illegalToInjectMessageBody = "RESTEASY003395: Illegal to inject a message body into a singleton into %s";
protected String illegalToInjectMessageBody$str() {
return illegalToInjectMessageBody;
}
@Override
public final String illegalToInjectMessageBody(final AccessibleObject target) {
return String.format(getLoggingLocale(), illegalToInjectMessageBody$str(), target);
}
private static final String illegalToInjectNonInterfaceType = "RESTEASY003400: Illegal to inject a non-interface type into a singleton";
protected String illegalToInjectNonInterfaceType$str() {
return illegalToInjectNonInterfaceType;
}
@Override
public final String illegalToInjectNonInterfaceType() {
return String.format(getLoggingLocale(), illegalToInjectNonInterfaceType$str());
}
private static final String illegalToInjectPathParam = "RESTEASY003405: It is illegal to inject a @PathParam into a singleton";
protected String illegalToInjectPathParam$str() {
return illegalToInjectPathParam;
}
@Override
public final String illegalToInjectPathParam() {
return String.format(getLoggingLocale(), illegalToInjectPathParam$str());
}
private static final String illegalToInjectQueryParam = "RESTEASY003410: It is illegal to inject a @QueryParam into a singleton";
protected String illegalToInjectQueryParam$str() {
return illegalToInjectQueryParam;
}
@Override
public final String illegalToInjectQueryParam() {
return String.format(getLoggingLocale(), illegalToInjectQueryParam$str());
}
private static final String illegalUriTemplate = "RESTEASY003415: Illegal uri template: %s";
protected String illegalUriTemplate$str() {
return illegalUriTemplate;
}
@Override
public final String illegalUriTemplate(final String template) {
return String.format(getLoggingLocale(), illegalUriTemplate$str(), template);
}
private static final String improperlyPaddedBase64Input = "RESTEASY003420: Improperly padded Base64 input.";
protected String improperlyPaddedBase64Input$str() {
return improperlyPaddedBase64Input;
}
@Override
public final String improperlyPaddedBase64Input() {
return String.format(getLoggingLocale(), improperlyPaddedBase64Input$str());
}
private static final String incorrectTypeParameterClientExceptionMapper = "RESTEASY003425: Incorrect type parameter. ClientExceptionMapper requires a subclass of java.lang.Throwable as its type parameter.";
protected String incorrectTypeParameterClientExceptionMapper$str() {
return incorrectTypeParameterClientExceptionMapper;
}
@Override
public final String incorrectTypeParameterClientExceptionMapper() {
return String.format(getLoggingLocale(), incorrectTypeParameterClientExceptionMapper$str());
}
private static final String incorrectTypeParameterExceptionMapper = "RESTEASY003430: Incorrect type parameter. ExceptionMapper requires a subclass of java.lang.Throwable as its type parameter.";
protected String incorrectTypeParameterExceptionMapper$str() {
return incorrectTypeParameterExceptionMapper;
}
@Override
public final String incorrectTypeParameterExceptionMapper() {
return String.format(getLoggingLocale(), incorrectTypeParameterExceptionMapper$str());
}
private static final String inputStreamEmpty = "RESTEASY003435: Input stream was empty, there is no entity";
protected String inputStreamEmpty$str() {
return inputStreamEmpty;
}
@Override
public final String inputStreamEmpty() {
return String.format(getLoggingLocale(), inputStreamEmpty$str());
}
private static final String inputStringNull = "RESTEASY003440: Input string was null.";
protected String inputStringNull$str() {
return inputStringNull;
}
@Override
public final String inputStringNull() {
return String.format(getLoggingLocale(), inputStringNull$str());
}
private static final String interceptorClassMustBeAnnotated = "RESTEASY003445: Interceptor class must be annotated with @ServerInterceptor and/or @ClientInterceptor";
protected String interceptorClassMustBeAnnotated$str() {
return interceptorClassMustBeAnnotated;
}
@Override
public final String interceptorClassMustBeAnnotated() {
return String.format(getLoggingLocale(), interceptorClassMustBeAnnotated$str());
}
private static final String interceptorClassMustBeAnnotatedWithClass = "RESTEASY003450: Interceptor class %s must be annotated with @ServerInterceptor and/or @ClientInterceptor";
protected String interceptorClassMustBeAnnotatedWithClass$str() {
return interceptorClassMustBeAnnotatedWithClass;
}
@Override
public final String interceptorClassMustBeAnnotatedWithClass(final Class<?> clazz) {
return String.format(getLoggingLocale(), interceptorClassMustBeAnnotatedWithClass$str(), clazz);
}
private static final String interceptorNullFromClass = "RESTEASY003455: interceptor null from class: %s";
protected String interceptorNullFromClass$str() {
return interceptorNullFromClass;
}
@Override
public final String interceptorNullFromClass(final String className) {
return String.format(getLoggingLocale(), interceptorNullFromClass$str(), className);
}
private static final String invalidCharacterInBase64Data = "RESTEASY003460: Invalid character in Base64 data.";
protected String invalidCharacterInBase64Data$str() {
return invalidCharacterInBase64Data;
}
@Override
public final String invalidCharacterInBase64Data() {
return String.format(getLoggingLocale(), invalidCharacterInBase64Data$str());
}
private static final String invalidEscapeCharacterInCookieValue = "RESTEASY003465: Invalid escape character in cookie value.";
protected String invalidEscapeCharacterInCookieValue$str() {
return invalidEscapeCharacterInCookieValue;
}
@Override
public final String invalidEscapeCharacterInCookieValue() {
return String.format(getLoggingLocale(), invalidEscapeCharacterInCookieValue$str());
}
private static final String invalidHost = "RESTEASY003470: invalid host";
protected String invalidHost$str() {
return invalidHost;
}
@Override
public final String invalidHost() {
return String.format(getLoggingLocale(), invalidHost$str());
}
private static final String invalidPort = "RESTEASY003475: Invalid port value";
protected String invalidPort$str() {
return invalidPort;
}
@Override
public final String invalidPort() {
return String.format(getLoggingLocale(), invalidPort$str());
}
private static final String isNotInitialRequest = "RESTEASY003480: %s is not initial request. Its suspended and retried. Aborting.";
protected String isNotInitialRequest$str() {
return isNotInitialRequest;
}
@Override
public final String isNotInitialRequest(final String path) {
return String.format(getLoggingLocale(), isNotInitialRequest$str(), path);
}
private static final String jndiComponentResourceNotSetCorrectly = "RESTEASY003485: JNDI Component Resource variable is not set correctly: jndi;class;true|false comma delimited";
protected String jndiComponentResourceNotSetCorrectly$str() {
return jndiComponentResourceNotSetCorrectly;
}
@Override
public final String jndiComponentResourceNotSetCorrectly() {
return String.format(getLoggingLocale(), jndiComponentResourceNotSetCorrectly$str());
}
private static final String keyCouldNotBeParsed = "RESTEASY003490: The %s config in web.xml could not be parsed, accepted values are true,false or 1,0";
protected String keyCouldNotBeParsed$str() {
return keyCouldNotBeParsed;
}
@Override
public final String keyCouldNotBeParsed(final String key) {
return String.format(getLoggingLocale(), keyCouldNotBeParsed$str(), key);
}
private static final String lastModifiedParamNull = "RESTEASY003495: lastModified param null";
protected String lastModifiedParamNull$str() {
return lastModifiedParamNull;
}
@Override
public final String lastModifiedParamNull() {
return String.format(getLoggingLocale(), lastModifiedParamNull$str());
}
private static final String localeValueNull = "RESTEASY003500: Locale value is null";
protected String localeValueNull$str() {
return localeValueNull;
}
@Override
public final String localeValueNull() {
return String.format(getLoggingLocale(), localeValueNull$str());
}
private static final String malformedMediaType = "RESTEASY003505: Malformed media type: %s";
protected String malformedMediaType$str() {
return malformedMediaType;
}
@Override
public final String malformedMediaType(final String header) {
return String.format(getLoggingLocale(), malformedMediaType$str(), header);
}
private static final String malformedParameter = "RESTEASY003510: Malformed parameter: %s";
protected String malformedParameter$str() {
return malformedParameter;
}
@Override
public final String malformedParameter(final String parameter) {
return String.format(getLoggingLocale(), malformedParameter$str(), parameter);
}
private static final String malformedParameters = "RESTEASY003515: Malformed parameters: %s.";
protected String malformedParameters$str() {
return malformedParameters;
}
@Override
public final String malformedParameters(final String header) {
return String.format(getLoggingLocale(), malformedParameters$str(), header);
}
private static final String malformedQualityValue = "RESTEASY003520: Malformed quality value.";
protected String malformedQualityValue$str() {
return malformedQualityValue;
}
@Override
public final String malformedQualityValue() {
return String.format(getLoggingLocale(), malformedQualityValue$str());
}
private static final String mapKeyNull = "RESTEASY003525: map key is null";
protected String mapKeyNull$str() {
return mapKeyNull;
}
@Override
public final String mapKeyNull() {
return String.format(getLoggingLocale(), mapKeyNull$str());
}
private static final String mapValueNull = "RESTEASY003530: map value is null";
protected String mapValueNull$str() {
return mapValueNull;
}
@Override
public final String mapValueNull() {
return String.format(getLoggingLocale(), mapValueNull$str());
}
private static final String marshalledEntityMustHaveTypeInfo = "RESTEASY003535: MarshalledEntity must have type information.";
protected String marshalledEntityMustHaveTypeInfo$str() {
return marshalledEntityMustHaveTypeInfo;
}
@Override
public final String marshalledEntityMustHaveTypeInfo() {
return String.format(getLoggingLocale(), marshalledEntityMustHaveTypeInfo$str());
}
private static final String mediaTypeQGreaterThan1 = "RESTEASY003540: MediaType q value cannot be greater than 1.0: %s";
protected String mediaTypeQGreaterThan1$str() {
return mediaTypeQGreaterThan1;
}
@Override
public final String mediaTypeQGreaterThan1(final String mediaType) {
return String.format(getLoggingLocale(), mediaTypeQGreaterThan1$str(), mediaType);
}
private static final String mediaTypeQMustBeFloat = "RESTEASY003545: MediaType q parameter must be a float: %s";
protected String mediaTypeQMustBeFloat$str() {
return mediaTypeQMustBeFloat;
}
@Override
public final String mediaTypeQMustBeFloat(final MediaType mediaType) {
return String.format(getLoggingLocale(), mediaTypeQMustBeFloat$str(), mediaType);
}
private static final String mediaTypeQWeightedLanguageMustBeFloat = "RESTEASY003550: MediaType q parameter must be a float: %s";
protected String mediaTypeQWeightedLanguageMustBeFloat$str() {
return mediaTypeQWeightedLanguageMustBeFloat;
}
@Override
public final String mediaTypeQWeightedLanguageMustBeFloat(final WeightedLanguage lang) {
return String.format(getLoggingLocale(), mediaTypeQWeightedLanguageMustBeFloat$str(), lang);
}
private static final String mediaTypeValueNull = "RESTEASY003555: MediaType value is null";
protected String mediaTypeValueNull$str() {
return mediaTypeValueNull;
}
@Override
public final String mediaTypeValueNull() {
return String.format(getLoggingLocale(), mediaTypeValueNull$str());
}
private static final String methodNotAnnotatedWithPath = "RESTEASY003560: method is not annotated with @Path";
protected String methodNotAnnotatedWithPath$str() {
return methodNotAnnotatedWithPath;
}
@Override
public final String methodNotAnnotatedWithPath() {
return String.format(getLoggingLocale(), methodNotAnnotatedWithPath$str());
}
private static final String methodNull = "RESTEASY003565: method was null";
protected String methodNull$str() {
return methodNull;
}
@Override
public final String methodNull() {
return String.format(getLoggingLocale(), methodNull$str());
}
private static final String missingTypeParameter = "RESTEASY003570: Missing type parameter.";
protected String missingTypeParameter$str() {
return missingTypeParameter;
}
@Override
public final String missingTypeParameter() {
return String.format(getLoggingLocale(), missingTypeParameter$str());
}
private static final String mustDefineConsumes = "RESTEASY003575: You must define a @Consumes type on your client method or interface, or supply a default";
protected String mustDefineConsumes$str() {
return mustDefineConsumes;
}
@Override
public final String mustDefineConsumes() {
return String.format(getLoggingLocale(), mustDefineConsumes$str());
}
private static final String = "RESTEASY003580: You must set either LinkHeaderParam.rel() or LinkHeaderParam.title() for on {0}.{1}";
protected String () {
return mustSetLinkHeaderRelOrTitle;
}
@Override
public final String (final String className, final String methodName) {
return _formatMessage(mustSetLinkHeaderRelOrTitle$str(), className, methodName);
}
private static final String = "RESTEASY003585: You must set either the port or ssl port, not both";
protected String () {
return mustSetEitherPortOrSSLPort;
}
@Override
public final String () {
return String.format(getLoggingLocale(), mustSetEitherPortOrSSLPort$str());
}
private static final String mustSetPort = "RESTEASY003590: You must set the port or ssl port";
protected String mustSetPort$str() {
return mustSetPort;
}
@Override
public final String mustSetPort() {
return String.format(getLoggingLocale(), mustSetPort$str());
}
private static final String mustUseOneHttpMethod = "RESTEASY003595: You must use at least one, but no more than one http method annotation on: %s";
protected String mustUseOneHttpMethod$str() {
return mustUseOneHttpMethod;
}
@Override
public final String mustUseOneHttpMethod(final String methodName) {
return String.format(getLoggingLocale(), mustUseOneHttpMethod$str(), methodName);
}
private static final String nameParameterNull = "RESTEASY003600: name parameter is null";
protected String nameParameterNull$str() {
return nameParameterNull;
}
@Override
public final String nameParameterNull() {
return String.format(getLoggingLocale(), nameParameterNull$str());
}
private static final String nameParamIsNull = "RESTEASY003605: name param is null";
protected String nameParamIsNull$str() {
return nameParamIsNull;
}
@Override
public final String nameParamIsNull() {
return String.format(getLoggingLocale(), nameParamIsNull$str());
}
private static final String nameParamWasNull = "RESTEASY003610: name param was null";
protected String nameParamWasNull$str() {
return nameParamWasNull;
}
@Override
public final String nameParamWasNull() {
return String.format(getLoggingLocale(), nameParamWasNull$str());
}
private static final String newCookieValueNull = "RESTEASY003615: NewCookie value is null";
protected String newCookieValueNull$str() {
return newCookieValueNull;
}
@Override
public final String newCookieValueNull() {
return String.format(getLoggingLocale(), newCookieValueNull$str());
}
private static final String noContent = "RESTEASY003620: No content";
protected String noContent$str() {
return noContent;
}
@Override
public final String noContent() {
return String.format(getLoggingLocale(), noContent$str());
}
private static final String noContentContentLength0 = "RESTEASY003625: No content. Content-Length is 0";
protected String noContentContentLength0$str() {
return noContentContentLength0;
}
@Override
public final String noContentContentLength0() {
return String.format(getLoggingLocale(), noContentContentLength0$str());
}
private static final String noLongerASupportedContextParam = "RESTEASY003630: %s is no longer a supported context param. See documentation for more details";
protected String noLongerASupportedContextParam$str() {
return noLongerASupportedContextParam;
}
@Override
public final String noLongerASupportedContextParam(final String paramName) {
return String.format(getLoggingLocale(), noLongerASupportedContextParam$str(), paramName);
}
private static final String = "RESTEASY003635: No match for accept header";
protected String () {
return noMatchForAcceptHeader;
}
@Override
public final String () {
return String.format(getLoggingLocale(), noMatchForAcceptHeader$str());
}
private static final String noOutputStreamAllowed = "RESTEASY003640: No output stream allowed";
protected String noOutputStreamAllowed$str() {
return noOutputStreamAllowed;
}
@Override
public final String noOutputStreamAllowed() {
return String.format(getLoggingLocale(), noOutputStreamAllowed$str());
}
private static final String noPublicPathAnnotatedMethod = "RESTEASY003645: No public @Path annotated method for {0}.{1}";
protected String noPublicPathAnnotatedMethod$str() {
return noPublicPathAnnotatedMethod;
}
@Override
public final String noPublicPathAnnotatedMethod(final String resource, final String method) {
return _formatMessage(noPublicPathAnnotatedMethod$str(), resource, method);
}
private static final String noResourceMethodFoundForHttpMethod = "RESTEASY003650: No resource method found for %s, return 405 with Allow header";
protected String noResourceMethodFoundForHttpMethod$str() {
return noResourceMethodFoundForHttpMethod;
}
@Override
public final String noResourceMethodFoundForHttpMethod(final String httpMethod) {
return String.format(getLoggingLocale(), noResourceMethodFoundForHttpMethod$str(), httpMethod);
}
private static final String noResourceMethodFoundForOptions = "RESTEASY003655: No resource method found for options, return OK with Allow header";
protected String noResourceMethodFoundForOptions$str() {
return noResourceMethodFoundForOptions;
}
@Override
public final String noResourceMethodFoundForOptions() {
return String.format(getLoggingLocale(), noResourceMethodFoundForOptions$str());
}
private static final String noTypeInformationForEntity = "RESTEASY003660: No type information to extract entity with, use other getEntity() methods";
protected String noTypeInformationForEntity$str() {
return noTypeInformationForEntity;
}
@Override
public final String noTypeInformationForEntity() {
return String.format(getLoggingLocale(), noTypeInformationForEntity$str());
}
private static final String notAllowedToReflectOnMethod = "RESTEASY003665: Not allowed to reflect on method: %s";
protected String notAllowedToReflectOnMethod$str() {
return notAllowedToReflectOnMethod;
}
@Override
public final String notAllowedToReflectOnMethod(final String methodName) {
return String.format(getLoggingLocale(), notAllowedToReflectOnMethod$str(), methodName);
}
private static final String notEnoughPathParameters = "RESTEASY003670: You did not supply enough values to fill path parameters";
protected String notEnoughPathParameters$str() {
return notEnoughPathParameters;
}
@Override
public final String notEnoughPathParameters() {
return String.format(getLoggingLocale(), notEnoughPathParameters$str());
}
private static final String notValidInjectableType = "RESTEASY003675: %s is not a valid injectable type for @Suspend";
protected String notValidInjectableType$str() {
return notValidInjectableType;
}
@Override
public final String notValidInjectableType(final String typeName) {
return String.format(getLoggingLocale(), notValidInjectableType$str(), typeName);
}
private static final String nullSubresource = "RESTEASY003680: Null subresource for path: %s.";
protected String nullSubresource$str() {
return nullSubresource;
}
@Override
public final String nullSubresource(final URI uri) {
return String.format(getLoggingLocale(), nullSubresource$str(), uri);
}
private static final String nullValue = "RESTEASY003685: null value";
protected String nullValue$str() {
return nullValue;
}
@Override
public final String nullValue() {
return String.format(getLoggingLocale(), nullValue$str());
}
private static final String numberOfMatchedSegments = "RESTEASY003690: Number of matched segments greater than actual";
protected String numberOfMatchedSegments$str() {
return numberOfMatchedSegments;
}
@Override
public final String numberOfMatchedSegments() {
return String.format(getLoggingLocale(), numberOfMatchedSegments$str());
}
private static final String oddNumberOfCharacters = "RESTEASY003695: Odd number of characters.";
protected String oddNumberOfCharacters$str() {
return oddNumberOfCharacters;
}
@Override
public final String oddNumberOfCharacters() {
return String.format(getLoggingLocale(), oddNumberOfCharacters$str());
}
private static final String originNotAllowed = "RESTEASY003700: Origin not allowed: %s";
protected String originNotAllowed$str() {
return originNotAllowed;
}
@Override
public final String originNotAllowed(final String origin) {
return String.format(getLoggingLocale(), originNotAllowed$str(), origin);
}
private static final String paramNull = "RESTEASY003705: param was null";
protected String paramNull$str() {
return paramNull;
}
@Override
public final String paramNull() {
return String.format(getLoggingLocale(), paramNull$str());
}
private static final String passedInValueNull = "RESTEASY003710: A passed in value was null";
protected String passedInValueNull$str() {
return passedInValueNull;
}
@Override
public final String passedInValueNull() {
return String.format(getLoggingLocale(), passedInValueNull$str());
}
private static final String pathNull = "RESTEASY003715: path was null";
protected String pathNull$str() {
return pathNull;
}
@Override
public final String pathNull() {
return String.format(getLoggingLocale(), pathNull$str());
}
private static final String pathParameterNotProvided = "RESTEASY003720: path param %s has not been provided by the parameter map";
protected String pathParameterNotProvided$str() {
return pathParameterNotProvided;
}
@Override
public final String pathParameterNotProvided(final String param) {
return String.format(getLoggingLocale(), pathParameterNotProvided$str(), param);
}
private static final String patternNull = "RESTEASY003725: pattern is null";
protected String patternNull$str() {
return patternNull;
}
@Override
public final String patternNull() {
return String.format(getLoggingLocale(), patternNull$str());
}
private static final String qValueCannotBeGreaterThan1 = "RESTEASY003730: Accept-Language q value cannot be greater than 1.0 %s";
protected String qValueCannotBeGreaterThan1$str() {
return qValueCannotBeGreaterThan1;
}
@Override
public final String qValueCannotBeGreaterThan1(final String lang) {
return String.format(getLoggingLocale(), qValueCannotBeGreaterThan1$str(), lang);
}
private static final String quotedStringIsNotClosed = "RESTEASY003735: Quoted string is not closed: %s";
protected String quotedStringIsNotClosed$str() {
return quotedStringIsNotClosed;
}
@Override
public final String quotedStringIsNotClosed(final String header) {
return String.format(getLoggingLocale(), quotedStringIsNotClosed$str(), header);
}
private static final String relParamNull = "RESTEASY003740: rel param was null";
protected String relParamNull$str() {
return relParamNull;
}
@Override
public final String relParamNull() {
return String.format(getLoggingLocale(), relParamNull$str());
}
private static final String = "RESTEASY003745: Removing a header is illegal for an HttpServletResponse";
protected String () {
return removingHeaderIllegal;
}
@Override
public final String () {
return String.format(getLoggingLocale(), removingHeaderIllegal$str());
}
private static final String requestMediaTypeNotUrlencoded = "RESTEASY003750: Request media type is not application/x-www-form-urlencoded";
protected String requestMediaTypeNotUrlencoded$str() {
return requestMediaTypeNotUrlencoded;
}
@Override
public final String requestMediaTypeNotUrlencoded() {
return String.format(getLoggingLocale(), requestMediaTypeNotUrlencoded$str());
}
private static final String requestWasAlreadyExecuted = "RESTEASY003755: Request was already executed";
protected String requestWasAlreadyExecuted$str() {
return requestWasAlreadyExecuted;
}
@Override
public final String requestWasAlreadyExecuted() {
return String.format(getLoggingLocale(), requestWasAlreadyExecuted$str());
}
private static final String resourceNull = "RESTEASY003760: resource was null";
protected String resourceNull$str() {
return resourceNull;
}
@Override
public final String resourceNull() {
return String.format(getLoggingLocale(), resourceNull$str());
}
private static final String responseIsClosed = "RESTEASY003765: Response is closed.";
protected String responseIsClosed$str() {
return responseIsClosed;
}
@Override
public final String responseIsClosed() {
return String.format(getLoggingLocale(), responseIsClosed$str());
}
private static final String responseIsCommitted = "RESTEASY003770: Response is committed, can't handle exception";
protected String responseIsCommitted$str() {
return responseIsCommitted;
}
@Override
public final String responseIsCommitted() {
return String.format(getLoggingLocale(), responseIsCommitted$str());
}
private static final String schemeSpecificPartNull = "RESTEASY003775: schemeSpecificPart was null";
protected String schemeSpecificPartNull$str() {
return schemeSpecificPartNull;
}
@Override
public final String schemeSpecificPartNull() {
return String.format(getLoggingLocale(), schemeSpecificPartNull$str());
}
private static final String segmentNull = "RESTEASY003780: A segment is null";
protected String segmentNull$str() {
return segmentNull;
}
@Override
public final String segmentNull() {
return String.format(getLoggingLocale(), segmentNull$str());
}
private static final String segmentsParameterNull = "RESTEASY003785: segments parameter was null";
protected String segmentsParameterNull$str() {
return segmentsParameterNull;
}
@Override
public final String segmentsParameterNull() {
return String.format(getLoggingLocale(), segmentsParameterNull$str());
}
private static final String shouldBeUnreachable = "RESTEASY003790: Should be unreachable";
protected String shouldBeUnreachable$str() {
return shouldBeUnreachable;
}
@Override
public final String shouldBeUnreachable() {
return String.format(getLoggingLocale(), shouldBeUnreachable$str());
}
private static final String sourceArrayCannotProcessBytes = "RESTEASY003795: Source array with length {0} cannot have offset of {1} and process {2} bytes.";
protected String sourceArrayCannotProcessBytes$str() {
return sourceArrayCannotProcessBytes;
}
@Override
public final String sourceArrayCannotProcessBytes(final int srcLen, final int off, final int len) {
return _formatMessage(sourceArrayCannotProcessBytes$str(), srcLen, off, len);
}
private static final String sourceArrayCannotProcessFourBytes = "RESTEASY003800: Source array with length {0} cannot have offset of {1} and still process four bytes.";
protected String sourceArrayCannotProcessFourBytes$str() {
return sourceArrayCannotProcessFourBytes;
}
@Override
public final String sourceArrayCannotProcessFourBytes(final int srcLen, final int off) {
return _formatMessage(sourceArrayCannotProcessFourBytes$str(), srcLen, off);
}
private static final String sourceArrayNull = "RESTEASY003805: Source array was null.";
protected String sourceArrayNull$str() {
return sourceArrayNull;
}
@Override
public final String sourceArrayNull() {
return String.format(getLoggingLocale(), sourceArrayNull$str());
}
private static final String streamWrappedBySignature = "RESTEASY003810: Stream wrapped by Signature, cannot reset the stream without destroying signature";
protected String streamWrappedBySignature$str() {
return streamWrappedBySignature;
}
@Override
public final String streamWrappedBySignature() {
return String.format(getLoggingLocale(), streamWrappedBySignature$str());
}
private static final String subresourceHasNoJaxRsAnnotations = "RESTEASY003815: Subresource for target class has no jax-rs annotations.: %s";
protected String subresourceHasNoJaxRsAnnotations$str() {
return subresourceHasNoJaxRsAnnotations;
}
@Override
public final String subresourceHasNoJaxRsAnnotations(final String className) {
return String.format(getLoggingLocale(), subresourceHasNoJaxRsAnnotations$str(), className);
}
private static final String tClassParameterNull = "RESTEASY003820: tClass parameter is null";
protected String tClassParameterNull$str() {
return tClassParameterNull;
}
@Override
public final String tClassParameterNull() {
return String.format(getLoggingLocale(), tClassParameterNull$str());
}
private static final String tailingGarbage = "RESTEASY003825: Tailing garbage: %s";
protected String tailingGarbage$str() {
return tailingGarbage;
}
@Override
public final String tailingGarbage(final String header) {
return String.format(getLoggingLocale(), tailingGarbage$str(), header);
}
private static final String templateParameterNull = "RESTEASY003830: NULL value for template parameter: %s";
protected String templateParameterNull$str() {
return templateParameterNull;
}
@Override
public final String templateParameterNull(final String param) {
return String.format(getLoggingLocale(), templateParameterNull$str(), param);
}
private static final String templateValuesParamNull = "RESTEASY003835: templateValues param null";
protected String templateValuesParamNull$str() {
return templateValuesParamNull;
}
@Override
public final String templateValuesParamNull() {
return String.format(getLoggingLocale(), templateValuesParamNull$str());
}
private static final String titleParamNull = "RESTEASY003840: title param was null";
protected String titleParamNull$str() {
return titleParamNull;
}
@Override
public final String titleParamNull() {
return String.format(getLoggingLocale(), titleParamNull$str());
}
private static final String twoMethodsSameName = "RESTEASY003845: there are two method named %s";
protected String twoMethodsSameName$str() {
return twoMethodsSameName;
}
@Override
public final String twoMethodsSameName(final String method) {
return String.format(getLoggingLocale(), twoMethodsSameName$str(), method);
}
private static final String typeParamNull = "RESTEASY003850: type param was null";
protected String typeParamNull$str() {
return typeParamNull;
}
@Override
public final String typeParamNull() {
return String.format(getLoggingLocale(), typeParamNull$str());
}
private static final String unableToCreateURI = "RESTEASY003855: Unable to create URI: %s";
protected String unableToCreateURI$str() {
return unableToCreateURI;
}
@Override
public final String unableToCreateURI(final String buf) {
return String.format(getLoggingLocale(), unableToCreateURI$str(), buf);
}
private static final String unableToDecodeQueryString = "RESTEASY003860: Unable to decode query string";
protected String unableToDecodeQueryString$str() {
return unableToDecodeQueryString;
}
@Override
public final String unableToDecodeQueryString() {
return String.format(getLoggingLocale(), unableToDecodeQueryString$str());
}
private static final String unableToDetermineBaseClass = "RESTEASY003865: Unable to determine base class from Type";
protected String unableToDetermineBaseClass$str() {
return unableToDetermineBaseClass;
}
@Override
public final String unableToDetermineBaseClass() {
return String.format(getLoggingLocale(), unableToDetermineBaseClass$str());
}
private static final String = "RESTEASY003870: Unable to extract parameter from http request: {0} value is '{1}' for {2}";
protected String () {
return unableToExtractParameter;
}
@Override
public final String (final String paramSignature, final String strVal, final AccessibleObject target) {
return _formatMessage(unableToExtractParameter$str(), paramSignature, strVal, target);
}
private static final String unableToFindConstructor = "RESTEASY003875: Unable to find a constructor that takes a String param or a valueOf() or fromString() method for {0} on {1} for basetype: {2}";
protected String unableToFindConstructor$str() {
return unableToFindConstructor;
}
@Override
public final String unableToFindConstructor(final String paramSignature, final AccessibleObject target, final String className) {
return _formatMessage(unableToFindConstructor$str(), paramSignature, target, className);
}
private static final String unableToFindContextualData = "RESTEASY003880: Unable to find contextual data of type: %s";
protected String unableToFindContextualData$str() {
return unableToFindContextualData;
}
@Override
public final String unableToFindContextualData(final String className) {
return String.format(getLoggingLocale(), unableToFindContextualData$str(), className);
}
private static final String unableToFindInjectorFactory = "RESTEASY003885: Unable to find InjectorFactory implementation.";
protected String unableToFindInjectorFactory$str() {
return unableToFindInjectorFactory;
}
@Override
public final String unableToFindInjectorFactory() {
return String.format(getLoggingLocale(), unableToFindInjectorFactory$str());
}
private static final String unableToFindJaxRsResource = "RESTEASY003890: Unable to find JAX-RS resource associated with path: %s.";
protected String unableToFindJaxRsResource$str() {
return unableToFindJaxRsResource;
}
@Override
public final String unableToFindJaxRsResource(final String path) {
return String.format(getLoggingLocale(), unableToFindJaxRsResource$str(), path);
}
private static final String unableToFindPublicConstructorForClass = "RESTEASY003895: Unable to find a public constructor for class %s";
protected String unableToFindPublicConstructorForClass$str() {
return unableToFindPublicConstructorForClass;
}
@Override
public final String unableToFindPublicConstructorForClass(final String className) {
return String.format(getLoggingLocale(), unableToFindPublicConstructorForClass$str(), className);
}
private static final String unableToFindPublicConstructorForProvider = "RESTEASY003900: Unable to find a public constructor for provider class %s";
protected String unableToFindPublicConstructorForProvider$str() {
return unableToFindPublicConstructorForProvider;
}
@Override
public final String unableToFindPublicConstructorForProvider(final String className) {
return String.format(getLoggingLocale(), unableToFindPublicConstructorForProvider$str(), className);
}
private static final String unableToFindTypeArguments = "RESTEASY003905: Unable to find type arguments of %s";
protected String unableToFindTypeArguments$str() {
return unableToFindTypeArguments;
}
@Override
public final String unableToFindTypeArguments(final Class<?> clazz) {
return String.format(getLoggingLocale(), unableToFindTypeArguments$str(), clazz);
}
private static final String unableToInstantiateClientExceptionMapper = "RESTEASY003910: Unable to instantiate ClientExceptionMapper";
protected String unableToInstantiateClientExceptionMapper$str() {
return unableToInstantiateClientExceptionMapper;
}
@Override
public final String unableToInstantiateClientExceptionMapper() {
return String.format(getLoggingLocale(), unableToInstantiateClientExceptionMapper$str());
}
private static final String unableToInstantiateContextObject = "RESTEASY003915: Unable to instantiate context object %s";
protected String unableToInstantiateContextObject$str() {
return unableToInstantiateContextObject;
}
@Override
public final String unableToInstantiateContextObject(final String key) {
return String.format(getLoggingLocale(), unableToInstantiateContextObject$str(), key);
}
private static final String unableToInstantiateContextResolver = "RESTEASY003920: Unable to instantiate ContextResolver";
protected String unableToInstantiateContextResolver$str() {
return unableToInstantiateContextResolver;
}
@Override
public final String unableToInstantiateContextResolver() {
return String.format(getLoggingLocale(), unableToInstantiateContextResolver$str());
}
private static final String unableToInstantiateExceptionMapper = "RESTEASY003925: Unable to instantiate ExceptionMapper";
protected String unableToInstantiateExceptionMapper$str() {
return unableToInstantiateExceptionMapper;
}
@Override
public final String unableToInstantiateExceptionMapper() {
return String.format(getLoggingLocale(), unableToInstantiateExceptionMapper$str());
}
private static final String unableToInstantiateForm = "RESTEASY003930: Unable to instantiate @Form class. No no-arg constructor.";
protected String unableToInstantiateForm$str() {
return unableToInstantiateForm;
}
@Override
public final String unableToInstantiateForm() {
return String.format(getLoggingLocale(), unableToInstantiateForm$str());
}
private static final String unableToInstantiateInjectorFactory = "RESTEASY003935: Unable to instantiate InjectorFactory implementation.";
protected String unableToInstantiateInjectorFactory$str() {
return unableToInstantiateInjectorFactory;
}
@Override
public final String unableToInstantiateInjectorFactory() {
return String.format(getLoggingLocale(), unableToInstantiateInjectorFactory$str());
}
private static final String unableToInstantiateMessageBodyReader = "RESTEASY003940: Unable to instantiate MessageBodyReader";
protected String unableToInstantiateMessageBodyReader$str() {
return unableToInstantiateMessageBodyReader;
}
@Override
public final String unableToInstantiateMessageBodyReader() {
return String.format(getLoggingLocale(), unableToInstantiateMessageBodyReader$str());
}
private static final String unableToInstantiateMessageBodyWriter = "RESTEASY003945: Unable to instantiate MessageBodyWriter";
protected String unableToInstantiateMessageBodyWriter$str() {
return unableToInstantiateMessageBodyWriter;
}
@Override
public final String unableToInstantiateMessageBodyWriter() {
return String.format(getLoggingLocale(), unableToInstantiateMessageBodyWriter$str());
}
private static final String unableToParseDate = "RESTEASY003950: Unable to parse the date %s";
protected String unableToParseDate$str() {
return unableToParseDate;
}
@Override
public final String unableToParseDate(final String dateValue) {
return String.format(getLoggingLocale(), unableToParseDate$str(), dateValue);
}
private static final String = "RESTEASY003955: Unable to parse Link header. No end to link: %s";
protected String () {
return unableToParseLinkHeaderNoEndToLink;
}
@Override
public final String (final String value) {
return String.format(getLoggingLocale(), unableToParseLinkHeaderNoEndToLink$str(), value);
}
private static final String = "RESTEASY003960: Unable to parse Link header. No end to parameter: %s";
protected String () {
return unableToParseLinkHeaderNoEndToParameter;
}
@Override
public final String (final String value) {
return String.format(getLoggingLocale(), unableToParseLinkHeaderNoEndToParameter$str(), value);
}
private static final String = "RESTEASY003965: Unable to parse Link header. Too many links in declaration: %s";
protected String () {
return unableToParseLinkHeaderTooManyLinks;
}
@Override
public final String (final String value) {
return String.format(getLoggingLocale(), unableToParseLinkHeaderTooManyLinks$str(), value);
}
private static final String unableToResolveTypeVariable = "RESTEASY003970: Unable to resolve type variable";
protected String unableToResolveTypeVariable$str() {
return unableToResolveTypeVariable;
}
@Override
public final String unableToResolveTypeVariable() {
return String.format(getLoggingLocale(), unableToResolveTypeVariable$str());
}
private static final String unableToUnmarshalResponse = "RESTEASY003975: Unable to unmarshall response for %s";
protected String unableToUnmarshalResponse$str() {
return unableToUnmarshalResponse;
}
@Override
public final String unableToUnmarshalResponse(final String attributeExceptionsTo) {
return String.format(getLoggingLocale(), unableToUnmarshalResponse$str(), attributeExceptionsTo);
}
private static final String unexpectedNumberSubclass = "RESTEASY003977: Unexpected Number subclass: %s";
protected String unexpectedNumberSubclass$str() {
return unexpectedNumberSubclass;
}
@Override
public final String unexpectedNumberSubclass(final String classname) {
return String.format(getLoggingLocale(), unexpectedNumberSubclass$str(), classname);
}
private static final String unknownInterceptorPrecedence = "RESTEASY003980: Unknown interceptor precedence: %s";
protected String unknownInterceptorPrecedence$str() {
return unknownInterceptorPrecedence;
}
@Override
public final String unknownInterceptorPrecedence(final String precedence) {
return String.format(getLoggingLocale(), unknownInterceptorPrecedence$str(), precedence);
}
private static final String unknownMediaTypeResponseEntity = "RESTEASY003985: Unknown media type for response entity";
protected String unknownMediaTypeResponseEntity$str() {
return unknownMediaTypeResponseEntity;
}
@Override
public final String unknownMediaTypeResponseEntity() {
return String.format(getLoggingLocale(), unknownMediaTypeResponseEntity$str());
}
private static final String unknownPathParam = "RESTEASY003990: Unknown @PathParam: {0} for path: {1}";
protected String unknownPathParam$str() {
return unknownPathParam;
}
@Override
public final String unknownPathParam(final String paramName, final String path) {
return _formatMessage(unknownPathParam$str(), paramName, path);
}
private static final String unknownStateListener = "RESTEASY003995: Unknown state. You have a Listener messing up what resteasy expects";
protected String unknownStateListener$str() {
return unknownStateListener;
}
@Override
public final String unknownStateListener() {
return String.format(getLoggingLocale(), unknownStateListener$str());
}
private static final String unsupportedCollectionType = "RESTEASY004000: Unsupported collectionType: %s";
protected String unsupportedCollectionType$str() {
return unsupportedCollectionType;
}
@Override
public final String unsupportedCollectionType(final Class<?> clazz) {
return String.format(getLoggingLocale(), unsupportedCollectionType$str(), clazz);
}
private static final String unsupportedParameter = "RESTEASY004005: Unsupported parameter: %s";
protected String unsupportedParameter$str() {
return unsupportedParameter;
}
@Override
public final String unsupportedParameter(final String parameter) {
return String.format(getLoggingLocale(), unsupportedParameter$str(), parameter);
}
private static final String uriNull = "RESTEASY004010: URI was null";
protected String uriNull$str() {
return uriNull;
}
@Override
public final String uriNull() {
return String.format(getLoggingLocale(), uriNull$str());
}
private static final String uriParamNull = "RESTEASY004015: uri param was null";
protected String uriParamNull$str() {
return uriParamNull;
}
@Override
public final String uriParamNull() {
return String.format(getLoggingLocale(), uriParamNull$str());
}
private static final String uriTemplateParameterNull = "RESTEASY004020: uriTemplate parameter is null";
protected String uriTemplateParameterNull$str() {
return uriTemplateParameterNull;
}
@Override
public final String uriTemplateParameterNull() {
return String.format(getLoggingLocale(), uriTemplateParameterNull$str());
}
private static final String uriValueNull = "RESTEASY004025: URI value is null";
protected String uriValueNull$str() {
return uriValueNull;
}
@Override
public final String uriValueNull() {
return String.format(getLoggingLocale(), uriValueNull$str());
}
private static final String userIsNotRegistered = "RESTEASY004030: User is not registered: %s";
protected String userIsNotRegistered$str() {
return userIsNotRegistered;
}
@Override
public final String userIsNotRegistered(final String user) {
return String.format(getLoggingLocale(), userIsNotRegistered$str(), user);
}
private static final String valueNull = "RESTEASY004035: A value was null";
protected String valueNull$str() {
return valueNull;
}
@Override
public final String valueNull() {
return String.format(getLoggingLocale(), valueNull$str());
}
private static final String valueParamIsNull = "RESTEASY004040: value param is null";
protected String valueParamIsNull$str() {
return valueParamIsNull;
}
@Override
public final String valueParamIsNull() {
return String.format(getLoggingLocale(), valueParamIsNull$str());
}
private static final String valueParamWasNull = "RESTEASY004045: value param was null";
protected String valueParamWasNull$str() {
return valueParamWasNull;
}
@Override
public final String valueParamWasNull() {
return String.format(getLoggingLocale(), valueParamWasNull$str());
}
private static final String valuesParamIsNull = "RESTEASY004050: values param is null";
protected String valuesParamIsNull$str() {
return valuesParamIsNull;
}
@Override
public final String valuesParamIsNull() {
return String.format(getLoggingLocale(), valuesParamIsNull$str());
}
private static final String valuesParamWasNull = "RESTEASY004055: values param was null";
protected String valuesParamWasNull$str() {
return valuesParamWasNull;
}
@Override
public final String valuesParamWasNull() {
return String.format(getLoggingLocale(), valuesParamWasNull$str());
}
private static final String valuesParameterNull = "RESTEASY004060: values parameter is null";
protected String valuesParameterNull$str() {
return valuesParameterNull;
}
@Override
public final String valuesParameterNull() {
return String.format(getLoggingLocale(), valuesParameterNull$str());
}
private static final String variantListMustNotBeZero = "RESTEASY004065: Variant list must not be zero";
protected String variantListMustNotBeZero$str() {
return variantListMustNotBeZero;
}
@Override
public final String variantListMustNotBeZero() {
return String.format(getLoggingLocale(), variantListMustNotBeZero$str());
}
private static final String wrongPassword = "RESTEASY004070: Wrong password for: %s";
protected String wrongPassword$str() {
return wrongPassword;
}
@Override
public final String wrongPassword(final String user) {
return String.format(getLoggingLocale(), wrongPassword$str(), user);
}
private static final String webTargetIsNotSetForEventSource = "RESTEASY004080: WebTarget is not set for creating SseEventSource";
protected String webTargetIsNotSetForEventSource$str() {
return webTargetIsNotSetForEventSource;
}
@Override
public final String webTargetIsNotSetForEventSource() {
return String.format(getLoggingLocale(), webTargetIsNotSetForEventSource$str());
}
private static final String eventSourceIsNotReadyForOpen = "RESTEASY004081: EventSource is not ready to open";
protected String eventSourceIsNotReadyForOpen$str() {
return eventSourceIsNotReadyForOpen;
}
@Override
public final String eventSourceIsNotReadyForOpen() {
return String.format(getLoggingLocale(), eventSourceIsNotReadyForOpen$str());
}
private static final String notFoundMBW = "RESTEASY004082: No suitable message body writer for class : %s";
protected String notFoundMBW$str() {
return notFoundMBW;
}
@Override
public final String notFoundMBW(final String className) {
return String.format(getLoggingLocale(), notFoundMBW$str(), className);
}
private static final String asyncServletIsRequired = "RESTEASY004083: Sever sent event feature requries HttpServlet30Dispatcher";
protected String asyncServletIsRequired$str() {
return asyncServletIsRequired;
}
@Override
public final String asyncServletIsRequired() {
return String.format(getLoggingLocale(), asyncServletIsRequired$str());
}
private static final String readEventException = "RESTEASY004084: Failed to read SseEvent";
protected String readEventException$str() {
return readEventException;
}
@Override
public final String readEventException() {
return String.format(getLoggingLocale(), readEventException$str());
}
private static final String nullValueSetToCreateOutboundSseEvent = "RESTEASY004085: %s is not set for OutboundSseEvent builder";
protected String nullValueSetToCreateOutboundSseEvent$str() {
return nullValueSetToCreateOutboundSseEvent;
}
@Override
public final String nullValueSetToCreateOutboundSseEvent(final String field) {
return String.format(getLoggingLocale(), nullValueSetToCreateOutboundSseEvent$str(), field);
}
private static final String failedToWriteDataToInboudEvent = "RESTEASY004086: Failed to write data to InBoundSseEvent";
protected String failedToWriteDataToInboudEvent$str() {
return failedToWriteDataToInboudEvent;
}
@Override
public final String failedToWriteDataToInboudEvent() {
return String.format(getLoggingLocale(), failedToWriteDataToInboudEvent$str());
}
private static final String notFoundMBR = "RESTEASY004087: No suitable message body reader for class : %s";
protected String notFoundMBR$str() {
return notFoundMBR;
}
@Override
public final String notFoundMBR(final String className) {
return String.format(getLoggingLocale(), notFoundMBR$str(), className);
}
private static final String failedToReadData = "RESTEASY004088: Failed to read data from InboundSseEvent";
protected String failedToReadData$str() {
return failedToReadData;
}
@Override
public final String failedToReadData() {
return String.format(getLoggingLocale(), failedToReadData$str());
}
private static final String failedToCreateSseEventOutput = "RESTEASY004089: Failed to create SseEventOutput";
protected String failedToCreateSseEventOutput$str() {
return failedToCreateSseEventOutput;
}
@Override
public final String failedToCreateSseEventOutput() {
return String.format(getLoggingLocale(), failedToCreateSseEventOutput$str());
}
private static final String unableToInstantiateAsyncResponseProvider = "RESTEASY004090: Unable to instantiate AsyncResponseProvider";
protected String unableToInstantiateAsyncResponseProvider$str() {
return unableToInstantiateAsyncResponseProvider;
}
@Override
public final String unableToInstantiateAsyncResponseProvider() {
return String.format(getLoggingLocale(), unableToInstantiateAsyncResponseProvider$str());
}
private static final String unableToInstantiateAsyncStreamProvider = "RESTEASY004091: Unable to instantiate AsyncStreamProvider";
protected String unableToInstantiateAsyncStreamProvider$str() {
return unableToInstantiateAsyncStreamProvider;
}
@Override
public final String unableToInstantiateAsyncStreamProvider() {
return String.format(getLoggingLocale(), unableToInstantiateAsyncStreamProvider$str());
}
private static final String sseEventSinkIsClosed = "RESTEASY004092: SseEventSink is closed";
protected String sseEventSinkIsClosed$str() {
return sseEventSinkIsClosed;
}
@Override
public final String sseEventSinkIsClosed() {
return String.format(getLoggingLocale(), sseEventSinkIsClosed$str());
}
private static final String sseBroadcasterIsClosed = "RESTEASY004093: SseBroadcaster is closed";
protected String sseBroadcasterIsClosed$str() {
return sseBroadcasterIsClosed;
}
@Override
public final String sseBroadcasterIsClosed() {
return String.format(getLoggingLocale(), sseBroadcasterIsClosed$str());
}
private static final String unableToInstantiateContextInjector = "RESTEASY004094: Unable to instantiate ContextInjector";
protected String unableToInstantiateContextInjector$str() {
return unableToInstantiateContextInjector;
}
@Override
public final String unableToInstantiateContextInjector() {
return String.format(getLoggingLocale(), unableToInstantiateContextInjector$str());
}
private static final String unableToInstantiateAsyncClientResponseProvider = "RESTEASY004095: Unable to instantiate AsyncClientResponseProvider";
protected String unableToInstantiateAsyncClientResponseProvider$str() {
return unableToInstantiateAsyncClientResponseProvider;
}
@Override
public final String unableToInstantiateAsyncClientResponseProvider() {
return String.format(getLoggingLocale(), unableToInstantiateAsyncClientResponseProvider$str());
}
private static final String unableToInstantiateAsyncClientStreamProvider = "RESTEASY004096: Unable to instantiate AsyncClientStreamProvider";
protected String unableToInstantiateAsyncClientStreamProvider$str() {
return unableToInstantiateAsyncClientStreamProvider;
}
@Override
public final String unableToInstantiateAsyncClientStreamProvider() {
return String.format(getLoggingLocale(), unableToInstantiateAsyncClientStreamProvider$str());
}
private static final String registeringContextResolverAsLambda = "RESTEASY004097: Registering a context resolver doesn't support lambdas";
protected String registeringContextResolverAsLambda$str() {
return registeringContextResolverAsLambda;
}
@Override
public final String registeringContextResolverAsLambda() {
return String.format(getLoggingLocale(), registeringContextResolverAsLambda$str());
}
}
Messages_$bundle
serialVersionUID: long
Messages_$bundle(): void
http://rest-easy.org/resteasy-jaxrs:
(JBoss by Red Hat)