ActiveMQMessageBundle_$bundle (Red Hat JBoss Enterprise Application Platform 7.4.0.GA public API)

java.lang.Object
- org.apache.activemq.artemis.core.server.ActiveMQMessageBundle_$bundle

All Implemented Interfaces:: Serializable, ActiveMQMessageBundle

@Generated(value="org.jboss.logging.processor.generator.model.MessageBundleImplementor",
           date="2021-06-15T05:53:32+0000")
public class ActiveMQMessageBundle_$bundle
extends Object
implements ActiveMQMessageBundle, Serializable

Warning this class consists of generated code.

See Also:: Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static ActiveMQMessageBundle_$bundle INSTANCE
- Fields inherited from interface org.apache.activemq.artemis.core.server.ActiveMQMessageBundle
  BUNDLE

Fields
Modifier and Type	Field and Description
`static ActiveMQMessageBundle_$bundle`	`INSTANCE`

Constructor Summary

Constructors
Modifier Constructor and Description

protected ActiveMQMessageBundle_$bundle()

Constructors
Modifier	Constructor and Description
`protected`	`ActiveMQMessageBundle_$bundle()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IllegalArgumentException`	`acceptorExists(Integer id)`
`protected String`	`acceptorExists$str()`
`IllegalArgumentException`	`acceptorNotExists(Integer id)`
`protected String`	`acceptorNotExists$str()`
`IllegalStateException`	`acceptorUnavailable()`
`protected String`	`acceptorUnavailable$str()`
`String`	`activationForServer(ActiveMQServer server)`
`protected String`	`activationForServer$str()`
`ActiveMQAddressExistsException`	`addressAlreadyExists(SimpleString address)`
`protected String`	`addressAlreadyExists$str()`
`ActiveMQAddressDoesNotExistException`	`addressDoesNotExist(SimpleString address)`
`protected String`	`addressDoesNotExist$str()`
`ActiveMQDeleteAddressException`	`addressHasBindings(SimpleString address)`
`protected String`	`addressHasBindings$str()`
`ActiveMQAddressFullException`	`addressIsFull(String addressName)`
`protected String`	`addressIsFull$str()`
`IllegalArgumentException`	`addressIsNull()`
`protected String`	`addressIsNull$str()`
`ActiveMQIllegalStateException`	`alreadyHaveReplicationServer()`
`protected String`	`alreadyHaveReplicationServer$str()`
`IllegalArgumentException`	`autoConvertError(Class<?> aClass)`
`protected String`	`autoConvertError$str()`
`ActiveMQIllegalStateException`	`backupServerNotInSync()`
`protected String`	`backupServerNotInSync$str()`
`ActiveMQQueueExistsException`	`bindingAlreadyExists(Binding binding)`
`protected String`	`bindingAlreadyExists$str()`
`IllegalArgumentException`	`bindingIdNotSpecified()`
`protected String`	`bindingIdNotSpecified$str()`
`ActiveMQInternalErrorException`	`bindingNotDivert(SimpleString name)`
`protected String`	`bindingNotDivert$str()`
`IllegalArgumentException`	`bindingTypeNotSpecified()`
`protected String`	`bindingTypeNotSpecified$str()`
`IllegalArgumentException`	`cannotConvertToInt()`
`protected String`	`cannotConvertToInt$str()`
`ActiveMQIllegalStateException`	`cannotCreateConsumerOnClosedSession(SimpleString queueName)`
`protected String`	`cannotCreateConsumerOnClosedSession$str()`
`IllegalArgumentException`	`cannotCreateDir(String dir)`
`protected String`	`cannotCreateDir$str()`
`ActiveMQIllegalStateException`	`cannotDeleteQueueWithConsumers(SimpleString name, SimpleString queueName, String s)`
`protected String`	`cannotDeleteQueueWithConsumers$str()`
`ActiveMQIllegalStateException`	`cannotDeleteQueueWithMessages(SimpleString name, SimpleString queueName, long messageCount)`
`protected String`	`cannotDeleteQueueWithMessages$str()`
`IllegalArgumentException`	`cannotFindResource(String resourceName)`
`protected String`	`cannotFindResource$str()`
`IllegalStateException`	`cannotSetMBeanserver()`
`protected String`	`cannotSetMBeanserver$str()`
`IllegalStateException`	`cannotSetSecurityManager()`
`protected String`	`cannotSetSecurityManager$str()`
`ActiveMQIOErrorException`	`cannotWriteToClosedFile(SequentialFile file)`
`protected String`	`cannotWriteToClosedFile$str()`
`ActiveMQConnectionTimedOutException`	`clientExited(String remoteAddress, long ttl)`
`protected String`	`clientExited$str()`
`IllegalArgumentException`	`clusterNameIsNull()`
`protected String`	`clusterNameIsNull$str()`
`IllegalArgumentException`	`connectionExists(Object id)`
`protected String`	`connectionExists$str()`
`ActiveMQInternalErrorException`	`connectionsClosedByManagement(String ipAddress)`
`protected String`	`connectionsClosedByManagement$str()`
`ActiveMQInternalErrorException`	`connectionsForUserClosedByManagement(String userName)`
`protected String`	`connectionsForUserClosedByManagement$str()`
`ActiveMQInternalErrorException`	`connectionWithIDClosedByManagement(String ID)`
`protected String`	`connectionWithIDClosedByManagement$str()`
`ActiveMQInternalErrorException`	`consumerConnectionsClosedByManagement(String address)`
`protected String`	`consumerConnectionsClosedByManagement$str()`
`ActiveMQIllegalStateException`	`consumerDoesntExist(long consumerID)`
`protected String`	`consumerDoesntExist$str()`
`ActiveMQIllegalStateException`	`consumerNoReference(Long id, Long messageID, SimpleString name)`
`protected String`	`consumerNoReference$str()`
`IllegalStateException`	`couldNotMoveJournal(File dir)`
`protected String`	`couldNotMoveJournal$str()`
`String`	`destroyConnectionWithSessionMetadataClosingConnection(String serverSessionString)` Message used on on `ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)`
`protected String`	`destroyConnectionWithSessionMetadataClosingConnection$str()`
`String`	`destroyConnectionWithSessionMetadataHeader(String key, String value)` Message used on on `ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)`
`protected String`	`destroyConnectionWithSessionMetadataHeader$str()`
`String`	`destroyConnectionWithSessionMetadataNoSessionFound(String key, String value)` Message used on on `ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)`
`protected String`	`destroyConnectionWithSessionMetadataNoSessionFound$str()`
`ActiveMQDisconnectedException`	`destroyConnectionWithSessionMetadataSendException(String key, String value)` Exception used on on `ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)`
`protected String`	`destroyConnectionWithSessionMetadataSendException$str()`
`ActiveMQIOErrorException`	`diskBeyondLimit(String usableSpace, String totalSpace, String usage)`
`protected String`	`diskBeyondLimit$str()`
`IllegalArgumentException`	`distancenotSpecified()`
`protected String`	`distancenotSpecified$str()`
`ActiveMQDivertDoesNotExistException`	`divertDoesNotExist(String divert)`
`protected String`	`divertDoesNotExist$str()`
`ActiveMQInternalErrorException`	`divertWithNoName()`
`protected String`	`divertWithNoName$str()`
`ActiveMQDuplicateMetaDataException`	`duplicateMetadata(String key, String data)`
`protected String`	`duplicateMetadata$str()`
`IllegalArgumentException`	`emptyOrNull(String name)`
`protected String`	`emptyOrNull$str()`
`String`	`endThreadDump()`
`protected String`	`endThreadDump$str()`
`IllegalArgumentException`	`errorCreatingTransformerClass(Exception e, String transformerClassName)`
`protected String`	`errorCreatingTransformerClass$str()`
`IllegalStateException`	`failedToBind(String acceptor, String hostPort, Exception e)`
`protected String`	`failedToBind$str()`
`ActiveMQIllegalStateException`	`failedToFindLoginModuleEntry(String entry)`
`protected String`	`failedToFindLoginModuleEntry$str()`
`ActiveMQIllegalStateException`	`failedToLoadRoleFile(String path)`
`protected String`	`failedToLoadRoleFile$str()`
`ActiveMQIllegalStateException`	`failedToLoadSecurityConfig()`
`protected String`	`failedToLoadSecurityConfig$str()`
`ActiveMQIllegalStateException`	`failedToLoadUserFile(String path)`
`protected String`	`failedToLoadUserFile$str()`
`ActiveMQIllegalStateException`	`failedToLocateConfigURL()`
`protected String`	`failedToLocateConfigURL$str()`
`IllegalArgumentException`	`failedToParseJson(String json)`
`protected String`	`failedToParseJson$str()`
`String`	`generatingThreadDump()`
`protected String`	`generatingThreadDump$str()`
`protected Locale`	`getLoggingLocale()`
`IllegalArgumentException`	`greaterThanMinusOne(String name, Number val)`
`protected String`	`greaterThanMinusOne$str()`
`IllegalArgumentException`	`greaterThanZero(Integer count)`
`IllegalArgumentException`	`greaterThanZero(String name, Number val)`
`protected String`	`greaterThanZero1$str()`
`protected String`	`greaterThanZero2$str()`
`IllegalArgumentException`	`greaterThanZeroOrMinusOne(String name, Number val)`
`protected String`	`greaterThanZeroOrMinusOne$str()`
`ActiveMQException`	`groupWhileStopping()`
`protected String`	`groupWhileStopping$str()`
`ActiveMQIncompatibleClientServerException`	`incompatibleClientServer()`
`protected String`	`incompatibleClientServer$str()`
`IllegalArgumentException`	`inRangeOfPositiveInt(String name, Number val)`
`protected String`	`inRangeOfPositiveInt$str()`
`IllegalArgumentException`	`inRangeOfPositiveIntThanMinusOne(String name, Number val)`
`protected String`	`inRangeOfPositiveIntThanMinusOne$str()`
`IllegalArgumentException`	`invalidAddressFullPolicyType(String val)`
`protected String`	`invalidAddressFullPolicyType$str()`
`IllegalArgumentException`	`invalidDeletionPolicyType(String val)`
`protected String`	`invalidDeletionPolicyType$str()`
`ActiveMQInvalidFilterExpressionException`	`invalidFilter(Throwable e, SimpleString filter)`
`protected String`	`invalidFilter$str()`
`IllegalArgumentException`	`invalidJournal()`
`protected String`	`invalidJournal$str()`
`IllegalArgumentException`	`invalidJournalType(String val)`
`protected String`	`invalidJournalType$str()`
`IllegalArgumentException`	`invalidJournalType2(JournalType journalType)`
`protected String`	`invalidJournalType2$str()`
`IllegalArgumentException`	`invalidMatch()`
`protected String`	`invalidMatch$str()`
`IllegalArgumentException`	`invalidMaxConsumers(String queueName, int value)`
`protected String`	`invalidMaxConsumers$str()`
`IllegalStateException`	`invalidMaxConsumersUpdate(String queueName, int maxConsumers, int consumers)`
`protected String`	`invalidMaxConsumersUpdate$str()`
`IllegalArgumentException`	`invalidMessageLoadBalancingType(String val)`
`protected String`	`invalidMessageLoadBalancingType$str()`
`IllegalArgumentException`	`invalidNewPriority(Integer period)`
`protected String`	`invalidNewPriority$str()`
`ActiveMQIllegalStateException`	`invalidPageIO()`
`protected String`	`invalidPageIO$str()`
`ActiveMQInvalidQueueConfiguration`	`invalidQueueConfiguration(SimpleString address, SimpleString queueName, String queuePropertyName, Object expectedValue, Object actualValue)`
`protected String`	`invalidQueueConfiguration$str()`
`ActiveMQIllegalStateException`	`invalidQueueName(SimpleString queueName)`
`protected String`	`invalidQueueName$str()`
`IllegalArgumentException`	`invalidRoutingType(String val)`
`protected String`	`invalidRoutingType$str()`
`IllegalStateException`	`invalidRoutingTypeDelete(RoutingType routingType, String address)`
`protected String`	`invalidRoutingTypeDelete$str()`
`IllegalArgumentException`	`invalidRoutingTypeForAddress(RoutingType routingType, String address, Set<RoutingType> supportedRoutingTypes)`
`protected String`	`invalidRoutingTypeForAddress$str()`
`IllegalStateException`	`invalidRoutingTypeUpdate(String queueName, RoutingType routingType, String address, Set<RoutingType> supportedRoutingTypes)`
`protected String`	`invalidRoutingTypeUpdate$str()`
`IllegalArgumentException`	`invalidSlowConsumerPolicyType(String val)`
`protected String`	`invalidSlowConsumerPolicyType$str()`
`IllegalArgumentException`	`invalidType(Object type)`
`protected String`	`invalidType$str()`
`IllegalStateException`	`journalDirIsFile(File fDir)`
`protected String`	`journalDirIsFile$str()`
`ActiveMQIllegalStateException`	`journalsNotInSync()`
`protected String`	`journalsNotInSync$str()`
`ActiveMQIllegalStateException`	`largeMessageNotInitialised()`
`protected String`	`largeMessageNotInitialised$str()`
`IllegalArgumentException`	`lessThanOrEqualToOne(String name, Number val)`
`protected String`	`lessThanOrEqualToOne$str()`
`ActiveMQIllegalStateException`	`liveBackupMismatch()`
`protected String`	`liveBackupMismatch$str()`
`ActiveMQQueueMaxConsumerLimitReached`	`maxConsumerLimitReachedForQueue(SimpleString address, SimpleString queueName)`
`protected String`	`maxConsumerLimitReachedForQueue$str()`
`ActiveMQIllegalStateException`	`messageIdNotAssigned()`
`protected String`	`messageIdNotAssigned$str()`
`IllegalStateException`	`methodNotApplicable()`
`protected String`	`methodNotApplicable$str()`
`IllegalArgumentException`	`mustbeBetween(String name, Integer minPriority, Integer maxPriority, Object value)`
`protected String`	`mustbeBetween$str()`
`ActiveMQIllegalStateException`	`noAddress()`
`protected String`	`noAddress$str()`
`ActiveMQInternalErrorException`	`noBindingForDivert(SimpleString name)`
`protected String`	`noBindingForDivert$str()`
`ActiveMQException`	`noConfigurationFoundForScaleDown()`
`protected String`	`noConfigurationFoundForScaleDown$str()`
`IllegalArgumentException`	`nodeIdNull()`
`protected String`	`nodeIdNull$str()`
`ActiveMQException`	`noDiscoveryGroupFound(DiscoveryGroupConfiguration dg)`
`protected String`	`noDiscoveryGroupFound$str()`
`IllegalArgumentException`	`noGetterMethod(String resourceName)`
`protected String`	`noGetterMethod$str()`
`IllegalArgumentException`	`noOperation(String operation, Integer length)`
`protected String`	`noOperation$str()`
`IllegalArgumentException`	`noQueueFound(String otherQueueName)`
`protected String`	`noQueueFound$str()`
`ActiveMQNonExistentQueueException`	`noSuchQueue(SimpleString queueName)`
`protected String`	`noSuchQueue$str()`
`ActiveMQInternalErrorException`	`notJournalImpl()`
`protected String`	`notJournalImpl$str()`
`IllegalArgumentException`	`notPercent(String name, Number val)`
`protected String`	`notPercent$str()`
`IllegalArgumentException`	`notPercentOrMinusOne(String name, Number val)`
`protected String`	`notPercentOrMinusOne$str()`
`IllegalArgumentException`	`nullMatch()`
`protected String`	`nullMatch$str()`
`IllegalArgumentException`	`nullPassword()`
`protected String`	`nullPassword$str()`
`IllegalArgumentException`	`nullUser()`
`protected String`	`nullUser$str()`
`IllegalArgumentException`	`periodMustGreaterThanZero(Long newPeriod)`
`protected String`	`periodMustGreaterThanZero$str()`
`ActiveMQQueueExistsException`	`queueAlreadyExists(SimpleString queueName, SimpleString addressName)`
`protected String`	`queueAlreadyExists$str()`
`ActiveMQSessionCreationException`	`queueLimitReached(String username, int limit)`
`protected String`	`queueLimitReached$str()`
`IllegalArgumentException`	`queueNameIsNull()`
`protected String`	`queueNameIsNull$str()`
`ActiveMQInvalidTransientQueueUseException`	`queueSubscriptionBelongsToDifferentAddress(SimpleString queueName)`
`protected String`	`queueSubscriptionBelongsToDifferentAddress$str()`
`ActiveMQInvalidTransientQueueUseException`	`queueSubscriptionBelongsToDifferentFilter(SimpleString queueName)`
`protected String`	`queueSubscriptionBelongsToDifferentFilter$str()`
`protected Object`	`readResolve()`
`ActiveMQIllegalStateException`	`rejectEmptyValidatedUser()`
`protected String`	`rejectEmptyValidatedUser$str()`
`ActiveMQInternalErrorException`	`replicationBackupUpToDate()`
`protected String`	`replicationBackupUpToDate$str()`
`ActiveMQReplicationTimeooutException`	`replicationSynchronizationTimeout(long timeout)`
`protected String`	`replicationSynchronizationTimeout$str()`
`ActiveMQInternalErrorException`	`replicationTooManyJournals()`
`protected String`	`replicationTooManyJournals$str()`
`ActiveMQInternalErrorException`	`replicationUnhandledDataType()`
`protected String`	`replicationUnhandledDataType$str()`
`ActiveMQInternalErrorException`	`replicationUnhandledError(Exception e)`
`protected String`	`replicationUnhandledError$str()`
`ActiveMQInternalErrorException`	`replicationUnhandledFileType(ReplicationSyncFileMessage.FileType fileType)`
`protected String`	`replicationUnhandledFileType$str()`
`ActiveMQIllegalStateException`	`replicatorIsNull()`
`protected String`	`replicatorIsNull$str()`
`IllegalArgumentException`	`routeNameIsNull()`
`protected String`	`routeNameIsNull$str()`
`String`	`serverDescribe(String identity, String describe)`
`protected String`	`serverDescribe$str()`
`ActiveMQIllegalStateException`	`serverNotBackupServer()`
`protected String`	`serverNotBackupServer$str()`
`ActiveMQSessionCreationException`	`serverNotStarted()`
`protected String`	`serverNotStarted$str()`
`ActiveMQSessionCreationException`	`sessionLimitReached(String username, int limit)`
`protected String`	`sessionLimitReached$str()`
`String`	`threadDump(Thread key, String name, Long id, ThreadGroup threadGroup)`
`protected String`	`threadDump$str()`
`ActiveMQClusterSecurityException`	`unableToValidateClusterUser(String user)`
`protected String`	`unableToValidateClusterUser$str()`
`ActiveMQSecurityException`	`unableToValidateUser(String remoteAddress, String user, String certMessage)`
`protected String`	`unableToValidateUser$str()`
`ActiveMQUnexpectedRoutingTypeForAddress`	`unexpectedRoutingTypeForAddress(SimpleString address, RoutingType expectedRoutingType, Set<RoutingType> supportedRoutingTypes)`
`protected String`	`unexpectedRoutingTypeForAddress$str()`
`IllegalArgumentException`	`unknownProtocol(String protocol)`
`protected String`	`unknownProtocol$str()`
`ActiveMQIllegalStateException`	`unsupportedHAPolicyConfiguration(Object o)`
`protected String`	`unsupportedHAPolicyConfiguration$str()`
`IllegalArgumentException`	`userAlreadyExists(String user)`
`protected String`	`userAlreadyExists$str()`
`IllegalArgumentException`	`userDoesNotExist(String user)`
`protected String`	`userDoesNotExist$str()`
`ActiveMQSecurityException`	`userNoPermissions(String username, CheckType checkType, SimpleString address)`
`protected String`	`userNoPermissions$str()`
`ActiveMQSecurityException`	`userNoPermissionsQueue(String username, CheckType checkType, SimpleString queue, SimpleString address)`
`protected String`	`userNoPermissionsQueue$str()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

INSTANCE

public static final ActiveMQMessageBundle_$bundle INSTANCE

Constructor Detail
- ActiveMQMessageBundle_$bundle
```
protected ActiveMQMessageBundle_$bundle()
```

Method Detail

readResolve
```
protected Object readResolve()
```

getLoggingLocale
```
protected Locale getLoggingLocale()
```

activationForServer$str

protected String activationForServer$str()

activationForServer
```
public final String activationForServer(ActiveMQServer server)
```
Specified by:

activationForServer in interface ActiveMQMessageBundle

generatingThreadDump$str

protected String generatingThreadDump$str()

generatingThreadDump
```
public final String generatingThreadDump()
```
Specified by:

generatingThreadDump in interface ActiveMQMessageBundle

threadDump$str
```
protected String threadDump$str()
```

threadDump

public final String threadDump(Thread key,
                               String name,
                               Long id,
                               ThreadGroup threadGroup)

Specified by:: threadDump in interface ActiveMQMessageBundle

endThreadDump$str
```
protected String endThreadDump$str()
```

endThreadDump
```
public final String endThreadDump()
```
Specified by:

endThreadDump in interface ActiveMQMessageBundle

serverDescribe$str
```
protected String serverDescribe$str()
```

serverDescribe

public final String serverDescribe(String identity,
                                   String describe)

Specified by:: serverDescribe in interface ActiveMQMessageBundle

connectionsClosedByManagement$str

protected String connectionsClosedByManagement$str()

connectionsClosedByManagement
```
public final ActiveMQInternalErrorException connectionsClosedByManagement(String ipAddress)
```
Specified by:

connectionsClosedByManagement in interface ActiveMQMessageBundle

notJournalImpl$str
```
protected String notJournalImpl$str()
```

notJournalImpl
```
public final ActiveMQInternalErrorException notJournalImpl()
```
Specified by:

notJournalImpl in interface ActiveMQMessageBundle

replicationUnhandledError$str

protected String replicationUnhandledError$str()

replicationUnhandledError
```
public final ActiveMQInternalErrorException replicationUnhandledError(Exception e)
```
Specified by:

replicationUnhandledError in interface ActiveMQMessageBundle

replicationTooManyJournals$str

protected String replicationTooManyJournals$str()

replicationTooManyJournals
```
public final ActiveMQInternalErrorException replicationTooManyJournals()
```
Specified by:

replicationTooManyJournals in interface ActiveMQMessageBundle

replicationUnhandledFileType$str

protected String replicationUnhandledFileType$str()

replicationUnhandledFileType

public final ActiveMQInternalErrorException replicationUnhandledFileType(ReplicationSyncFileMessage.FileType fileType)

Specified by:: replicationUnhandledFileType in interface ActiveMQMessageBundle

replicationBackupUpToDate$str

protected String replicationBackupUpToDate$str()

replicationBackupUpToDate
```
public final ActiveMQInternalErrorException replicationBackupUpToDate()
```
Specified by:

replicationBackupUpToDate in interface ActiveMQMessageBundle

replicationUnhandledDataType$str

protected String replicationUnhandledDataType$str()

replicationUnhandledDataType
```
public final ActiveMQInternalErrorException replicationUnhandledDataType()
```
Specified by:

replicationUnhandledDataType in interface ActiveMQMessageBundle

noBindingForDivert$str

protected String noBindingForDivert$str()

noBindingForDivert

public final ActiveMQInternalErrorException noBindingForDivert(SimpleString name)

Specified by:: noBindingForDivert in interface ActiveMQMessageBundle

bindingNotDivert$str

protected String bindingNotDivert$str()

bindingNotDivert

public final ActiveMQInternalErrorException bindingNotDivert(SimpleString name)

Specified by:: bindingNotDivert in interface ActiveMQMessageBundle

clientExited$str
```
protected String clientExited$str()
```

clientExited

public final ActiveMQConnectionTimedOutException clientExited(String remoteAddress,
                                                              long ttl)

Specified by:: clientExited in interface ActiveMQMessageBundle

divertWithNoName$str

protected String divertWithNoName$str()

divertWithNoName
```
public final ActiveMQInternalErrorException divertWithNoName()
```
Specified by:

divertWithNoName in interface ActiveMQMessageBundle

noSuchQueue$str
```
protected String noSuchQueue$str()
```

noSuchQueue

public final ActiveMQNonExistentQueueException noSuchQueue(SimpleString queueName)

Specified by:: noSuchQueue in interface ActiveMQMessageBundle

bindingAlreadyExists$str

protected String bindingAlreadyExists$str()

bindingAlreadyExists

public final ActiveMQQueueExistsException bindingAlreadyExists(Binding binding)

Specified by:: bindingAlreadyExists in interface ActiveMQMessageBundle

queueAlreadyExists$str

protected String queueAlreadyExists$str()

queueAlreadyExists

public final ActiveMQQueueExistsException queueAlreadyExists(SimpleString queueName,
                                                             SimpleString addressName)

Specified by:: queueAlreadyExists in interface ActiveMQMessageBundle

invalidFilter$str
```
protected String invalidFilter$str()
```

invalidFilter

public final ActiveMQInvalidFilterExpressionException invalidFilter(Throwable e,
                                                                    SimpleString filter)

Specified by:: invalidFilter in interface ActiveMQMessageBundle

messageIdNotAssigned$str

protected String messageIdNotAssigned$str()

messageIdNotAssigned
```
public final ActiveMQIllegalStateException messageIdNotAssigned()
```
Specified by:

messageIdNotAssigned in interface ActiveMQMessageBundle

journalsNotInSync$str

protected String journalsNotInSync$str()

journalsNotInSync
```
public final ActiveMQIllegalStateException journalsNotInSync()
```
Specified by:

journalsNotInSync in interface ActiveMQMessageBundle

serverNotBackupServer$str

protected String serverNotBackupServer$str()

serverNotBackupServer
```
public final ActiveMQIllegalStateException serverNotBackupServer()
```
Specified by:

serverNotBackupServer in interface ActiveMQMessageBundle

alreadyHaveReplicationServer$str

protected String alreadyHaveReplicationServer$str()

alreadyHaveReplicationServer
```
public final ActiveMQIllegalStateException alreadyHaveReplicationServer()
```
Specified by:

alreadyHaveReplicationServer in interface ActiveMQMessageBundle

cannotDeleteQueueWithConsumers$str

protected String cannotDeleteQueueWithConsumers$str()

cannotDeleteQueueWithConsumers

public final ActiveMQIllegalStateException cannotDeleteQueueWithConsumers(SimpleString name,
                                                                          SimpleString queueName,
                                                                          String s)

Specified by:: cannotDeleteQueueWithConsumers in interface ActiveMQMessageBundle

backupServerNotInSync$str

protected String backupServerNotInSync$str()

backupServerNotInSync
```
public final ActiveMQIllegalStateException backupServerNotInSync()
```
Specified by:

backupServerNotInSync in interface ActiveMQMessageBundle

consumerNoReference$str

protected String consumerNoReference$str()

consumerNoReference

public final ActiveMQIllegalStateException consumerNoReference(Long id,
                                                               Long messageID,
                                                               SimpleString name)

Specified by:: consumerNoReference in interface ActiveMQMessageBundle

consumerDoesntExist$str

protected String consumerDoesntExist$str()

consumerDoesntExist

public final ActiveMQIllegalStateException consumerDoesntExist(long consumerID)

Specified by:: consumerDoesntExist in interface ActiveMQMessageBundle

noAddress$str
```
protected String noAddress$str()
```

noAddress
```
public final ActiveMQIllegalStateException noAddress()
```
Specified by:

noAddress in interface ActiveMQMessageBundle

largeMessageNotInitialised$str

protected String largeMessageNotInitialised$str()

largeMessageNotInitialised
```
public final ActiveMQIllegalStateException largeMessageNotInitialised()
```
Specified by:

largeMessageNotInitialised in interface ActiveMQMessageBundle

unableToValidateUser$str

protected String unableToValidateUser$str()

unableToValidateUser

public final ActiveMQSecurityException unableToValidateUser(String remoteAddress,
                                                            String user,
                                                            String certMessage)

Specified by:: unableToValidateUser in interface ActiveMQMessageBundle

userNoPermissions$str

protected String userNoPermissions$str()

userNoPermissions

public final ActiveMQSecurityException userNoPermissions(String username,
                                                         CheckType checkType,
                                                         SimpleString address)

Specified by:: userNoPermissions in interface ActiveMQMessageBundle

incompatibleClientServer$str

protected String incompatibleClientServer$str()

incompatibleClientServer
```
public final ActiveMQIncompatibleClientServerException incompatibleClientServer()
```
Specified by:

incompatibleClientServer in interface ActiveMQMessageBundle

serverNotStarted$str

protected String serverNotStarted$str()

serverNotStarted
```
public final ActiveMQSessionCreationException serverNotStarted()
```
Specified by:

serverNotStarted in interface ActiveMQMessageBundle

duplicateMetadata$str

protected String duplicateMetadata$str()

duplicateMetadata

public final ActiveMQDuplicateMetaDataException duplicateMetadata(String key,
                                                                  String data)

Specified by:: duplicateMetadata in interface ActiveMQMessageBundle

invalidType$str
```
protected String invalidType$str()
```

invalidType

public final IllegalArgumentException invalidType(Object type)

Specified by:: invalidType in interface ActiveMQMessageBundle

emptyOrNull$str
```
protected String emptyOrNull$str()
```

emptyOrNull

public final IllegalArgumentException emptyOrNull(String name)

Specified by:: emptyOrNull in interface ActiveMQMessageBundle

greaterThanZero2$str

protected String greaterThanZero2$str()

greaterThanZero

public final IllegalArgumentException greaterThanZero(String name,
                                                      Number val)

Specified by:: greaterThanZero in interface ActiveMQMessageBundle

notPercent$str
```
protected String notPercent$str()
```

notPercent

public final IllegalArgumentException notPercent(String name,
                                                 Number val)

Specified by:: notPercent in interface ActiveMQMessageBundle

greaterThanMinusOne$str

protected String greaterThanMinusOne$str()

greaterThanMinusOne

public final IllegalArgumentException greaterThanMinusOne(String name,
                                                          Number val)

Specified by:: greaterThanMinusOne in interface ActiveMQMessageBundle

greaterThanZeroOrMinusOne$str

protected String greaterThanZeroOrMinusOne$str()

greaterThanZeroOrMinusOne

public final IllegalArgumentException greaterThanZeroOrMinusOne(String name,
                                                                Number val)

Specified by:: greaterThanZeroOrMinusOne in interface ActiveMQMessageBundle

mustbeBetween$str
```
protected String mustbeBetween$str()
```

mustbeBetween

public final IllegalArgumentException mustbeBetween(String name,
                                                    Integer minPriority,
                                                    Integer maxPriority,
                                                    Object value)

Specified by:: mustbeBetween in interface ActiveMQMessageBundle

invalidJournalType$str

protected String invalidJournalType$str()

invalidJournalType
```
public final IllegalArgumentException invalidJournalType(String val)
```
Specified by:

invalidJournalType in interface ActiveMQMessageBundle

invalidAddressFullPolicyType$str

protected String invalidAddressFullPolicyType$str()

invalidAddressFullPolicyType
```
public final IllegalArgumentException invalidAddressFullPolicyType(String val)
```
Specified by:

invalidAddressFullPolicyType in interface ActiveMQMessageBundle

greaterThanZero1$str

protected String greaterThanZero1$str()

greaterThanZero

public final IllegalArgumentException greaterThanZero(Integer count)

Specified by:: greaterThanZero in interface ActiveMQMessageBundle

periodMustGreaterThanZero$str

protected String periodMustGreaterThanZero$str()

periodMustGreaterThanZero
```
public final IllegalArgumentException periodMustGreaterThanZero(Long newPeriod)
```
Specified by:

periodMustGreaterThanZero in interface ActiveMQMessageBundle

invalidNewPriority$str

protected String invalidNewPriority$str()

invalidNewPriority
```
public final IllegalArgumentException invalidNewPriority(Integer period)
```
Specified by:

invalidNewPriority in interface ActiveMQMessageBundle

noQueueFound$str
```
protected String noQueueFound$str()
```

noQueueFound

public final IllegalArgumentException noQueueFound(String otherQueueName)

Specified by:: noQueueFound in interface ActiveMQMessageBundle

invalidJournal$str
```
protected String invalidJournal$str()
```

invalidJournal
```
public final IllegalArgumentException invalidJournal()
```
Specified by:

invalidJournal in interface ActiveMQMessageBundle

invalidJournalType2$str

protected String invalidJournalType2$str()

invalidJournalType2

public final IllegalArgumentException invalidJournalType2(JournalType journalType)

Specified by:: invalidJournalType2 in interface ActiveMQMessageBundle

cannotCreateDir$str

protected String cannotCreateDir$str()

cannotCreateDir
```
public final IllegalArgumentException cannotCreateDir(String dir)
```
Specified by:

cannotCreateDir in interface ActiveMQMessageBundle

cannotConvertToInt$str

protected String cannotConvertToInt$str()

cannotConvertToInt
```
public final IllegalArgumentException cannotConvertToInt()
```
Specified by:

cannotConvertToInt in interface ActiveMQMessageBundle

routeNameIsNull$str

protected String routeNameIsNull$str()

routeNameIsNull
```
public final IllegalArgumentException routeNameIsNull()
```
Specified by:

routeNameIsNull in interface ActiveMQMessageBundle

clusterNameIsNull$str

protected String clusterNameIsNull$str()

clusterNameIsNull
```
public final IllegalArgumentException clusterNameIsNull()
```
Specified by:

clusterNameIsNull in interface ActiveMQMessageBundle

addressIsNull$str
```
protected String addressIsNull$str()
```

addressIsNull
```
public final IllegalArgumentException addressIsNull()
```
Specified by:

addressIsNull in interface ActiveMQMessageBundle

bindingTypeNotSpecified$str

protected String bindingTypeNotSpecified$str()

bindingTypeNotSpecified
```
public final IllegalArgumentException bindingTypeNotSpecified()
```
Specified by:

bindingTypeNotSpecified in interface ActiveMQMessageBundle

bindingIdNotSpecified$str

protected String bindingIdNotSpecified$str()

bindingIdNotSpecified
```
public final IllegalArgumentException bindingIdNotSpecified()
```
Specified by:

bindingIdNotSpecified in interface ActiveMQMessageBundle

distancenotSpecified$str

protected String distancenotSpecified$str()

distancenotSpecified
```
public final IllegalArgumentException distancenotSpecified()
```
Specified by:

distancenotSpecified in interface ActiveMQMessageBundle

connectionExists$str

protected String connectionExists$str()

connectionExists
```
public final IllegalArgumentException connectionExists(Object id)
```
Specified by:

connectionExists in interface ActiveMQMessageBundle

acceptorExists$str
```
protected String acceptorExists$str()
```

acceptorExists
```
public final IllegalArgumentException acceptorExists(Integer id)
```
Specified by:

acceptorExists in interface ActiveMQMessageBundle

acceptorNotExists$str

protected String acceptorNotExists$str()

acceptorNotExists
```
public final IllegalArgumentException acceptorNotExists(Integer id)
```
Specified by:

acceptorNotExists in interface ActiveMQMessageBundle

unknownProtocol$str

protected String unknownProtocol$str()

unknownProtocol

public final IllegalArgumentException unknownProtocol(String protocol)

Specified by:: unknownProtocol in interface ActiveMQMessageBundle

nodeIdNull$str
```
protected String nodeIdNull$str()
```

nodeIdNull
```
public final IllegalArgumentException nodeIdNull()
```
Specified by:

nodeIdNull in interface ActiveMQMessageBundle

queueNameIsNull$str

protected String queueNameIsNull$str()

queueNameIsNull
```
public final IllegalArgumentException queueNameIsNull()
```
Specified by:

queueNameIsNull in interface ActiveMQMessageBundle

cannotFindResource$str

protected String cannotFindResource$str()

cannotFindResource

public final IllegalArgumentException cannotFindResource(String resourceName)

Specified by:: cannotFindResource in interface ActiveMQMessageBundle

noGetterMethod$str
```
protected String noGetterMethod$str()
```

noGetterMethod

public final IllegalArgumentException noGetterMethod(String resourceName)

Specified by:: noGetterMethod in interface ActiveMQMessageBundle

noOperation$str
```
protected String noOperation$str()
```

noOperation

public final IllegalArgumentException noOperation(String operation,
                                                  Integer length)

Specified by:: noOperation in interface ActiveMQMessageBundle

nullMatch$str
```
protected String nullMatch$str()
```

nullMatch
```
public final IllegalArgumentException nullMatch()
```
Specified by:

nullMatch in interface ActiveMQMessageBundle

invalidMatch$str
```
protected String invalidMatch$str()
```

invalidMatch
```
public final IllegalArgumentException invalidMatch()
```
Specified by:

invalidMatch in interface ActiveMQMessageBundle

nullUser$str
```
protected String nullUser$str()
```

nullUser
```
public final IllegalArgumentException nullUser()
```
Specified by:

nullUser in interface ActiveMQMessageBundle

nullPassword$str
```
protected String nullPassword$str()
```

nullPassword
```
public final IllegalArgumentException nullPassword()
```
Specified by:

nullPassword in interface ActiveMQMessageBundle

errorCreatingTransformerClass$str

protected String errorCreatingTransformerClass$str()

errorCreatingTransformerClass

public final IllegalArgumentException errorCreatingTransformerClass(Exception e,
                                                                    String transformerClassName)

Specified by:: errorCreatingTransformerClass in interface ActiveMQMessageBundle

autoConvertError$str

protected String autoConvertError$str()

autoConvertError

public final IllegalArgumentException autoConvertError(Class<?> aClass)

Specified by:: autoConvertError in interface ActiveMQMessageBundle

destroyConnectionWithSessionMetadataHeader$str

protected String destroyConnectionWithSessionMetadataHeader$str()

destroyConnectionWithSessionMetadataHeader
```
public final String destroyConnectionWithSessionMetadataHeader(String key,
                                                               String value)
