Package io.smallrye.reactive.messaging.providers.i18n

Interface ProviderExceptions

  • All Known Implementing Classes:
    ProviderExceptions_$bundle
    @MessageBundle(projectCode="SRMSG",
               length=5)
public interface ProviderExceptions

    • Method Detail

      • illegalArgumentForGenericParameterType

        @Message(id=1,
         value="Method %s only has %d so parameter with index %d cannot be retrieved")
IllegalArgumentException illegalArgumentForGenericParameterType​(Method method,
                                                                int length,
                                                                int index)

      • illegalArgumentForAnnotationNullOrBlank

        @Message(id=2,
         value="Invalid method annotated with %s: %s - value is blank or null")
IllegalArgumentException illegalArgumentForAnnotationNullOrBlank​(String annotation,
                                                                 String annotationTarget)

      • illegalStateExceptionForValidate

        @Message(id=3,
         value="Unknown shape: %s")
IllegalStateException illegalStateExceptionForValidate​(Shape shape)

      • illegalArgumentForValidateProcessor

        @Message(id=4,
         value="Invalid method annotated with @Outgoing and @Incoming %s - one parameter expected")
IllegalArgumentException illegalArgumentForValidateProcessor​(String methodAsString)

      • illegalStateForValidateProcessor

        @Message(id=5,
         value="Unsupported acknowledgement policy - POST_PROCESSING not supported when producing messages for %s")
IllegalStateException illegalStateForValidateProcessor​(String methodAsString)

      • definitionExceptionUnsupported

        @Message(id=6,
         value="Invalid method annotated with %s: %s - The @Acknowledgment annotation is only supported for method annotated with @Incoming")
javax.enterprise.inject.spi.DefinitionException definitionExceptionUnsupported​(String annotation,
                                                                               String methodAsString)

      • illegalArgumentForUnsupportedShape

        @Message(id=7,
         value="Unsupported shape %s for method %s")
IllegalArgumentException illegalArgumentForUnsupportedShape​(Shape shape,
                                                            String methodAsString)

      • illegalArgumentForProcessorShape

        @Message(id=8,
         value="Expected a Processor shape, received a %s")
IllegalArgumentException illegalArgumentForProcessorShape​(Shape shape)

      • illegalArgumentForInitialize

        @Message(id=9,
         value="Invalid Processor - unsupported signature for %s")
IllegalArgumentException illegalArgumentForInitialize​(String methodAsString)

      • illegalArgumentForPublisherShape

        @Message(id=11,
         value="Expected a Publisher shape, received a %s")
IllegalArgumentException illegalArgumentForPublisherShape​(Shape shape)

      • illegalArgumentForSubscriberShape

        @Message(id=13,
         value="Expected a Subscriber shape, received a %s")
IllegalArgumentException illegalArgumentForSubscriberShape​(Shape shape)

      • illegalStateExceptionForSubscriberOrSubscriberBuilder

        @Message(id=15,
         value="Invalid return type: %s - expected a Subscriber or a SubscriberBuilder")
IllegalStateException illegalStateExceptionForSubscriberOrSubscriberBuilder​(String resultClassName)

      • runtimeForFailedWorker

        @Message(id=16,
         value="Failed to create Worker for %s")
RuntimeException runtimeForFailedWorker​(String workerName)

      • illegalArgumentForFailedWorker

        @Message(id=17,
         value="@Blocking referred to invalid worker name.")
IllegalArgumentException illegalArgumentForFailedWorker()

      • illegalStateForStream

        @Message(id=18,
         value="Unable to find a stream with the name %s, available streams are: %s")
IllegalStateException illegalStateForStream​(String name,
                                            Set<String> valid)

      • incomingNotFoundForEmitter

        @Message(id=19,
         value="Unable to connect an emitter with the channel `%s`")
javax.enterprise.inject.spi.DefinitionException incomingNotFoundForEmitter​(String name)

      • emitterWithoutChannelAnnotation

        @Message(id=20,
         value="Missing @Channel qualifier for + `%s`")
javax.enterprise.inject.spi.DefinitionException emitterWithoutChannelAnnotation​(javax.enterprise.inject.spi.InjectionPoint injectionPoint)

      • illegalArgumentForDefaultBuffer

        @Message(id=21,
         value="The default buffer size must be strictly positive")
IllegalArgumentException illegalArgumentForDefaultBuffer()

      • illegalArgumentForNullValue

        @Message(id=23,
         value="`null` is not a valid value")
IllegalArgumentException illegalArgumentForNullValue()

      • incomingNotFoundForEmitter

        @Message(id=24,
         value="The emitter encountered a failure")
IllegalStateException incomingNotFoundForEmitter​(@Cause
                                                 Throwable throwable)

      • illegalStateForDownstreamCancel

        @Message(id=25,
         value="The downstream has cancelled the consumption")
IllegalStateException illegalStateForDownstreamCancel()

      • illegalStateForEmitterWhileEmitting

        @Message(id=26,
         value="The emitter encountered a failure while emitting")
IllegalStateException illegalStateForEmitterWhileEmitting​(@Cause
                                                          Throwable throwable)

      • noEmitterForChannel

        @Message(id=27,
         value="Cannot send a message, there is no subscriber found for the channel \'%s\'. Before calling `send`, you can verify there is a subscriber and demands using `emitter.hasRequests()`. Alternatively, you can add `@OnOverflow(OnOverflow.Strategy.DROP)` on the emitter.")
IllegalStateException noEmitterForChannel​(String name)

      • illegalStateForCancelledSubscriber

        @Message(id=28,
         value="The subscription to %s has been cancelled")
IllegalStateException illegalStateForCancelledSubscriber​(String name)

      • illegalArgumentForException

        @Message(id=29,
         value="`%s` is not a valid exception")
IllegalArgumentException illegalArgumentForException​(String val)

      • illegalStateInsufficientDownstreamRequests

        @Message(id=34,
         value="Insufficient downstream requests to emit item")
IllegalStateException illegalStateInsufficientDownstreamRequests()

      • illegalStateUnhandledType

        @Message(id=35,
         value="found an unhandled type: %s")
IllegalStateException illegalStateUnhandledType​(Type type)

      • illegalArgumentMissingAssignment

        @Message(id=36,
         value="missing assignment type for type variable %s")
IllegalArgumentException illegalArgumentMissingAssignment​(Type type)

      • illegalStateUnexpectedGenericInterface

        @Message(id=37,
         value="Unexpected generic interface type found: %s")
IllegalStateException illegalStateUnexpectedGenericInterface​(Type type)

      • validationForContainsNull

        @Message(id=42,
         value="%s must not contain a `null` element")
IllegalArgumentException validationForContainsNull​(String name)

      • illegalArgumentInvalidChannelConfiguration

        @Message(id=44,
         value="Invalid channel configuration -  the `channel-name` attribute cannot be used in configuration (channel `%s`)")
IllegalArgumentException illegalArgumentInvalidChannelConfiguration​(String name)

      • noSuchElementForAttribute

        @Message(id=45,
         value="Cannot find attribute `%s` for channel `%s`. Has been tried: % and %s")
NoSuchElementException noSuchElementForAttribute​(String propertyName,
                                                 String name,
                                                 String channelKey,
                                                 String connectorKey)

      • illegalArgumentForAnnotationNonEmpty

        @Message(id=46,
         value="%ss must contain a non-empty array of %s")
IllegalArgumentException illegalArgumentForAnnotationNonEmpty​(String annotation,
                                                              String annotationTarget)

      • definitionNoParamOnSubscriber

        @Message(id=47,
         value="Invalid method annotated with %s: %s - when returning a Subscriber or a SubscriberBuilder, no parameters are expected")
javax.enterprise.inject.spi.DefinitionException definitionNoParamOnSubscriber​(String annotation,
                                                                              String methodAsString)

      • definitionSubscriberTypeParam

        @Message(id=48,
         value="Invalid method annotated with %s: %s - the returned Subscriber must declare a type parameter")
javax.enterprise.inject.spi.DefinitionException definitionSubscriberTypeParam​(String annotation,
                                                                              String methodAsString)

      • definitionOnParam

        @Message(id=49,
         value="Invalid method annotated with %s: %s - when returning a %s, one parameter is expected")
javax.enterprise.inject.spi.DefinitionException definitionOnParam​(String annotation,
                                                                  String methodAsString,
                                                                  String returnType)

      • definitionUnsupportedSignature

        @Message(id=50,
         value="Invalid method annotated with %s: %s - Unsupported signature")
javax.enterprise.inject.spi.DefinitionException definitionUnsupportedSignature​(String annotation,
                                                                               String methodAsString)

      • unsupportedSynchronousSignature

        @Message(id=51,
         value="Invalid method annotated with @Incoming: %s - The signature is not supported. The method consumes a `Message`, so the returned type must be `CompletionStage<Void>` or `Uni<Void>`.")
javax.enterprise.inject.spi.DefinitionException unsupportedSynchronousSignature​(String methodAsString)

      • definitionNotVoid

        @Message(id=52,
         value="Invalid method annotated with %s: %s - the method must not be `void`")
javax.enterprise.inject.spi.DefinitionException definitionNotVoid​(String annotation,
                                                                  String methodAsString)

      • definitionNoParametersExpected

        @Message(id=53,
         value="Invalid method annotated with %s: %s - no parameters expected")