```
Description copied from interface: ActiveMQMessageBundle

Message used on on ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)

Specified by:

destroyConnectionWithSessionMetadataHeader in interface ActiveMQMessageBundle

destroyConnectionWithSessionMetadataClosingConnection$str

protected String destroyConnectionWithSessionMetadataClosingConnection$str()

destroyConnectionWithSessionMetadataClosingConnection
```
public final String destroyConnectionWithSessionMetadataClosingConnection(String serverSessionString)
```
Description copied from interface: ActiveMQMessageBundle

Message used on on ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)

Specified by:

destroyConnectionWithSessionMetadataClosingConnection in interface ActiveMQMessageBundle

destroyConnectionWithSessionMetadataSendException$str

protected String destroyConnectionWithSessionMetadataSendException$str()

destroyConnectionWithSessionMetadataSendException

public final ActiveMQDisconnectedException destroyConnectionWithSessionMetadataSendException(String key,
                                                                                             String value)

Description copied from interface: ActiveMQMessageBundle

Exception used on on ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)

Specified by:: destroyConnectionWithSessionMetadataSendException in interface ActiveMQMessageBundle

destroyConnectionWithSessionMetadataNoSessionFound$str

protected String destroyConnectionWithSessionMetadataNoSessionFound$str()

destroyConnectionWithSessionMetadataNoSessionFound
```
public final String destroyConnectionWithSessionMetadataNoSessionFound(String key,
                                                                       String value)