javax.enterprise.inject.spi.DefinitionException definitionNoParametersExpected​(String annotation,
                                                                               String methodAsString)

      • definitionMustDeclareParam

        @Message(id=54,
         value="Invalid method annotated with %s: %s - the returned %s must declare a type parameter")
javax.enterprise.inject.spi.DefinitionException definitionMustDeclareParam​(String annotation,
                                                                           String methodAsString,
                                                                           String returnClass)

      • definitionMustNotHaveParams

        @Message(id=55,
         value="Invalid method annotated with %s: %s - the method must not have parameters")
javax.enterprise.inject.spi.DefinitionException definitionMustNotHaveParams​(String annotation,
                                                                            String methodAsString)

      • definitionExpectedTwoParams

        @Message(id=56,
         value="Invalid method annotated with %s: %s - Expected 2 type parameters for the returned Processor")
javax.enterprise.inject.spi.DefinitionException definitionExpectedTwoParams​(String annotation,
                                                                            String methodAsString)

      • definitionExpectedReturnedParam

        @Message(id=57,
         value="Invalid method annotated with %s: %s - Expected a type parameter in the returned %s")
javax.enterprise.inject.spi.DefinitionException definitionExpectedReturnedParam​(String annotation,
                                                                                String methodAsString,
                                                                                String returnClass)

      • definitionExpectedConsumedParam

        @Message(id=58,
         value="Invalid method annotated with %s: %s - Expected a type parameter for the consumed  %s")
javax.enterprise.inject.spi.DefinitionException definitionExpectedConsumedParam​(String annotation,
                                                                                String methodAsString,
                                                                                String returnClass)

      • definitionAutoAckNotSupported

        @Message(id=59,
         value="Invalid method annotated with %s: %s - Automatic post-processing acknowledgment is not supported.")
javax.enterprise.inject.spi.DefinitionException definitionAutoAckNotSupported​(String annotation,
                                                                              String methodAsString)

      • definitionManualAckNotSupported

        @Message(id=60,
         value="Invalid method annotated with %s: %s - Consuming a stream of payload is not supported with MANUAL acknowledgment. Use a Publisher<Message<I>> or PublisherBuilder<Message<I>> instead.")
javax.enterprise.inject.spi.DefinitionException definitionManualAckNotSupported​(String annotation,
                                                                                String methodAsString)

      • definitionProduceConsume

        @Message(id=61,
         value="Invalid method annotated with %s: %s - If the method produces a PublisherBuilder, it needs to consume a PublisherBuilder.")
javax.enterprise.inject.spi.DefinitionException definitionProduceConsume​(String annotation,
                                                                         String methodAsString)

      • definitionMergeOnlyIncoming

        @Message(id=62,
         value="Invalid method annotated with %s: %s - The @Merge annotation is only supported for method annotated with @Incoming")
javax.enterprise.inject.spi.DefinitionException definitionMergeOnlyIncoming​(String annotation,
                                                                            String methodAsString)

      • definitionBroadcastOnlyOutgoing

        @Message(id=63,
         value="Invalid method annotated with %s: %s - The @Broadcast annotation is only supported for method annotated with @Outgoing")
javax.enterprise.inject.spi.DefinitionException definitionBroadcastOnlyOutgoing​(String annotation,
                                                                                String methodAsString)

      • definitionBlockingOnlyIndividual

        @Message(id=64,
         value="Invalid method annotated with @Blocking: %s - The @Blocking annotation is only supported for methods returning `void` (@Incoming only), a `Message` or a payload")
javax.enterprise.inject.spi.DefinitionException definitionBlockingOnlyIndividual​(String methodAsString)

      • definitionBlockingOnlyIndividualParam

        @Message(id=65,
         value="Invalid method annotated with @Blocking: %s - The @Blocking annotation is only supported for methods consuming an individual Message or payload like `consume(String s)` or `consume(Message<String> s)")
javax.enterprise.inject.spi.DefinitionException definitionBlockingOnlyIndividualParam​(String methodAsString)

      • illegalBlockingSignature

        @Message(id=66,
         value="Invalid method annotated with @Blocking: %s - no @Incoming or @Outgoing present")
IllegalArgumentException illegalBlockingSignature​(String methodAsString)

      • illegalArgumentForWorkerConfigKey

        @Message(id=67,
         value="Invalid method annotated with %s: %s - %s was not defined")
IllegalArgumentException illegalArgumentForWorkerConfigKey​(String annotation,
                                                           String annotationTarget,
                                                           String workerConfigKey)

      • nullPointerOnInvokeBlocking

        @Message(id=68,
         value="The operation %s has returned null")
NullPointerException nullPointerOnInvokeBlocking​(String methodAsString)

      • illegalArgumentChannelConnectorConfiguration

        @Message(id=71,
         value="Invalid channel configuration -  the `connector` attribute must be set for channel `%s`")