```
Description copied from interface: ActiveMQMessageBundle

Message used on on ActiveMQServerImpl.destroyConnectionWithSessionMetadata(String, String)

Specified by:

destroyConnectionWithSessionMetadataNoSessionFound in interface ActiveMQMessageBundle

invalidPageIO$str
```
protected String invalidPageIO$str()
```

invalidPageIO
```
public final ActiveMQIllegalStateException invalidPageIO()
```
Specified by:

invalidPageIO in interface ActiveMQMessageBundle

noDiscoveryGroupFound$str

protected String noDiscoveryGroupFound$str()

noDiscoveryGroupFound

public final ActiveMQException noDiscoveryGroupFound(DiscoveryGroupConfiguration dg)

Specified by:: noDiscoveryGroupFound in interface ActiveMQMessageBundle

queueSubscriptionBelongsToDifferentAddress$str

protected String queueSubscriptionBelongsToDifferentAddress$str()

queueSubscriptionBelongsToDifferentAddress

public final ActiveMQInvalidTransientQueueUseException queueSubscriptionBelongsToDifferentAddress(SimpleString queueName)

Specified by:: queueSubscriptionBelongsToDifferentAddress in interface ActiveMQMessageBundle

queueSubscriptionBelongsToDifferentFilter$str

protected String queueSubscriptionBelongsToDifferentFilter$str()

queueSubscriptionBelongsToDifferentFilter

public final ActiveMQInvalidTransientQueueUseException queueSubscriptionBelongsToDifferentFilter(SimpleString queueName)

Specified by:: queueSubscriptionBelongsToDifferentFilter in interface ActiveMQMessageBundle

unableToValidateClusterUser$str

protected String unableToValidateClusterUser$str()

unableToValidateClusterUser
```
public final ActiveMQClusterSecurityException unableToValidateClusterUser(String user)
```
Specified by:

unableToValidateClusterUser in interface ActiveMQMessageBundle

journalDirIsFile$str

protected String journalDirIsFile$str()

journalDirIsFile
```
public final IllegalStateException journalDirIsFile(File fDir)
```
Specified by:

journalDirIsFile in interface ActiveMQMessageBundle

couldNotMoveJournal$str

protected String couldNotMoveJournal$str()

couldNotMoveJournal
```
public final IllegalStateException couldNotMoveJournal(File dir)
```
Specified by:

couldNotMoveJournal in interface ActiveMQMessageBundle

addressIsFull$str
```
protected String addressIsFull$str()
```

addressIsFull

public final ActiveMQAddressFullException addressIsFull(String addressName)

Specified by:: addressIsFull in interface ActiveMQMessageBundle

noConfigurationFoundForScaleDown$str

protected String noConfigurationFoundForScaleDown$str()

noConfigurationFoundForScaleDown
```
public final ActiveMQException noConfigurationFoundForScaleDown()
```
Specified by:

noConfigurationFoundForScaleDown in interface ActiveMQMessageBundle

groupWhileStopping$str

protected String groupWhileStopping$str()

groupWhileStopping
```
public final ActiveMQException groupWhileStopping()
```
Specified by:

groupWhileStopping in interface ActiveMQMessageBundle

invalidSlowConsumerPolicyType$str

protected String invalidSlowConsumerPolicyType$str()

invalidSlowConsumerPolicyType
```
public final IllegalArgumentException invalidSlowConsumerPolicyType(String val)
```
Specified by:

invalidSlowConsumerPolicyType in interface ActiveMQMessageBundle

consumerConnectionsClosedByManagement$str

protected String consumerConnectionsClosedByManagement$str()

consumerConnectionsClosedByManagement
```
public final ActiveMQInternalErrorException consumerConnectionsClosedByManagement(String address)
```
Specified by:

consumerConnectionsClosedByManagement in interface ActiveMQMessageBundle

connectionsForUserClosedByManagement$str

protected String connectionsForUserClosedByManagement$str()

connectionsForUserClosedByManagement
```
public final ActiveMQInternalErrorException connectionsForUserClosedByManagement(String userName)
```
Specified by:

connectionsForUserClosedByManagement in interface ActiveMQMessageBundle

unsupportedHAPolicyConfiguration$str

protected String unsupportedHAPolicyConfiguration$str()

unsupportedHAPolicyConfiguration
```
public final ActiveMQIllegalStateException unsupportedHAPolicyConfiguration(Object o)
```
Specified by:

unsupportedHAPolicyConfiguration in interface ActiveMQMessageBundle

sessionLimitReached$str

protected String sessionLimitReached$str()

sessionLimitReached

public final ActiveMQSessionCreationException sessionLimitReached(String username,
                                                                  int limit)

Specified by:: sessionLimitReached in interface ActiveMQMessageBundle

queueLimitReached$str

protected String queueLimitReached$str()

queueLimitReached

public final ActiveMQSessionCreationException queueLimitReached(String username,
                                                                int limit)

Specified by:: queueLimitReached in interface ActiveMQMessageBundle

cannotSetMBeanserver$str

protected String cannotSetMBeanserver$str()

cannotSetMBeanserver
```
public final IllegalStateException cannotSetMBeanserver()
```
Specified by:

cannotSetMBeanserver in interface ActiveMQMessageBundle

invalidMessageLoadBalancingType$str

protected String invalidMessageLoadBalancingType$str()

invalidMessageLoadBalancingType
```
public final IllegalArgumentException invalidMessageLoadBalancingType(String val)
```
Specified by:

invalidMessageLoadBalancingType in interface ActiveMQMessageBundle

replicationSynchronizationTimeout$str

protected String replicationSynchronizationTimeout$str()

replicationSynchronizationTimeout
```
public final ActiveMQReplicationTimeooutException replicationSynchronizationTimeout(long timeout)
```
Specified by:

replicationSynchronizationTimeout in interface ActiveMQMessageBundle

liveBackupMismatch$str

protected String liveBackupMismatch$str()

liveBackupMismatch
```
public final ActiveMQIllegalStateException liveBackupMismatch()
```
Specified by:

liveBackupMismatch in interface ActiveMQMessageBundle

acceptorUnavailable$str

protected String acceptorUnavailable$str()

acceptorUnavailable
```
public final IllegalStateException acceptorUnavailable()
```
Specified by:

acceptorUnavailable in interface ActiveMQMessageBundle

replicatorIsNull$str

protected String replicatorIsNull$str()

replicatorIsNull
```
public final ActiveMQIllegalStateException replicatorIsNull()
```
Specified by:

replicatorIsNull in interface ActiveMQMessageBundle

methodNotApplicable$str

protected String methodNotApplicable$str()

methodNotApplicable
```
public final IllegalStateException methodNotApplicable()
```
Specified by:

methodNotApplicable in interface ActiveMQMessageBundle

diskBeyondLimit$str

protected String diskBeyondLimit$str()

diskBeyondLimit

public final ActiveMQIOErrorException diskBeyondLimit(String usableSpace,
                                                      String totalSpace,
                                                      String usage)

Specified by:: diskBeyondLimit in interface ActiveMQMessageBundle

connectionWithIDClosedByManagement$str

protected String connectionWithIDClosedByManagement$str()

connectionWithIDClosedByManagement
```
public final ActiveMQInternalErrorException connectionWithIDClosedByManagement(String ID)
```
Specified by:

connectionWithIDClosedByManagement in interface ActiveMQMessageBundle

maxConsumerLimitReachedForQueue$str

protected String maxConsumerLimitReachedForQueue$str()

maxConsumerLimitReachedForQueue

public final ActiveMQQueueMaxConsumerLimitReached maxConsumerLimitReachedForQueue(SimpleString address,
                                                                                  SimpleString queueName)

Specified by:: maxConsumerLimitReachedForQueue in interface ActiveMQMessageBundle

unexpectedRoutingTypeForAddress$str

protected String unexpectedRoutingTypeForAddress$str()

unexpectedRoutingTypeForAddress

public final ActiveMQUnexpectedRoutingTypeForAddress unexpectedRoutingTypeForAddress(SimpleString address,
                                                                                     RoutingType expectedRoutingType,
                                                                                     Set<RoutingType> supportedRoutingTypes)

Specified by:: unexpectedRoutingTypeForAddress in interface ActiveMQMessageBundle

invalidQueueConfiguration$str

protected String invalidQueueConfiguration$str()

invalidQueueConfiguration

public final ActiveMQInvalidQueueConfiguration invalidQueueConfiguration(SimpleString address,
                                                                         SimpleString queueName,
                                                                         String queuePropertyName,
                                                                         Object expectedValue,
                                                                         Object actualValue)

Specified by:: invalidQueueConfiguration in interface ActiveMQMessageBundle

addressDoesNotExist$str

protected String addressDoesNotExist$str()

addressDoesNotExist

public final ActiveMQAddressDoesNotExistException addressDoesNotExist(SimpleString address)

Specified by:: addressDoesNotExist in interface ActiveMQMessageBundle

addressAlreadyExists$str

protected String addressAlreadyExists$str()

addressAlreadyExists

public final ActiveMQAddressExistsException addressAlreadyExists(SimpleString address)

Specified by:: addressAlreadyExists in interface ActiveMQMessageBundle

addressHasBindings$str

protected String addressHasBindings$str()

addressHasBindings

public final ActiveMQDeleteAddressException addressHasBindings(SimpleString address)

Specified by:: addressHasBindings in interface ActiveMQMessageBundle

invalidMaxConsumers$str

protected String invalidMaxConsumers$str()

invalidMaxConsumers

public final IllegalArgumentException invalidMaxConsumers(String queueName,
                                                          int value)

Specified by:: invalidMaxConsumers in interface ActiveMQMessageBundle

invalidRoutingTypeForAddress$str

protected String invalidRoutingTypeForAddress$str()

invalidRoutingTypeForAddress

public final IllegalArgumentException invalidRoutingTypeForAddress(RoutingType routingType,
                                                                   String address,
                                                                   Set<RoutingType> supportedRoutingTypes)

Specified by:: invalidRoutingTypeForAddress in interface ActiveMQMessageBundle

invalidRoutingType$str

protected String invalidRoutingType$str()

invalidRoutingType
```
public final IllegalArgumentException invalidRoutingType(String val)
```
Specified by:

invalidRoutingType in interface ActiveMQMessageBundle

invalidRoutingTypeDelete$str

protected String invalidRoutingTypeDelete$str()

invalidRoutingTypeDelete

public final IllegalStateException invalidRoutingTypeDelete(RoutingType routingType,
                                                            String address)

Specified by:: invalidRoutingTypeDelete in interface ActiveMQMessageBundle

invalidMaxConsumersUpdate$str

protected String invalidMaxConsumersUpdate$str()

invalidMaxConsumersUpdate

public final IllegalStateException invalidMaxConsumersUpdate(String queueName,
                                                             int maxConsumers,
                                                             int consumers)

Specified by:: invalidMaxConsumersUpdate in interface ActiveMQMessageBundle

invalidRoutingTypeUpdate$str

protected String invalidRoutingTypeUpdate$str()

invalidRoutingTypeUpdate

public final IllegalStateException invalidRoutingTypeUpdate(String queueName,
                                                            RoutingType routingType,
                                                            String address,
                                                            Set<RoutingType> supportedRoutingTypes)

Specified by:: invalidRoutingTypeUpdate in interface ActiveMQMessageBundle

invalidDeletionPolicyType$str

protected String invalidDeletionPolicyType$str()

invalidDeletionPolicyType
```
public final IllegalArgumentException invalidDeletionPolicyType(String val)
```
Specified by:

invalidDeletionPolicyType in interface ActiveMQMessageBundle

userNoPermissionsQueue$str

protected String userNoPermissionsQueue$str()

userNoPermissionsQueue

public final ActiveMQSecurityException userNoPermissionsQueue(String username,
                                                              CheckType checkType,
                                                              SimpleString queue,
                                                              SimpleString address)

Specified by:: userNoPermissionsQueue in interface ActiveMQMessageBundle

notPercentOrMinusOne$str

protected String notPercentOrMinusOne$str()

notPercentOrMinusOne

public final IllegalArgumentException notPercentOrMinusOne(String name,
                                                           Number val)

Specified by:: notPercentOrMinusOne in interface ActiveMQMessageBundle

cannotDeleteQueueWithMessages$str

protected String cannotDeleteQueueWithMessages$str()

cannotDeleteQueueWithMessages

public final ActiveMQIllegalStateException cannotDeleteQueueWithMessages(SimpleString name,
                                                                         SimpleString queueName,
                                                                         long messageCount)

Specified by:: cannotDeleteQueueWithMessages in interface ActiveMQMessageBundle

invalidQueueName$str

protected String invalidQueueName$str()

invalidQueueName

public final ActiveMQIllegalStateException invalidQueueName(SimpleString queueName)

Specified by:: invalidQueueName in interface ActiveMQMessageBundle

cannotWriteToClosedFile$str

protected String cannotWriteToClosedFile$str()

cannotWriteToClosedFile
```
public final ActiveMQIOErrorException cannotWriteToClosedFile(SequentialFile file)
```
Specified by:

cannotWriteToClosedFile in interface ActiveMQMessageBundle

failedToLocateConfigURL$str

protected String failedToLocateConfigURL$str()

failedToLocateConfigURL
```
public final ActiveMQIllegalStateException failedToLocateConfigURL()
```
Specified by:

failedToLocateConfigURL in interface ActiveMQMessageBundle

failedToLoadSecurityConfig$str

protected String failedToLoadSecurityConfig$str()

failedToLoadSecurityConfig
```
public final ActiveMQIllegalStateException failedToLoadSecurityConfig()
```
Specified by:

failedToLoadSecurityConfig in interface ActiveMQMessageBundle

failedToLoadUserFile$str

protected String failedToLoadUserFile$str()

failedToLoadUserFile
```
public final ActiveMQIllegalStateException failedToLoadUserFile(String path)
```
Specified by:

failedToLoadUserFile in interface ActiveMQMessageBundle

failedToLoadRoleFile$str

protected String failedToLoadRoleFile$str()

failedToLoadRoleFile
```
public final ActiveMQIllegalStateException failedToLoadRoleFile(String path)
```
Specified by:

failedToLoadRoleFile in interface ActiveMQMessageBundle

failedToFindLoginModuleEntry$str

protected String failedToFindLoginModuleEntry$str()

failedToFindLoginModuleEntry
```
public final ActiveMQIllegalStateException failedToFindLoginModuleEntry(String entry)
```
Specified by:

failedToFindLoginModuleEntry in interface ActiveMQMessageBundle

userAlreadyExists$str

protected String userAlreadyExists$str()

userAlreadyExists
```
public final IllegalArgumentException userAlreadyExists(String user)
```
Specified by:

userAlreadyExists in interface ActiveMQMessageBundle

userDoesNotExist$str

protected String userDoesNotExist$str()

userDoesNotExist
```
public final IllegalArgumentException userDoesNotExist(String user)
```
Specified by:

userDoesNotExist in interface ActiveMQMessageBundle

rejectEmptyValidatedUser$str

protected String rejectEmptyValidatedUser$str()

rejectEmptyValidatedUser
```
public final ActiveMQIllegalStateException rejectEmptyValidatedUser()
```
Specified by:

rejectEmptyValidatedUser in interface ActiveMQMessageBundle

inRangeOfPositiveInt$str

protected String inRangeOfPositiveInt$str()

inRangeOfPositiveInt

public final IllegalArgumentException inRangeOfPositiveInt(String name,
                                                           Number val)

Specified by:: inRangeOfPositiveInt in interface ActiveMQMessageBundle

inRangeOfPositiveIntThanMinusOne$str

protected String inRangeOfPositiveIntThanMinusOne$str()

inRangeOfPositiveIntThanMinusOne

public final IllegalArgumentException inRangeOfPositiveIntThanMinusOne(String name,
                                                                       Number val)

Specified by:: inRangeOfPositiveIntThanMinusOne in interface ActiveMQMessageBundle

lessThanOrEqualToOne$str

protected String lessThanOrEqualToOne$str()

lessThanOrEqualToOne

public final IllegalArgumentException lessThanOrEqualToOne(String name,
                                                           Number val)

Specified by:: lessThanOrEqualToOne in interface ActiveMQMessageBundle

failedToParseJson$str

protected String failedToParseJson$str()

failedToParseJson
```
public final IllegalArgumentException failedToParseJson(String json)
```
Specified by:

failedToParseJson in interface ActiveMQMessageBundle

failedToBind$str
```
protected String failedToBind$str()
```

failedToBind

public final IllegalStateException failedToBind(String acceptor,
                                                String hostPort,
                                                Exception e)

Specified by:: failedToBind in interface ActiveMQMessageBundle

divertDoesNotExist$str

protected String divertDoesNotExist$str()

divertDoesNotExist

public final ActiveMQDivertDoesNotExistException divertDoesNotExist(String divert)

Specified by:: divertDoesNotExist in interface ActiveMQMessageBundle

cannotCreateConsumerOnClosedSession$str

protected String cannotCreateConsumerOnClosedSession$str()

cannotCreateConsumerOnClosedSession
```
public final ActiveMQIllegalStateException cannotCreateConsumerOnClosedSession(SimpleString queueName)
```
Specified by:

cannotCreateConsumerOnClosedSession in interface ActiveMQMessageBundle

cannotSetSecurityManager$str

protected String cannotSetSecurityManager$str()

cannotSetSecurityManager
```
public final IllegalStateException cannotSetSecurityManager()
```
Specified by:

cannotSetSecurityManager in interface ActiveMQMessageBundle

Class ActiveMQMessageBundle_$bundle

Field Summary

Fields inherited from interface org.apache.activemq.artemis.core.server.ActiveMQMessageBundle

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INSTANCE

Constructor Detail

ActiveMQMessageBundle_$bundle

Method Detail

readResolve

getLoggingLocale

activationForServer$str

activationForServer

generatingThreadDump$str

generatingThreadDump

threadDump$str

threadDump

endThreadDump$str

endThreadDump

serverDescribe$str

serverDescribe

connectionsClosedByManagement$str

connectionsClosedByManagement

notJournalImpl$str

notJournalImpl

replicationUnhandledError$str

replicationUnhandledError

replicationTooManyJournals$str

replicationTooManyJournals

replicationUnhandledFileType$str

replicationUnhandledFileType

replicationBackupUpToDate$str

replicationBackupUpToDate

replicationUnhandledDataType$str

replicationUnhandledDataType

noBindingForDivert$str

noBindingForDivert

bindingNotDivert$str

bindingNotDivert

clientExited$str

clientExited

divertWithNoName$str

divertWithNoName

noSuchQueue$str

noSuchQueue

bindingAlreadyExists$str

bindingAlreadyExists

queueAlreadyExists$str

queueAlreadyExists

invalidFilter$str

invalidFilter

messageIdNotAssigned$str

messageIdNotAssigned

journalsNotInSync$str

journalsNotInSync

serverNotBackupServer$str

serverNotBackupServer

alreadyHaveReplicationServer$str

alreadyHaveReplicationServer

cannotDeleteQueueWithConsumers$str

cannotDeleteQueueWithConsumers

backupServerNotInSync$str

backupServerNotInSync

consumerNoReference$str

consumerNoReference

consumerDoesntExist$str

consumerDoesntExist

noAddress$str

noAddress

largeMessageNotInitialised$str

largeMessageNotInitialised

unableToValidateUser$str

unableToValidateUser

userNoPermissions$str

userNoPermissions

incompatibleClientServer$str

incompatibleClientServer

serverNotStarted$str