IllegalArgumentException illegalArgumentChannelConnectorConfiguration​(String name)

      • illegalArgumentUnknownConnector

        @Message(id=72,
         value="Unknown connector for `%s`.")
IllegalArgumentException illegalArgumentUnknownConnector​(String name)

      • deploymentInvalidConfiguration

        @Message(id=73,
         value="Invalid configuration, the following channel names cannot be used for both incoming and outgoing: %s")
javax.enterprise.inject.spi.DeploymentException deploymentInvalidConfiguration​(Set<String> sources)

      • illegalStateRetrieveConfig

        @Message(id=74,
         value="Unable to retrieve the config")
IllegalStateException illegalStateRetrieveConfig()

      • invalidEmitterOfMessage

        @Message(id=75,
         value="Invalid Emitter injection found for `%s`. Injecting an `Emitter<Message<T>>` is invalid. You can use an `Emitter<T>` to send instances of `T` and `Message<T>`.")
javax.enterprise.inject.spi.DefinitionException invalidEmitterOfMessage​(javax.enterprise.inject.spi.InjectionPoint ip)

      • invalidRawEmitter

        @Message(id=76,
         value="Invalid Emitter injection found for  `%s`. The Emitter expected to be parameterized with the emitted type, such as Emitter<String>.")
javax.enterprise.inject.spi.DefinitionException invalidRawEmitter​(javax.enterprise.inject.spi.InjectionPoint ip)

      • noConverterForType

        @Message(id=77,
         value="No converter for type `%s`")
NoSuchElementException noConverterForType​(Class<?> propertyType)

      • converterReturnedNull

        @Message(id=78,
         value="Converter `%s` returned null for value `%s`")
NoSuchElementException converterReturnedNull​(org.eclipse.microprofile.config.spi.Converter<?> converter,
                                             String value)

      • definitionCompletionStageOfVoid

        @Message(id=80,
         value="Invalid method annotated with @Incoming: %s - when returning a CompletionStage, you must return a CompletionStage<Void>")
javax.enterprise.inject.spi.DefinitionException definitionCompletionStageOfVoid​(String methodAsString)

      • definitionReturnVoid

        @Message(id=81,
         value="Invalid method annotated with @Incoming: %s. The signature is not supported as the produced result would be ignored. The method must return `void`, found %s.")
javax.enterprise.inject.spi.DefinitionException definitionReturnVoid​(String methodAsString,
                                                                     String returnType)

      • definitionProduceMessageStreamAndConsumePayload

        @Message(id=82,
         value="Invalid method signature for %s - method returning a Multi<Message<O>>, Publisher<Message<O>> or a PublisherBuilder<Message<O>> cannot consume an individual payload. You must consume a Message<I> instead and handle the acknowledgement.")
javax.enterprise.inject.spi.DefinitionException definitionProduceMessageStreamAndConsumePayload​(String methodAsString)

      • definitionProducePayloadStreamAndConsumeMessage

        @Message(id=83,
         value="Invalid method signature for %s - method returning a Multi<O>, Publisher<O> or a PublisherBuilder<O> cannot consume an individual message. You must consume a payload instead or return a Publisher<Message<O>> or a PublisherBuilder<Message<O>>.")
javax.enterprise.inject.spi.DefinitionException definitionProducePayloadStreamAndConsumeMessage​(String methodAsString)

      • definitionProducePayloadStreamAndConsumeMessageStream

        @Message(id=84,
         value="Invalid method signature for %s - method returning a Multi<O>, Publisher<O> or a PublisherBuilder<O> cannot consume a Publisher<Message<I>> or a Multi<Message<I>>. You must consume a Multi<I> or a Publisher<I> instead.")
javax.enterprise.inject.spi.DefinitionException definitionProducePayloadStreamAndConsumeMessageStream​(String messageAsString)

      • definitionProduceMessageStreamAndConsumePayloadStream

        @Message(id=85,
         value="Invalid method signature for %s - method returning a Multi<Message<O>>, Publisher<Message<O>> or a PublisherBuilder<Message<O>> cannot consume a Publisher<I> or a Multi<I>. You must consume a Multi<Message<I>> or a Publisher<Message<I>> instead and handle the acknowledgement.")
javax.enterprise.inject.spi.DefinitionException definitionProduceMessageStreamAndConsumePayloadStream​(String messageAsString)

      • multipleBeanDeclaration

        @Message(id=86,
         value="Multiple beans expose the connector %s : %s, %s")
javax.enterprise.inject.spi.DeploymentException multipleBeanDeclaration​(String connector,
                                                                        String bean1,
                                                                        String bean2)

      • missingConnectorQualifier

        @Message(id=87,
         value="The bean %s implements a connector interface but does not use the @Connector qualifier")
javax.enterprise.inject.spi.DefinitionException missingConnectorQualifier​(String clazz)