Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
org.mule.api.MuleException

Packages that use MuleException
org.mule | The Mule implementation of the Universal Message Objects(tm) API specification.
org.mule.agent | Admin components and Agents used to control and Monitor Mule
org.mule.api | The Universal Message Object(tm) API provides a way for components to interact without needing to know about the protocol or delivery mechanisms of information passed between them
org.mule.api.client |
org.mule.api.component |
org.mule.api.config |
org.mule.api.construct |
org.mule.api.context | Mule Context APIs, including the MuleContext, agent and server event interfaces
org.mule.api.endpoint | Endpoint interfaces.
org.mule.api.interceptor |
org.mule.api.lifecycle | Lifecycle interfaces for all Components.
org.mule.api.model | Contains the interfaces for the Model and supporting objects such as the CompoenntResolver, EntryPointResolver, etc.
org.mule.api.processor |
org.mule.api.processor.policy |
org.mule.api.registry |
org.mule.api.routing | Interfaces that define inbound and outbound routing API.
org.mule.api.routing.filter |
org.mule.api.security | Security API for authentication and authorisation.
org.mule.api.service |
org.mule.api.source |
org.mule.api.store |
org.mule.api.transaction |
org.mule.api.transformer | Contains the interfaces for transformers and exceptions for the Transformer API.
org.mule.api.transformer.wire |
org.mule.api.transport | Contains the interfaces that comprise a provider implementation.
org.mule.client |
org.mule.component |
org.mule.config | Providers Mule Xml configuration support and general configuration classes.
org.mule.config.dsl.routers |
org.mule.config.endpoint |
org.mule.config.processors |
org.mule.config.spring.factories |
org.mule.construct |
org.mule.construct.builder |
org.mule.construct.processor |
org.mule.context.notification | Internal server notification types fired via the MuleManager.
org.mule.endpoint | Implemtation of Mule endpoint uris.
org.mule.endpoint.dynamic |
org.mule.endpoint.inbound |
org.mule.endpoint.outbound |
org.mule.enricher |
org.mule.example.errorhandler |
org.mule.example.errorhandler.exceptions |
org.mule.example.loanbroker |
org.mule.example.notifications |
org.mule.exception |
org.mule.interceptor |
org.mule.lifecycle |
org.mule.lifecycle.processor |
org.mule.model |
org.mule.model.resolvers |
org.mule.model.seda |
org.mule.module.atom |
org.mule.module.atom.endpoint |
org.mule.module.atom.routing |
org.mule.module.bpm |
org.mule.module.client | Simple interface for Mule clients to send and receive events from local or remote Mule Servers.
org.mule.module.client.remoting |
org.mule.module.cxf |
org.mule.module.cxf.builder |
org.mule.module.cxf.config |
org.mule.module.cxf.security |
org.mule.module.cxf.transport |
org.mule.module.guice |
org.mule.module.ibeans.config |
org.mule.module.ibeans.spi.support |
org.mule.module.jca | A Resource Adapter implementation that allows a Mule instance to be deployed to a J2ee application server and exposes Mule services via the JCA connector architecture.
org.mule.module.management | Mule system management extensions such as Jmx support.
org.mule.module.management.agent | Management agents including agents for Jdmk, MX4J, and Log4J
org.mule.module.management.mbean | Jmx Management beans for mule components, the model and the Mule server.
org.mule.module.rss.endpoint |
org.mule.module.rss.routing |
org.mule.module.scripting.builders |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.spring.events | A Spring EventMulticaster that allows any Spring bean to send and receive mule events through the ApplicationContext and event listeners.
org.mule.module.sxc |
org.mule.module.ws.construct |
org.mule.module.ws.construct.builder |
org.mule.processor |
org.mule.processor.chain |
org.mule.registry |
org.mule.retry |
org.mule.routing | Defines the core routing patterns supported by mule.
org.mule.routing.correlation |
org.mule.routing.outbound | Outbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.requestreply |
org.mule.security | Core security implementation including the mule security manager and encryption types
org.mule.service |
org.mule.service.processor |
org.mule.session |
org.mule.source |
org.mule.tck |
org.mule.tck.exceptions |
org.mule.transaction | Contains the core transaction support classes and exception types.
org.mule.transformer | Provides the default transformer base implementations for Mule including compression and encryption support.
org.mule.transformer.wire |
org.mule.transport | Contains Abstract classes providing common functionality for all Mule providers.
org.mule.transport.ajax |
org.mule.transport.ajax.container | A AJAX transport allows Mule applications to send a receive events to the web browser.
org.mule.transport.ajax.embedded | A AJAX transport allows Mule applications to send a receive events to the web browser.
org.mule.transport.ejb |
org.mule.transport.email | Provides pop3, smtp and imap connectivity for Mule.
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers.
org.mule.transport.ftp |
org.mule.transport.http | Provides http transport including proxy support.
org.mule.transport.http.components |
org.mule.transport.ibean |
org.mule.transport.jdbc | Provides jdbc transport.
org.mule.transport.jms | Provides Jms transport connectivity with support for all Jms features.
org.mule.transport.jms.redelivery |
org.mule.transport.polling |
org.mule.transport.quartz |
org.mule.transport.quartz.config |
org.mule.transport.quartz.jobs |
org.mule.transport.rmi |
org.mule.transport.service | Provides SPI support for building mule connectors and providers using service descriptors.
org.mule.transport.servlet |
org.mule.transport.servlet.jetty |
org.mule.transport.soap.axis | Provides an Axis soap transport for Mule.
org.mule.transport.soap.axis.extensions | Axis specific extensions and component implementation that enables Mule components to act as Axis soap services.
org.mule.transport.soap.axis.wsdl |
org.mule.transport.stdio |
org.mule.transport.tcp | Provides tcp connectivity for Mule.
org.mule.transport.udp | Provides Udp connectivity for Mule.
org.mule.transport.vm | A connector implementation allowing events to be passed between Mule sessions via in-memory queues.
org.mule.transport.xmpp |
org.mule.util.pool |
org.mule.util.xa | An abstract resource manager that supports local and xa transactions.
org.mule.work | A javax.resource.spi.WorkManager implementation.

Uses of MuleException in org.mule

Methods in org.mule that throw MuleException
`protected void` | `DefaultMuleMessage.applyAllTransformers(MuleEvent event, List<? extends Transformer> transformers)`
`void` | `DefaultMuleMessage.applyTransformers(MuleEvent event, List<? extends Transformer> transformers)` Will apply a list of transformers to the payload of the message.
`void` | `DefaultMuleMessage.applyTransformers(MuleEvent event, List<? extends Transformer> transformers, Class<?> outputType)`
`void` | `DefaultMuleMessage.applyTransformers(MuleEvent event, Transformer... transformers)` Will apply a list of transformers to the payload of the message.
`void` | `DefaultMuleEventContext.dispatchEvent(MuleMessage message)` This will dispatch an event asynchronously via the configured outbound endpoint on the service for this session
`void` | `DefaultMuleEventContext.dispatchEvent(MuleMessage message, EndpointURI endpointUri)` Depending on the session state this methods either Passes an event asynchronously to the next available Mule component in the pool or via the endpointUri configured for the event
`void` | `DefaultMuleEventContext.dispatchEvent(MuleMessage message, OutboundEndpoint endpoint)` Depending on the session state this methods either Passes an event asynchronously to the next available Mule component in the pool or via the endpoint configured for the event
`void` | `DefaultMuleEventContext.dispatchEvent(MuleMessage message, String endpointName)` Depending on the session state this methods either Passes an event asynchronously to the next available Mule component in the pool or via the endpoint configured for the event
`void` | `DefaultMuleEventContext.dispatchEvent(Object message)` This will dispatch an event asynchronously via the configured outbound endpoint on the service for this session
`byte[]` | `DefaultMuleEventContext.getMessageAsBytes()` Reterns the conents of the message as a byte array.
`String` | `DefaultMuleEventContext.getMessageAsString()` Returns the message contents as a string This method will use the default encoding on the event
`String` | `DefaultMuleEvent.getMessageAsString()`
`String` | `DefaultMuleEventContext.getMessageAsString(String encoding)` Returns the message contents as a string
`String` | `DefaultMuleEvent.getMessageAsString(String encoding)` Returns the message contents for logging
`void` | `DefaultMuleMessage.initAfterDeserialisation(MuleContext muleContext)` Invoked after deserialization.
`MuleMessage` | `DefaultMuleEventContext.requestEvent(EndpointURI endpointUri, long timeout)` Requests a synchronous receive of an event on the service
`MuleMessage` | `DefaultMuleEventContext.requestEvent(InboundEndpoint endpoint, long timeout)` Requests a synchronous receive of an event on the service
`MuleMessage` | `DefaultMuleEventContext.requestEvent(String endpointName, long timeout)` Requests a synchronous receive of an event on the service
`MuleMessage` | `DefaultMuleEventContext.sendEvent(MuleMessage message)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpoint configured for the event
`MuleMessage` | `DefaultMuleEventContext.sendEvent(MuleMessage message, EndpointURI endpointUri)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpointUri configured for the event
`MuleMessage` | `DefaultMuleEventContext.sendEvent(MuleMessage message, OutboundEndpoint endpoint)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpoint configured for the event
`MuleMessage` | `DefaultMuleEventContext.sendEvent(MuleMessage message, String endpointName)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpoint configured for the event
`MuleMessage` | `DefaultMuleEventContext.sendEvent(Object message)` This will send an event via the configured outbound router on the service
`FutureMessageResult` | `DefaultMuleEventContext.sendEventAsync(MuleMessage message, EndpointURI endpointUri, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `DefaultMuleEventContext.sendEventAsync(MuleMessage message, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `DefaultMuleEventContext.sendEventAsync(MuleMessage message, String endpointName, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `DefaultMuleEventContext.sendEventAsync(Object message, int timeout)` sends an event request via the configured outbound router for this service.
`void` | `RouteableExceptionStrategy.start()`
`void` | `DefaultMuleContext.start()`
`void` | `RouteableExceptionStrategy.stop()`
`void` | `DefaultMuleContext.stop()` Stops the `MuleContext` which stops all sessions and connectors

Uses of MuleException in org.mule.agent

Methods in org.mule.agent that throw MuleException
`void` | `AbstractNotificationLoggerAgent.start()`
`void` | `AbstractNotificationLoggerAgent.stop()`

Uses of MuleException in org.mule.api

Subclasses of MuleException in org.mule.api
`class` | `AnnotationException` Root exception for errors related to annotation parsing
`class` | `DefaultMuleException` `MuleException` Is the base exception type for the Mule application any other exceptions thrown by Mule code will be based on this exception.
`class` | `MessagingException` `MessagingException` is a general message exception thrown when errors specific to Message processing occur..

Methods in org.mule.api that throw MuleException
`void` | `MuleMessage.applyTransformers(MuleEvent event, List<? extends Transformer> transformers)` Will apply a list of transformers to the payload of the message.
`void` | `MuleMessage.applyTransformers(MuleEvent event, List<? extends Transformer> transformers, Class<?> outputType)` Will apply a list of transformers to the payload of the message.
`void` | `MuleMessage.applyTransformers(MuleEvent event, Transformer... transformers)` Will apply a list of transformers to the payload of the message.
`void` | `MuleEventContext.dispatchEvent(MuleMessage message)` Deprecated.
`void` | `MuleEventContext.dispatchEvent(MuleMessage message, EndpointURI endpoint)` Deprecated.
`void` | `MuleEventContext.dispatchEvent(MuleMessage message, OutboundEndpoint endpoint)` Depending on the session state this methods either Passes an event asynchronously to the next available Mule component in the pool or via the endpoint configured for the event
`void` | `MuleEventContext.dispatchEvent(MuleMessage message, String endpointName)` Depending on the session state this methods either Passes an event asynchronously to the next available Mule component in the pool or via the endpoint configured for the event.
`void` | `MuleEventContext.dispatchEvent(Object payload)` Deprecated.
`MuleMessage` | `FutureMessageResult.getMessage()`
`MuleMessage` | `FutureMessageResult.getMessage(long timeout)`
`byte[]` | `MuleEventContext.getMessageAsBytes()` Returns the contents of the message as a byte array.
`byte[]` | `MuleEvent.getMessageAsBytes()` Returns the contents of the message as a byte array.
`String` | `MuleEventContext.getMessageAsString()` Returns the message contents as a string This method will use the encoding set on the event
`String` | `MuleEvent.getMessageAsString()` Returns the message contents as a string If necessary this will use the encoding set on the event
`String` | `MuleEventContext.getMessageAsString(String encoding)` Returns the message contents as a string
`String` | `MuleEvent.getMessageAsString(String encoding)` Returns the message contents as a string
`InboundEndpoint` | `EndpointAnnotationParser.parseInboundEndpoint(Annotation annotation, Map metaInfo)` Creates an inbound endpoint from the annotation.
`MessageProcessor` | `MessageProcessorAnnotationParser.parseMessageProcessor(Annotation annotation)` Will create a Mule Router according to the annotation.
`OutboundEndpoint` | `EndpointAnnotationParser.parseOutboundEndpoint(Annotation annotation, Map metaInfo)` Creates an outbound endpoint from the annotation.
`MuleMessage` | `MuleEventContext.requestEvent(EndpointURI endpoint, long timeout)` Deprecated.
`MuleMessage` | `MuleEventContext.requestEvent(InboundEndpoint endpoint, long timeout)` Requests a synchronous receive of an event on the service.
`MuleMessage` | `MuleEventContext.requestEvent(String endpointName, long timeout)` Requests a synchronous receive of an event on the service.
`MuleMessage` | `MuleEventContext.sendEvent(MuleMessage message)` Deprecated.
`MuleMessage` | `MuleEventContext.sendEvent(MuleMessage message, EndpointURI endpoint)` Deprecated.
`MuleMessage` | `MuleEventContext.sendEvent(MuleMessage message, OutboundEndpoint endpoint)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpoint configured for the event
`MuleMessage` | `MuleEventContext.sendEvent(MuleMessage message, String endpointName)` Depending on the session state this methods either Passes an event synchronously to the next available Mule component in the pool or via the endpoint configured for the event
`MuleMessage` | `MuleEventContext.sendEvent(Object message)` Deprecated.
`FutureMessageResult` | `MuleEventContext.sendEventAsync(MuleMessage message, EndpointURI endpoint, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `MuleEventContext.sendEventAsync(MuleMessage message, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `MuleEventContext.sendEventAsync(MuleMessage message, String endpointName, int timeout)` sends an event request via the configured outbound router for this service.
`FutureMessageResult` | `MuleEventContext.sendEventAsync(Object message, int timeout)` sends an event request via the configured outbound router for this service.

Uses of MuleException in org.mule.api.client

Methods in org.mule.api.client that throw MuleException
`void` | `MuleClient.dispatch(String url, MuleMessage message)` Dispatches an event asynchronously to a endpointUri via a Mule server.
`void` | `MuleClient.dispatch(String url, Object payload, Map<String,Object> messageProperties)` Dispatches an event asynchronously to a endpointUri via a Mule server.
`MuleMessage` | `LocalMuleClient.process(OutboundEndpoint endpoint, MuleMessage message)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `LocalMuleClient.process(OutboundEndpoint endpoint, Object payload, Map<String,Object> messageProperties)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.process(String uri, MessageExchangePattern mep, MuleMessage message)` Processes a messsage with an outbound endpoint using the specified `MessageExchangePattern`
`MuleMessage` | `MuleClient.process(String uri, MessageExchangePattern mep, Object payload, Map<String,Object> messageProperties)` Processes a message with an outbound endpoint using the specified `MessageExchangePattern`
`MuleMessage` | `LocalMuleClient.request(InboundEndpoint endpoint, long timeout)` Will receive an event from an endpointUri determined by the URL.
`MuleMessage` | `MuleClient.request(String url, long timeout)` Will receive an event from an endpointUri determined by the URL.
`MuleMessage` | `MuleClient.send(String url, MuleMessage message)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, MuleMessage message, long timeout)` Sends an event synchronously to a endpointUri via a mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, Object payload, Map<String,Object> messageProperties)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, Object payload, Map<String,Object> messageProperties, long timeout)` Sends an event synchronously to a endpointUri via a mule server and a resulting message is returned.

Uses of MuleException in org.mule.api.component

Methods in org.mule.api.component that throw MuleException
`LifecycleAdapter` | `LifecycleAdapterFactory.create(Object pojoService, JavaComponent component, FlowConstruct flowConstruct, EntryPointResolverSet resolver, MuleContext muleContext)`
`Object` | `LifecycleAdapter.invoke(MuleEvent message)`
`MuleEvent` | `InterfaceBinding.process(MuleEvent event)` This method is responsible for routing the Message via the MuleSession.
`void` | `InterfaceBinding.setEndpoint(ImmutableEndpoint endpoint)`

Uses of MuleException in org.mule.api.config

Subclasses of MuleException in org.mule.api.config
`class` | `ConfigurationException`

Uses of MuleException in org.mule.api.construct

Subclasses of MuleException in org.mule.api.construct
`class` | `FlowConstructInvalidException`

Uses of MuleException in org.mule.api.context

Subclasses of MuleException in org.mule.api.context
`class` | `MuleContextException` `MuleContextException` is thrown when an exception occurs with Mule Context objects

Methods in org.mule.api.context that throw MuleException
`WorkManager` | `WorkManagerSource.getWorkManager()`

Uses of MuleException in org.mule.api.endpoint

Subclasses of MuleException in org.mule.api.endpoint
`class` | `EndpointException` `EndpointException` is an abstract exception extended by endpoint specific exceptions.
`class` | `EndpointNotFoundException` `EndpointNotFoundException` is thrown when an endpoint name or protocol is specified but a matching endpoint is not registered with the Mule server
`class` | `MalformedEndpointException` `MalformedEndpointException` is thrown by the MuleEndpointURI class if it fails to parse a Url

Methods in org.mule.api.endpoint that throw MuleException
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`EndpointBuilder` | `EndpointFactory.getEndpointBuilder(String uri)` Used to retrieve the an EndpointBuilder equal to the one would be used to create an endpoint. This is useful if you need to customize a builder before creation of an endpoint as you can use this method to obtain the endpoint builder, custommize it and then call the factory methods that take a EndpointBuilder rather than a String.
`InboundEndpoint` | `EndpointFactory.getInboundEndpoint(EndpointBuilder builder)` Creates an endpoint with the "INBOUND" role using the builder provided.
`InboundEndpoint` | `EndpointFactory.getInboundEndpoint(EndpointURI endpointUri)` Deprecated.
`InboundEndpoint` | `EndpointFactory.getInboundEndpoint(String uri)` Creates an endpoint with the "INBOUND" role.
`OutboundEndpoint` | `EndpointFactory.getOutboundEndpoint(EndpointBuilder builder)` Creates an endpoint with the "OUTBOUND" role using the builder provided.
`OutboundEndpoint` | `EndpointFactory.getOutboundEndpoint(EndpointURI endpointUri)` Deprecated.
`OutboundEndpoint` | `EndpointFactory.getOutboundEndpoint(String uri)` Creates an endpoint with the "OUTBOUND" role.

Uses of MuleException in org.mule.api.interceptor

Methods in org.mule.api.interceptor that throw MuleException
`MuleEvent` | `Interceptor.process(MuleEvent event)` Invoked when the component should be called.

Uses of MuleException in org.mule.api.lifecycle

Subclasses of MuleException in org.mule.api.lifecycle
`class` | `CreateException` `CreateException` is thrown when creating an object inside Mule wasn't possible due to inconsistent internal state or wrong input.
`class` | `DisposeException` `DisposeException` TODO (document class)
`class` | `InitialisationException` `InitialisationException` is thrown by the initialise method defined in the `org.mule.api.lifecycle.Initialisable` interface.
`class` | `LifecycleException` `LifecycleException` TODO
`class` | `RecoverableException` `RecoverableException` can be thrown during initialisation to indicate that the error occurred is not fatal and a reactive action can be performed to try and remedy the error.
`class` | `StartException` `DisposeException` TODO (document class)
`class` | `StopException` `DisposeException` TODO (document class)

Methods in org.mule.api.lifecycle that throw MuleException
`void` | `LifecycleCallback.onTransition(String phaseName, O object)`
`void` | `Startable.start()`
`void` | `Stoppable.stop()`

Uses of MuleException in org.mule.api.model

Subclasses of MuleException in org.mule.api.model
`class` | `SessionException` `SessionException` is thrown when errors occur in the DefaultMuleSession or Seession Manager

Uses of MuleException in org.mule.api.processor

Methods in org.mule.api.processor that throw MuleException
`void` | `MessageRouter.addRoute(MessageProcessor processor)` Adds a new message processor to the list of routes
`MessageProcessorChain` | `MessageProcessorChainBuilder.build()`
`MessageProcessor` | `MessageProcessorBuilder.build()`
`MuleEvent` | `MessageProcessor.process(MuleEvent event)` Invokes the MessageProcessor.
`MuleEvent` | `LoggerMessageProcessor.process(MuleEvent event)`
`void` | `MessageRouter.removeRoute(MessageProcessor processor)` Removes a message processor from the list of routes

Uses of MuleException in org.mule.api.processor.policy

Methods in org.mule.api.processor.policy that throw MuleException
`MuleEvent` | `TimingPolicy.invoke(PolicyInvocation invocation)`
`MuleEvent` | `AroundPolicy.invoke(PolicyInvocation invocation)`
`MuleEvent` | `PolicyInvocation.proceed()` Proceed using the current event.

Uses of MuleException in org.mule.api.registry

Subclasses of MuleException in org.mule.api.registry
`class` | `RegistrationException`
`class` | `ResolverException` An exception that is thrown by resolver classes responsible for finding objects in the registry based on particular criteria
`class` | `ServiceException` Any service-related exception: service not found, service lookup error, etc.

Methods in org.mule.api.registry that throw MuleException
`Object` | `MuleRegistry.applyLifecycle(Object object)` Will execute any lifecycle phases on an object without actually registering the object in the registry.
`Object` | `MuleRegistry.applyLifecycle(Object object, String phase)`
`Object` | `MuleRegistry.applyProcessors(Object object)` Will execute any processors on an object without actually registering the object in the registry.
`Object` | `MuleRegistry.applyProcessors(Object object, int flags)` Will execute any processors on an object without actually registering the object in the registry.
`Object` | `MuleRegistry.applyProcessorsAndLifecycle(Object object)` Will execute any processors on an object and fire any lifecycle methods according to the current lifecycle without actually registering the object in the registry.
`void` | `MuleRegistry.registerAgent(Agent agent)`
`void` | `MuleRegistry.registerConnector(Connector connector)`
`void` | `MuleRegistry.registerEndpoint(ImmutableEndpoint endpoint)`
`void` | `MuleRegistry.registerEndpointBuilder(String name, EndpointBuilder builder)`
`void` | `MuleRegistry.registerFlowConstruct(FlowConstruct flowConstruct)`
`void` | `MuleRegistry.registerModel(Model model)`
`void` | `MuleRegistry.registerService(Service service)`
`void` | `MuleRegistry.registerTransformer(Transformer transformer)`
`void` | `MuleRegistry.unregisterAgent(String agentName)`
`void` | `MuleRegistry.unregisterConnector(String connectorName)`
`void` | `MuleRegistry.unregisterEndpoint(String endpointName)`
`void` | `MuleRegistry.unregisterFlowConstruct(String flowConstructName)`
`void` | `MuleRegistry.unregisterModel(String modelName)`
`void` | `MuleRegistry.unregisterService(String serviceName)`
`void` | `MuleRegistry.unregisterTransformer(String transformerName)`

Uses of MuleException in org.mule.api.routing

Subclasses of MuleException in org.mule.api.routing
`class` | `CouldNotRouteOutboundMessageException` `CouldNotRouteOutboundMessageException` thrown if Mule fails to route the current outbound event.
`class` | `ResponseTimeoutException` `ResponseTimeoutException` is thrown when a response is not received in a given timeout in the Response Router.
`class` | `RoutePathNotFoundException` `RoutePathNotFoundException` is thrown if a routing path for an event cannot be found.
`class` | `RoutingException` `RoutingException` is a base class for all routing exceptions.

Methods in org.mule.api.routing that throw MuleException
`boolean` | `Matchable.isMatch(MuleMessage message)` Determines if the event should be processed

Uses of MuleException in org.mule.api.routing.filter

Subclasses of MuleException in org.mule.api.routing.filter
`class` | `FilterUnacceptedException`

Uses of MuleException in org.mule.api.security

Subclasses of MuleException in org.mule.api.security
`class` | `CredentialsNotSetException` `CredentialsNotSetException` is thrown when user credentials cannot be obtained from the current message
`class` | `CryptoFailureException` `CryptoFailureException` is a generic exception thrown by an CryptoStrategy if encryption or decryption fails.
`class` | `EncryptionNotSupportedException` `EncryptionNotSupportedException` is thrown if an algorithm is set in the MULE_USER header but it doesn't match the algorithm set on the security filter
`class` | `EncryptionStrategyNotFoundException` `EncryptionStrategyNotFoundException` is thrown by the SecurityManager when an encryption scheme is set in a property or header that has not been registered witrh the manager
`class` | `SecurityException` `SecurityException` is a generic security exception
`class` | `SecurityProviderNotFoundException` `SecurityProviderNotFoundException` is thrown by the SecurityManager when an authentication request is made but no suitable security provider can be found to process the authentication
`class` | `UnauthorisedException` `UnauthorisedException` is thrown if authentication fails
`class` | `UnknownAuthenticationTypeException` `UnknownAuthenticationTypeException` is thrown if a security context request is make with an unrecognised Authentication type.
`class` | `UnsupportedAuthenticationSchemeException` `UnsupportedAuthenticationSchemeException` is thrown when a authentication scheme is being used on the message that the Security filter does not understand

Uses of MuleException in org.mule.api.service

Subclasses of MuleException in org.mule.api.service
`class` | `FailedToQueueEventException` `FailedToQueueEventException` is thrown when an event cannot be put on an internal service queue.

Methods in org.mule.api.service that throw MuleException
`void` | `Service.dispatchEvent(MuleEvent event)` Deprecated.
`void` | `Service.pause()` Pauses event processing for a single Mule Service.
`void` | `Service.resume()` Resumes a single Mule Service that has been paused.
`MuleEvent` | `Service.sendEvent(MuleEvent event)` Deprecated.

Uses of MuleException in org.mule.api.source

Methods in org.mule.api.source that throw MuleException
`void` | `CompositeMessageSource.addSource(MessageSource messageSource)`
`void` | `CompositeMessageSource.removeSource(MessageSource messageSource)`

Uses of MuleException in org.mule.api.store

Subclasses of MuleException in org.mule.api.store
`class` | `ObjectAlreadyExistsException`
`class` | `ObjectDoesNotExistException`
`class` | `ObjectStoreException` This exception class is thrown in cases when an exception occurs while operating on an `ObjectStore`.
`class` | `ObjectStoreNotAvaliableException` This exception is thrown when the underlying to an `ObjectStore`'s system fails.

Uses of MuleException in org.mule.api.transaction

Subclasses of MuleException in org.mule.api.transaction
`class` | `TransactionException` `TransactionException` is thrown when an exception occurs while trying to create, start commit or rollback an exception

Uses of MuleException in org.mule.api.transformer

Subclasses of MuleException in org.mule.api.transformer
`class` | `TransformerException` `TransformerException` is a simple exception that is thrown by transformers.
`class` | `TransformerMessagingException` An exception that occurred while transforming a message.

Uses of MuleException in org.mule.api.transformer.wire

Methods in org.mule.api.transformer.wire that throw MuleException
`Object` | `WireFormat.read(InputStream is)`
`void` | `WireFormat.write(OutputStream out, Object o, String encoding)`

Uses of MuleException in org.mule.api.transport

Subclasses of MuleException in org.mule.api.transport
`class` | `ConnectorException` `ConnectorException` Is thrown in the context of a Connector, usually some sort of transport level error where the connection has failed.
`class` | `DispatchException` `DispatchException` is thrown when an endpoint dispatcher fails to send, dispatch or receive a message.
`class` | `MessageTypeNotSupportedException` `MessageTypeNotSupportedException` is thrown when a `MuleMessage` instance is to be created with an payload type that is not of supported type by that `MuleMessageFactory`.
`class` | `NoReceiverForEndpointException` `NoReceiverForEndpointException` is thrown when an enpoint is specified for a receiver but no such receiver exists.
`class` | `ReceiveException` `ReceiveException` is specifically thrown by the Provider receive method if something fails in the underlying transport

Methods in org.mule.api.transport that throw MuleException
`void` | `MessageRequesterFactory.activate(InboundEndpoint endpoint, MessageRequester requester)` Invoked before the given requester is handed out to a client, but not after `MessageRequesterFactory.create(org.mule.api.endpoint.InboundEndpoint)`.
`void` | `MessageDispatcherFactory.activate(OutboundEndpoint endpoint, MessageDispatcher dispatcher)` Invoked before the given dispatcher is handed out to a client, but not after `MessageDispatcherFactory.create(OutboundEndpoint)`.
`MessageRequester` | `MessageRequesterFactory.create(InboundEndpoint endpoint)` Creates a new message requester instance, initialised with the passed endpoint.
`MessageDispatcher` | `MessageDispatcherFactory.create(OutboundEndpoint endpoint)` Creates a new message dispatcher instance, initialised with the passed endpoint.
`MuleMessage` | `MessageRequester.createMuleMessage(Object transportMessage)`
`MuleMessage` | `MessageReceiver.createMuleMessage(Object transportMessage)`
`MuleMessage` | `MessageDispatcher.createMuleMessage(Object transportMessage)`
`MuleMessage` | `MessageRequester.createMuleMessage(Object transportMessage, String encoding)`
`MuleMessage` | `MessageReceiver.createMuleMessage(Object transportMessage, String encoding)`
`MuleMessage` | `MessageDispatcher.createMuleMessage(Object transportMessage, String encoding)`
`OutputStream` | `Connector.getOutputStream(OutboundEndpoint endpoint, MuleEvent event)` Will get the output stream for this type of transport.
`MuleMessage` | `InternalMessageListener.onMessage(MuleMessage message, Transaction trans, boolean synchronous, OutputStream outputStream)`
`void` | `ReplyToHandler.processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)`
`MuleSession` | `SessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`void` | `SessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`MuleEvent` | `MessageReceiver.routeMessage(MuleMessage message)`
`MuleEvent` | `MessageReceiver.routeMessage(MuleMessage message, Transaction trans)`
`MuleEvent` | `MessageReceiver.routeMessage(MuleMessage message, Transaction trans, OutputStream outputStream)`
`void` | `SessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`

Uses of MuleException in org.mule.client

Methods in org.mule.client that throw MuleException
`void` | `DefaultLocalMuleClient.dispatch(String url, MuleMessage message)`
`void` | `DefaultLocalMuleClient.dispatch(String url, Object payload, Map<String,Object> messageProperties)`
`protected InboundEndpoint` | `DefaultLocalMuleClient.getInboundEndpoint(String uri, MessageExchangePattern mep)`
`protected OutboundEndpoint` | `DefaultLocalMuleClient.getOutboundEndpoint(String uri, MessageExchangePattern mep, Long responseTimeout)`
`MuleMessage` | `DefaultLocalMuleClient.process(OutboundEndpoint endpoint, MuleMessage message)`
`MuleMessage` | `DefaultLocalMuleClient.process(OutboundEndpoint endpoint, Object payload, Map<String,Object> messageProperties)`
`MuleMessage` | `DefaultLocalMuleClient.process(String uri, MessageExchangePattern mep, MuleMessage message)`
`MuleMessage` | `DefaultLocalMuleClient.process(String uri, MessageExchangePattern mep, Object payload, Map<String,Object> messageProperties)`
`MuleMessage` | `DefaultLocalMuleClient.request(InboundEndpoint endpoint, long timeout)`
`MuleMessage` | `DefaultLocalMuleClient.request(String url, long timeout)`
`MuleMessage` | `DefaultLocalMuleClient.send(String url, MuleMessage message)`
`MuleMessage` | `DefaultLocalMuleClient.send(String url, MuleMessage message, long timeout)`
`MuleMessage` | `DefaultLocalMuleClient.send(String url, Object payload, Map<String,Object> messageProperties)`
`MuleMessage` | `DefaultLocalMuleClient.send(String url, Object payload, Map<String,Object> messageProperties, long timeout)`

Uses of MuleException in org.mule.component

Subclasses of MuleException in org.mule.component
`class` | `ComponentException` `ComponentException` should be thrown when some action on a component fails, such as starting or stopping

Methods in org.mule.component that throw MuleException
`protected void` | `DefaultComponentLifecycleAdapter.configureBinding()`
`LifecycleAdapter` | `DefaultComponentLifecycleAdapterFactory.create(Object pojoService, JavaComponent component, FlowConstruct flowConstruct, EntryPointResolverSet resolver, MuleContext muleContext)`
`protected MuleEvent` | `AbstractComponent.createResultEvent(MuleEvent event, Object result)`
`protected void` | `SimpleCallableJavaComponent.doStart()`
`protected void` | `PooledJavaComponent.doStart()`
`protected void` | `DefaultJavaComponent.doStart()`
`protected void` | `AbstractJavaComponent.doStart()`
`protected void` | `AbstractComponent.doStart()`
`protected void` | `SimpleCallableJavaComponent.doStop()`
`protected void` | `PooledJavaComponent.doStop()`
`protected void` | `DefaultJavaComponent.doStop()`
`protected void` | `AbstractComponent.doStop()`
`Object` | `DefaultComponentLifecycleAdapter.invoke(MuleEvent event)`
`MuleEvent` | `DefaultInterfaceBinding.process(MuleEvent event)`
`MuleEvent` | `AbstractComponent.process(MuleEvent event)`
`void` | `DefaultInterfaceBinding.setEndpoint(ImmutableEndpoint e)`
`void` | `NullLifecycleAdapter.start()`
`void` | `DefaultComponentLifecycleAdapter.start()` Propagates start() life-cycle to component object implementations if they implement the mule `Startable` interface.
`void` | `AbstractComponent.start()`
`void` | `NullLifecycleAdapter.stop()`
`void` | `DefaultComponentLifecycleAdapter.stop()` Propagates stop() life-cycle to component object implementations if they implement the mule `Stoppable` interface.
`void` | `AbstractComponent.stop()`

Constructors in org.mule.component that throw MuleException
`DefaultComponentLifecycleAdapter(Object componentObject, JavaComponent component, FlowConstruct flowConstruct, EntryPointResolverSet entryPointResolver, MuleContext muleContext)`
`DefaultComponentLifecycleAdapter(Object componentObject, JavaComponent component, FlowConstruct flowConstruct, MuleContext muleContext)`
`NullLifecycleAdapter(Object componentObject, JavaComponent component, FlowConstruct flowConstruct, EntryPointResolverSet entryPointResolver, MuleContext muleContext)`

Uses of MuleException in org.mule.config

Methods in org.mule.config that return MuleException
`static MuleException` | `ExceptionHelper.getRootMuleException(Throwable t)`

Uses of MuleException in org.mule.config.dsl.routers

Methods in org.mule.config.dsl.routers that throw MuleException
`boolean` | `ContentBasedRouter.isMatch(MuleMessage message)`

Uses of MuleException in org.mule.config.endpoint

Methods in org.mule.config.endpoint that throw MuleException
`protected abstract AnnotatedEndpointData` | `AbstractEndpointAnnotationParser.createEndpointData(Annotation annotation)`
`protected EndpointBuilder` | `AnnotatedEndpointHelper.getEndpointBuilder(AnnotatedEndpointData epData)`
`protected AnnotatedEndpointHelper` | `AbstractEndpointAnnotationParser.getEndpointHelper()`
`protected Properties` | `ConfigurableTransportFactory.loadOverrides()`
`InboundEndpoint` | `AbstractEndpointAnnotationParser.parseInboundEndpoint(Annotation annotation, Map metaInfo)`
`OutboundEndpoint` | `AbstractEndpointAnnotationParser.parseOutboundEndpoint(Annotation annotation, Map metaInfo)`
`ImmutableEndpoint` | `AnnotatedEndpointHelper.processEndpoint(AnnotatedEndpointData epData)`

Constructors in org.mule.config.endpoint that throw MuleException
`AnnotatedEndpointHelper(MuleContext muleContext)`
`ConfigurableTransportFactory(MuleContext muleContext)`

Uses of MuleException in org.mule.config.processors

Methods in org.mule.config.processors that throw MuleException
`protected void` | `DecoratingAnnotatedServiceProcessor.processInbound(Class componentFactoryClass, Service service)`
`protected void` | `DecoratingAnnotatedServiceProcessor.processInboundRouters(Class componentFactoryClass, Service service)`
`protected void` | `DecoratingAnnotatedServiceProcessor.processOutbound(Class componentFactoryClass, Service service)`
`protected OutboundRouter` | `DecoratingAnnotatedServiceProcessor.processOutboundRouter(Class componentFactoryClass)`
`protected void` | `DecoratingAnnotatedServiceProcessor.processReply(Class componentFactoryClass, Service service)`
`protected void` | `DecoratingAnnotatedServiceProcessor.processReplyRouters(Class componentFactoryClass, Service service)`
`protected InboundEndpoint` | `DecoratingAnnotatedServiceProcessor.tryInboundEndpointAnnotation(AnnotationMetaData metaData, ChannelType channelType)`
`protected OutboundEndpoint` | `DecoratingAnnotatedServiceProcessor.tryOutboundEndpointAnnotation(AnnotationMetaData metaData, ChannelType channelType)`

Uses of MuleException in org.mule.config.spring.factories

Methods in org.mule.config.spring.factories that throw MuleException
`protected AbstractFlowConstruct` | `AbstractFlowConstructFactoryBean.createFlowConstruct()`

Uses of MuleException in org.mule.construct

Methods in org.mule.construct that throw MuleException
`protected abstract void` | `AbstractFlowConstruct.configureMessageProcessors(MessageProcessorChainBuilder builder)` Used to configure the processing chain for this `FlowConstuct` `MessageProcessor`s to the chain using the builder provided.
`protected void` | `AbstractFlowConstruct.createMessageProcessor()` Creates a `MessageProcessor` that will process messages from the configured `MessageSource`.
`protected void` | `AbstractFlowConstruct.doStart()`
`protected void` | `AbstractFlowConstruct.doStop()`
`void` | `FlowConstructLifecycleManager.fireDisposePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `FlowConstructLifecycleManager.fireInitialisePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `FlowConstructLifecycleManager.firePausePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `FlowConstructLifecycleManager.fireResumePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `FlowConstructLifecycleManager.fireStartPhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `FlowConstructLifecycleManager.fireStopPhase(LifecycleCallback<FlowConstruct> callback)`
`MuleEvent` | `SimpleFlowConstruct.process(MuleEvent event)`
`void` | `AbstractFlowConstruct.start()`
`protected void` | `AbstractFlowConstruct.startIfStartable(Object candidate)`
`void` | `AbstractFlowConstruct.stop()`
`protected void` | `AbstractFlowConstruct.stopIfStoppable(Object candidate)`

Constructors in org.mule.construct that throw MuleException
`SimpleService(String name, MuleContext muleContext, MessageSource messageSource, Component component, SimpleService.Type type)`

Uses of MuleException in org.mule.construct.builder

Methods in org.mule.construct.builder that throw MuleException
`F` | `AbstractFlowConstructBuilder.build(MuleContext muleContext)`
`F` | `AbstractFlowConstructBuilder.buildAndRegister(MuleContext muleContext)`
`protected Validator` | `ValidatorBuilder.buildFlowConstruct(MuleContext muleContext)`
`protected SimpleService` | `SimpleServiceBuilder.buildFlowConstruct(MuleContext muleContext)`
`protected Bridge` | `BridgeBuilder.buildFlowConstruct(MuleContext muleContext)`
`protected abstract F` | `AbstractFlowConstructBuilder.buildFlowConstruct(MuleContext muleContext)`
`protected InboundEndpoint` | `AbstractFlowConstructWithSingleInboundEndpointBuilder.getOrBuildInboundEndpoint(MuleContext muleContext)`
`protected OutboundEndpoint` | `AbstractFlowConstructWithSingleInboundAndOutboundEndpointBuilder.getOrBuildOutboundEndpoint(MuleContext muleContext)`

Uses of MuleException in org.mule.construct.processor

Methods in org.mule.construct.processor that throw MuleException
`MuleEvent` | `FlowConstructStatisticsMessageProcessor.process(MuleEvent event)`

Uses of MuleException in org.mule.context.notification

Subclasses of MuleException in org.mule.context.notification
`class` | `NotificationException` Thrown by the ServerNotification Manager if unrecognised listeners or events are passed to the manager

Uses of MuleException in org.mule.endpoint

Methods in org.mule.endpoint that throw MuleException
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`protected MessageProcessor` | `DynamicOutboundEndpoint.NullOutboundEndpoint.createMessageProcessorChain(FlowConstruct flowConstruct)`
`protected MessageProcessor` | `DefaultOutboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`MessageProcessor` | `DefaultInboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`protected abstract MessageProcessor` | `AbstractEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createOutboundMessageProcessors(OutboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createOutboundResponseMessageProcessors(OutboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`protected ImmutableEndpoint` | `DefaultEndpointFactory.getEndpoint(EndpointURI uri, org.mule.endpoint.DefaultEndpointFactory.EndpointSource source)`
`EndpointBuilder` | `DefaultEndpointFactory.getEndpointBuilder(String uri)`
`InboundEndpoint` | `DefaultEndpointFactory.getInboundEndpoint(EndpointBuilder builder)`
`InboundEndpoint` | `DefaultEndpointFactory.getInboundEndpoint(EndpointURI uri)`
`InboundEndpoint` | `DefaultEndpointFactory.getInboundEndpoint(String uri)`
`MessageProcessor` | `AbstractEndpoint.getMessageProcessorChain(FlowConstruct flowContruct)`
`OutboundEndpoint` | `DefaultEndpointFactory.getOutboundEndpoint(EndpointBuilder builder)`
`OutboundEndpoint` | `DefaultEndpointFactory.getOutboundEndpoint(EndpointURI uri)`
`OutboundEndpoint` | `DefaultEndpointFactory.getOutboundEndpoint(String uri)`
`protected MessageProcessor` | `EndpointMessageProcessorChainBuilder.initializeMessageProcessor(Object processor)`
`MuleEvent` | `DynamicURIOutboundEndpoint.process(MuleEvent event)`
`MuleEvent` | `DynamicOutboundEndpoint.process(MuleEvent event)`
`MuleEvent` | `DynamicOutboundEndpoint.NullOutboundEndpoint.process(MuleEvent event)`
`MuleEvent` | `DefaultOutboundEndpoint.process(MuleEvent event)`
`void` | `DynamicURIInboundEndpoint.start()`
`void` | `DefaultInboundEndpoint.start()`
`void` | `DynamicURIInboundEndpoint.stop()`
`void` | `DefaultInboundEndpoint.stop()`

Uses of MuleException in org.mule.endpoint.dynamic

Methods in org.mule.endpoint.dynamic that throw MuleException
`protected void` | `NullConnector.doStart()`
`protected void` | `NullConnector.doStop()`

Constructors in org.mule.endpoint.dynamic that throw MuleException
`NullConnector(MuleContext context)`

Uses of MuleException in org.mule.endpoint.inbound

Methods in org.mule.endpoint.inbound that throw MuleException
`MuleEvent` | `InboundNotificationMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `InboundLoggingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `InboundExceptionDetailsMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `InboundEndpointPropertyMessageProcessor.process(MuleEvent event)`

Uses of MuleException in org.mule.endpoint.outbound

Methods in org.mule.endpoint.outbound that throw MuleException
`MuleEvent` | `OutboundTxRollbackMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundSessionHandlerMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundRewriteResponseEventMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundResponsePropertiesMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundNotificationMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundLoggingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundEventTimeoutMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `OutboundEndpointPropertyMessageProcessor.process(MuleEvent event)`

Uses of MuleException in org.mule.enricher

Methods in org.mule.enricher that throw MuleException
`MuleEvent` | `MessageEnricher.process(MuleEvent event)`

Uses of MuleException in org.mule.example.errorhandler

Subclasses of MuleException in org.mule.example.errorhandler
`class` | `HandlerException`

Methods in org.mule.example.errorhandler that throw MuleException
`Object` | `BusinessErrorManager.onCall(MuleEventContext context)`
`void` | `ErrorManager.onException(ErrorMessage msg)`

Uses of MuleException in org.mule.example.errorhandler.exceptions

Subclasses of MuleException in org.mule.example.errorhandler.exceptions
`class` | `BusinessException` `BusinessException` TODO (document class)
`class` | `FatalException` `FatalException` TODO (document class)

Uses of MuleException in org.mule.example.loanbroker

Subclasses of MuleException in org.mule.example.loanbroker
`class` | `LoanBrokerException` Exception related to the LoanBroker example app.

Methods in org.mule.example.loanbroker that throw MuleException
`protected ConfigurationBuilder` | `AbstractLoanBrokerApp.getConfigBuilder()`

Uses of MuleException in org.mule.example.notifications

Methods in org.mule.example.notifications that throw MuleException
`void` | `HeartbeatAgent.start()`
`void` | `HeartbeatAgent.stop()`

Uses of MuleException in org.mule.exception

Methods in org.mule.exception that throw MuleException
`protected OutboundRouter` | `AbstractExceptionListener.createOutboundRouter()`

Uses of MuleException in org.mule.interceptor

Methods in org.mule.interceptor that throw MuleException
`MuleEvent` | `ProcessingTimeInterceptor.after(MuleEvent event)`
`abstract MuleEvent` | `AbstractEnvelopeInterceptor.after(MuleEvent event)` This method is invoked after the event has been processed, unless an exception was thrown
`MuleEvent` | `ProcessingTimeInterceptor.before(MuleEvent event)`
`abstract MuleEvent` | `AbstractEnvelopeInterceptor.before(MuleEvent event)` This method is invoked before the event is processed
`MuleEvent` | `ProcessingTimeInterceptor.last(MuleEvent event, ProcessingTime time, long startTime, boolean exceptionWasThrown)`
`MuleEvent` | `LoggingInterceptor.last(MuleEvent event, ProcessingTime time, long startTime, boolean exceptionWasThrown)`
`abstract MuleEvent` | `AbstractEnvelopeInterceptor.last(MuleEvent event, ProcessingTime time, long startTime, boolean exceptionWasThrown)` This method is always invoked after the event has been processed,
`MuleEvent` | `TimerInterceptor.process(MuleEvent event)`
`MuleEvent` | `InterceptorStack.process(MuleEvent event)`
`MuleEvent` | `AbstractEnvelopeInterceptor.process(MuleEvent event)`

Uses of MuleException in org.mule.lifecycle

Methods in org.mule.lifecycle that throw MuleException
`abstract void` | `SimpleLifecycleManager.fireDisposePhase(LifecycleCallback<O> callback)`
`abstract void` | `SimpleLifecycleManager.fireInitialisePhase(LifecycleCallback<O> callback)`
`abstract void` | `SimpleLifecycleManager.fireStartPhase(LifecycleCallback<O> callback)`
`abstract void` | `SimpleLifecycleManager.fireStopPhase(LifecycleCallback<O> callback)`
`void` | `EmptyLifecycleCallback.onTransition(String phaseName, O object)`

Uses of MuleException in org.mule.lifecycle.processor

Methods in org.mule.lifecycle.processor that throw MuleException
`protected MuleEvent` | `ProcessIfStartedWaitIfSyncPausedMessageProcessor.processNext(MuleEvent event)`
`protected MuleEvent` | `ProcessIfStartedWaitIfPausedMessageProcessor.processNext(MuleEvent event)`

Uses of MuleException in org.mule.model

Methods in org.mule.model that throw MuleException
`void` | `ModelLifecycleManager.fireDisposePhase(LifecycleCallback<AbstractModel> callback)`
`void` | `ModelLifecycleManager.fireInitialisePhase(LifecycleCallback<AbstractModel> callback)`
`void` | `ModelLifecycleManager.fireStartPhase(LifecycleCallback<AbstractModel> callback)`
`void` | `ModelLifecycleManager.fireStopPhase(LifecycleCallback<AbstractModel> callback)`
`void` | `AbstractModel.start()` Starts all registered components
`void` | `AbstractModel.stop()` Stops any registered components

Uses of MuleException in org.mule.model.resolvers

Subclasses of MuleException in org.mule.model.resolvers
`class` | `EntryPointNotFoundException` Tis exception gets thrown by the `DefaultEntryPointResolverSet` if after trying all entrypointResolvers it cannot fin the entrypoint on the service service
`class` | `NoSatisfiableMethodsException` `NoSatisfiableMethodsException` is thrown by EntryPointResolvers when the service passed has no methods that meet the criteria of the configured EntryPointResolver.
`class` | `TooManySatisfiableMethodsException` `TooManySatisfiableMethodsException` is thrown by EntryPointResolvers when the service passed has more than one method that meets the criteria of the configured EntryPointResolver.

Uses of MuleException in org.mule.model.seda

Methods in org.mule.model.seda that throw MuleException
`protected void` | `SedaService.doForceStop()`
`protected void` | `SedaService.doStart()`
`protected void` | `SedaService.doStop()`

Uses of MuleException in org.mule.module.atom

Methods in org.mule.module.atom that throw MuleException
`Object` | `AbderaServiceComponent.AbderaCallable.onCall(MuleEventContext event)`

Uses of MuleException in org.mule.module.atom.endpoint

Methods in org.mule.module.atom.endpoint that throw MuleException
`boolean` | `AtomInboundEndpoint.onMessage(MuleMessage message)`

Uses of MuleException in org.mule.module.atom.routing

Methods in org.mule.module.atom.routing that throw MuleException
`protected List<MuleMessage>` | `FeedSplitter.splitMessage(MuleEvent event)`

Uses of MuleException in org.mule.module.bpm

Methods in org.mule.module.bpm that throw MuleException
`MuleMessage` | `Process.generateMessage(String endpoint, Object payload, Map messageProperties, MessageExchangePattern exchangePattern)`

Uses of MuleException in org.mule.module.client

Methods in org.mule.module.client that throw MuleException
`FutureMessageResult` | `RemoteDispatcher.asyncReceiveRemote(String endpoint, int timeout)`
`void` | `MuleClient.dispatch(String url, MuleMessage message)` Dispatches an event asynchronously to a endpointUri via a Mule server.
`void` | `MuleClient.dispatch(String url, Object payload, Map messageProperties)` Dispatches an event asynchronously to a endpointUri via a Mule server.
`protected MuleMessage` | `RemoteDispatcher.dispatchAction(RemoteDispatcherNotification action, boolean synchronous, int timeout)`
`void` | `MuleClient.dispatchDirect(String componentName, MuleMessage message)` Dispatches an event asynchronously to a component
`void` | `MuleClient.dispatchDirect(String component, Object payload, Map messageProperties)` Dispatches an event asynchronously to a component
`void` | `RemoteDispatcher.dispatchRemote(String endpoint, Object payload, Map messageProperties)`
`void` | `RemoteDispatcher.dispatchToRemoteComponent(String component, Object payload, Map messageProperties)` Dispatcher an event asynchronously to a components on a remote Mule instance.
`protected MuleMessage` | `RemoteDispatcher.doToRemote(String endpoint, Object payload, Map messageProperties, boolean synchronous, int timeout)`
`protected MuleMessage` | `RemoteDispatcher.doToRemoteComponent(String component, Object payload, Map messageProperties, boolean synchronous)`
`protected ImmutableEndpoint` | `MuleClient.getDefaultClientEndpoint(Service service, Object payload, boolean sync)`
`protected MuleEvent` | `MuleClient.getEvent(MuleMessage message, OutboundEndpoint endpoint)`
`protected InboundEndpoint` | `MuleClient.getInboundEndpoint(String uri)`
`protected OutboundEndpoint` | `MuleClient.getOutboundEndpoint(String uri, MessageExchangePattern exchangePattern, Integer responseTimeout)`
`RemoteDispatcher` | `MuleClient.getRemoteDispatcher(String serverEndpoint)`
`RemoteDispatcher` | `MuleClient.getRemoteDispatcher(String serverEndpoint, String user, String password)`
`MuleMessage` | `RemoteDispatcher.receiveRemote(String endpoint, int timeout)`
`void` | `MuleClient.registerComponent(Object component, String name, EndpointURI listenerEndpoint)` Deprecated. Use the RegistryContext to get the registry and register the service there
`void` | `MuleClient.registerComponent(Object component, String name, MuleEndpointURI listenerEndpoint, MuleEndpointURI sendEndpoint)` Deprecated. Use the RegistryContext to get the registry and register the service there
`MuleMessage` | `MuleClient.request(String url, List transformers, long timeout)` Will receive an event from an endpointUri determined by the URL
`MuleMessage` | `MuleClient.request(String url, long timeout)` Will receive an event from an endpointUri determined by the URL.
`MuleMessage` | `MuleClient.request(String url, String transformers, long timeout)` Will receive an event from an endpointUri determined by the URL
`protected WireFormat` | `RemoteDispatcher.requestWireFormat()`
`MuleMessage` | `MuleClient.send(String url, MuleMessage message)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, MuleMessage message, int timeout)` Sends an event synchronously to a endpointUri via a mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, Object payload, Map messageProperties)` Sends an event synchronously to a endpointUri via a Mule server and a resulting message is returned.
`MuleMessage` | `MuleClient.send(String url, Object payload, Map messageProperties, int timeout)` Sends an event synchronously to a endpointUri via a mule server and a resulting message is returned.
`FutureMessageResult` | `MuleClient.sendAsync(String url, MuleMessage message)` Sends an event request to a URL, making the result of the event trigger available as a Future result that can be accessed later by client code.
`FutureMessageResult` | `MuleClient.sendAsync(String url, MuleMessage message, int timeout)` Sends an event request to a URL, making the result of the event trigger available as a Future result that can be accessed later by client code.
`FutureMessageResult` | `MuleClient.sendAsync(String url, Object payload, Map messageProperties)` Sends an event request to a URL, making the result of the event trigger available as a Future result that can be accessed later by client code.
`FutureMessageResult` | `MuleClient.sendAsync(String url, Object payload, Map messageProperties, int timeout)` Sends an event request to a URL, making the result of the event trigger available as a Future result that can be accessed later by client code.
`FutureMessageResult` | `RemoteDispatcher.sendAsyncRemote(String endpoint, Object payload, Map messageProperties)`
`FutureMessageResult` | `RemoteDispatcher.sendAsyncToRemoteComponent(String component, String transformers, Object payload, Map messageProperties)` sends an event to a components on a remote Mule instance, while making the result of the event trigger available as a Future result that can be accessed later by client code.
`MuleMessage` | `MuleClient.sendDirect(String componentName, String transformers, MuleMessage message)` Sends an event synchronously to a component
`MuleMessage` | `MuleClient.sendDirect(String component, String transformers, Object payload, Map messageProperties)` Sends an event synchronously to a component
`FutureMessageResult` | `MuleClient.sendDirectAsync(String component, String transformers, MuleMessage message)` Snds an event to a component on a local Mule instance, while making the result of the event trigger available as a Future result that can be accessed later by client code.
`FutureMessageResult` | `MuleClient.sendDirectAsync(String component, String transformers, Object payload, Map messageProperties)` Sends an event to a component on a local Mule instance, while making the result of the event trigger available as a Future result that can be accessed later by client code.
`void` | `MuleClient.sendNoReceive(String url, Object payload, Map<String,Object> messageProperties)` Sends an event synchronously to a endpointUri via a Mule server without waiting for the result.
`MuleMessage` | `RemoteDispatcher.sendRemote(String endpoint, Object payload, Map messageProperties)`
`MuleMessage` | `RemoteDispatcher.sendRemote(String endpoint, Object payload, Map messageProperties, int timeout)`
`MuleMessage` | `RemoteDispatcher.sendToRemoteComponent(String component, Object payload, Map messageProperties)` sends an event synchronously to a components on a remote Mule instance.
`void` | `MuleClient.unregisterComponent(String name)` Deprecated. Use the RegistryContext to get the registry and unregister the service there
`protected void` | `RemoteDispatcher.updateContext(MuleMessage message, ImmutableEndpoint endpoint, boolean synchronous)`

Constructors in org.mule.module.client that throw MuleException
`MuleClient()` Creates a Mule client that will use the default serverEndpoint when connecting to a remote server instance.
`MuleClient(boolean startContext)`
`MuleClient(MuleContext context)`
`MuleClient(String configResources)` Configures a Mule client instance using the the default `SpringXmlConfigurationBuilder` to parse `configResources`.
`MuleClient(String user, String password)` Configures a new Mule client and either uses an existing Manager running in this JVM or creates a new empty `MuleContext`
`RemoteDispatcher(String endpoint, Credentials credentials, MuleContext muleContext)`
`RemoteDispatcher(String endpoint, MuleContext muleContext)`

Uses of MuleException in org.mule.module.client.remoting

Subclasses of MuleException in org.mule.module.client.remoting
`class` | `RemoteDispatcherException` Exceptions thrown by the Client RemoteDispatcher.
`class` | `UnsupportedWireFormatException` Exception is thrown when the server is using a wire format that the client does not support

Methods in org.mule.module.client.remoting that throw MuleException
`static Service` | `RemoteDispatcherComponent.getSerivce(InboundEndpoint endpoint, WireFormat wireFormat, String encoding, int eventTimeout, MuleContext muleContext)`
`protected Object` | `RemoteDispatcherComponent.invokeAction(RemoteDispatcherNotification action, MuleEventContext context)`
`protected Object` | `RemoteDispatcherComponent.receiveAction(RemoteDispatcherNotification action, MuleEventContext context)`
`protected Object` | `RemoteDispatcherComponent.sendAction(RemoteDispatcherNotification action, MuleEventContext context)`
`void` | `RemoteDispatcherAgent.start()`
`void` | `RemoteDispatcherAgent.stop()`

Uses of MuleException in org.mule.module.cxf

Methods in org.mule.module.cxf that throw MuleException
`static CxfConfiguration` | `CxfConfiguration.getConfiguration(MuleContext muleContext)`
`protected InputStream` | `CxfInboundMessageProcessor.getMessageStream(MuleEvent context)` Gets the stream representation of the current message.
`MuleEvent` | `CxfOutboundMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `CxfInboundMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `CxfOutboundMessageProcessor.processNext(MuleEvent event)` This method is public so it can be invoked from the MuleUniversalConduit.
`MuleEvent` | `CxfInboundMessageProcessor.processNext(MuleEvent event)`
`protected MuleEvent` | `CxfInboundMessageProcessor.sendToDestination(MuleEvent event)`
`void` | `CxfInboundMessageProcessor.start()`
`void` | `CxfInboundMessageProcessor.stop()`

Uses of MuleException in org.mule.module.cxf.builder

Methods in org.mule.module.cxf.builder that throw MuleException
`CxfOutboundMessageProcessor` | `AbstractOutboundMessageProcessorBuilder.build()`
`CxfInboundMessageProcessor` | `AbstractInboundMessageProcessorBuilder.build()`
`protected Class<?>` | `WebServiceMessageProcessorBuilder.getTargetClass(Service service)` Try to determine the target class from the Service.

Uses of MuleException in org.mule.module.cxf.config

Methods in org.mule.module.cxf.config that throw MuleException
`MuleEvent` | `FlowConfiguringMessageProcessor.process(MuleEvent event)`
`void` | `FlowConfiguringMessageProcessor.start()`
`void` | `FlowConfiguringMessageProcessor.stop()`

Uses of MuleException in org.mule.module.cxf.security

Subclasses of MuleException in org.mule.module.cxf.security
`class` | `WebServiceSecurityException`

Uses of MuleException in org.mule.module.cxf.transport

Methods in org.mule.module.cxf.transport that throw MuleException
`protected OutboundEndpoint` | `MuleUniversalConduit.getEndpoint(MuleContext muleContext, String uri)`
`protected MuleEvent` | `MuleUniversalConduit.processNext(MuleEvent event, org.apache.cxf.message.Exchange exchange)`

Uses of MuleException in org.mule.module.guice

Methods in org.mule.module.guice that throw MuleException
`protected EndpointBuilder` | `AbstractMuleGuiceModule.createEndpointBuilder(String uri)` Creates an `EndpointBuilder` instance for the endpoint uri.

Uses of MuleException in org.mule.module.ibeans.config

Methods in org.mule.module.ibeans.config that throw MuleException
`Object` | `IBeanHolder.create(MuleContext muleContext, MuleIBeansPlugin plugin)`
`protected AnnotatedEndpointData` | `CallAnnotationParser.createEndpointData(Annotation annotation)`
`InboundEndpoint` | `CallAnnotationParser.parseInboundEndpoint(Annotation annotation, Map metaInfo)`
`OutboundEndpoint` | `CallAnnotationParser.parseOutboundEndpoint(Annotation annotation, Map metaInfo)`
`MuleEvent` | `CallInterfaceBinding.process(MuleEvent event)`
`MuleMessage` | `CallInterfaceBinding.route(MuleMessage message, MuleSession session)`

Uses of MuleException in org.mule.module.ibeans.spi.support

Methods in org.mule.module.ibeans.spi.support that throw MuleException
`MessageProcessor` | `DynamicRequestEndpoint.NullInboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`MuleEvent` | `DynamicRequestEndpoint.NullInboundEndpoint.process(MuleEvent event)`
`MuleEvent` | `CallOutboundEndpoint.process(MuleEvent event)`

Uses of MuleException in org.mule.module.jca

Methods in org.mule.module.jca that throw MuleException
`protected Service` | `MuleResourceAdapter.createJcaService(javax.resource.spi.endpoint.MessageEndpointFactory endpointFactory, JcaModel model, InboundEndpoint endpoint)`
`protected InboundEndpoint` | `MuleResourceAdapter.createMessageInflowEndpoint(MuleActivationSpec muleActivationSpec)`
`void` | `MuleConnection.dispatch(String url, Object payload, Map messageProperties)`
`void` | `DefaultMuleConnection.dispatch(String url, Object payload, Map messageProperties)` Dispatches an event asynchronously to a endpointUri via a mule server.
`protected MuleEvent` | `DefaultMuleConnection.getEvent(MuleMessage message, OutboundEndpoint endpoint)` Packages a mule event for the current request
`protected JcaModel` | `MuleResourceAdapter.getJcaModel(String modelName)`
`Object` | `JcaComponent.getManagedInstance()`
`protected OutboundEndpoint` | `DefaultMuleConnection.getOutboundEndpoint(String uri, MessageExchangePattern exchangePattern)`
`MuleMessage` | `MuleConnection.request(String url, long timeout)`
`MuleMessage` | `DefaultMuleConnection.request(String url, long timeout)` Will receive an event from an endpointUri determined by the url
`MuleMessage` | `MuleConnection.send(String url, Object payload, Map messageProperties)`
`MuleMessage` | `DefaultMuleConnection.send(String url, Object payload, Map messageProperties)` Sends an object (payload) synchronous to the given url and returns a MuleMessage response back.
`MuleEvent` | `JcaService.sendEvent(MuleEvent event)` This is the synchronous call method and not supported by components managed in a JCA container
`void` | `DelegateWorkManager.start()`
`void` | `DelegateWorkManager.stop()`

Uses of MuleException in org.mule.module.management

Subclasses of MuleException in org.mule.module.management
`class` | `ManagementException` `ManagementException` is a general exception thrown by management extensions.

Uses of MuleException in org.mule.module.management.agent

Subclasses of MuleException in org.mule.module.management.agent
`class` | `JmxManagementException` `JmxManagementException` is thrown by the Jmx agents if an error occurs while executing an operation.

Methods in org.mule.module.management.agent that throw MuleException
`protected void` | `JmxAgent.registerWrapperService()` Register a Java Service Wrapper agent.
`void` | `YourKitProfilerAgent.start()`
`void` | `WrapperManagerAgent.start()`
`void` | `RmiRegistryAgent.start()`
`void` | `Mx4jAgent.start()`
`void` | `Log4jAgent.start()`
`void` | `JmxAgent.start()`
`void` | `JdmkAgent.start()`
`void` | `DefaultJmxSupportAgent.start()`
`void` | `YourKitProfilerAgent.stop()`
`void` | `WrapperManagerAgent.stop()`
`void` | `RmiRegistryAgent.stop()`
`void` | `Mx4jAgent.stop()`
`void` | `Log4jAgent.stop()`
`void` | `JmxAgent.stop()`
`void` | `JdmkAgent.stop()`
`void` | `DefaultJmxSupportAgent.stop()`

Uses of MuleException in org.mule.module.management.mbean

Methods in org.mule.module.management.mbean that throw MuleException
`void` | `ServiceServiceMBean.dispose()`
`void` | `ServiceService.dispose()`
`void` | `MuleServiceMBean.dispose()`
`void` | `MuleService.dispose()`
`void` | `ServiceServiceMBean.forceStop()` Causes the service to stop without processing its event queue first
`void` | `ServiceService.forceStop()`
`void` | `ServiceServiceMBean.pause()` Pauses event processing for theComponent.
`void` | `ServiceService.pause()` Pauses event processing for theComponent.
`void` | `ServiceServiceMBean.resume()` Resumes the Service that has been paused.
`void` | `ServiceService.resume()` Resumes the Service that has been paused.
`void` | `ServiceService.start()`
`void` | `RegistryServiceMBean.start()`
`void` | `MuleServiceMBean.start()`
`void` | `MuleService.start()`
`void` | `ModelServiceMBean.start()`
`void` | `ModelService.start()`
`void` | `ConnectorServiceMBean.startConnector()`
`void` | `ConnectorService.startConnector()`
`void` | `ServiceService.stop()`
`void` | `RegistryServiceMBean.stop()`
`void` | `MuleServiceMBean.stop()`
`void` | `MuleService.stop()`
`void` | `ModelServiceMBean.stop()`
`void` | `ModelService.stop()`
`void` | `ConnectorServiceMBean.stopConnector()`
`void` | `ConnectorService.stopConnector()`

Uses of MuleException in org.mule.module.rss.endpoint

Methods in org.mule.module.rss.endpoint that throw MuleException
`boolean` | `RssInboundEndpoint.onMessage(MuleMessage message)`

Uses of MuleException in org.mule.module.rss.routing

Methods in org.mule.module.rss.routing that throw MuleException
`protected List<MuleMessage>` | `FeedSplitter.splitMessage(MuleEvent event)`

Uses of MuleException in org.mule.module.scripting.builders

Constructors in org.mule.module.scripting.builders that throw MuleException
`ScriptConfigurationBuilder(String configResource)`
`ScriptConfigurationBuilder(String[] configResources)`
`ScriptConfigurationBuilder(String scriptEngineName, String configResource)`
`ScriptConfigurationBuilder(String scriptEngineName, String[] configResources)`

Uses of MuleException in org.mule.module.scripting.component

Methods in org.mule.module.scripting.component that throw MuleException
`protected void` | `ScriptComponent.configureComponentBindings()`

Uses of MuleException in org.mule.module.spring.events

Methods in org.mule.module.spring.events that throw MuleException
`protected Service` | `MuleEventMulticaster.getDefaultService()`
`protected void` | `MuleEventMulticaster.registerConnectors()`
`protected void` | `MuleEventMulticaster.registerMulticasterComponent()`
`protected void` | `MuleEventMulticaster.registerTransformers()`
`protected void` | `MuleEventMulticaster.setSubscriptionsOnService(Service service)`

Uses of MuleException in org.mule.module.sxc

Methods in org.mule.module.sxc that throw MuleException
`boolean` | `SxcFilteringOutboundRouter.isMatch(MuleMessage message)`
`boolean` | `SxcFilteringOutboundRouter.testMatch(MuleMessage message)`

Uses of MuleException in org.mule.module.ws.construct

Constructors in org.mule.module.ws.construct that throw MuleException
`WSProxy(String name, MuleContext muleContext, MessageSource messageSource, OutboundEndpoint outboundEndpoint)`
`WSProxy(String name, MuleContext muleContext, MessageSource messageSource, OutboundEndpoint outboundEndpoint, String wsdlContents)`
`WSProxy(String name, MuleContext muleContext, MessageSource messageSource, OutboundEndpoint outboundEndpoint, URI wsdlUri)`

Uses of MuleException in org.mule.module.ws.construct.builder

Methods in org.mule.module.ws.construct.builder that throw MuleException
`protected WSProxy` | `WSProxyBuilder.buildFlowConstruct(MuleContext muleContext)`

Uses of MuleException in org.mule.processor

Methods in org.mule.processor that return MuleException
`protected MuleException` | `AbstractFilteringMessageProcessor.filterUnacceptedException(MuleEvent event)`

Methods in org.mule.processor that throw MuleException
`protected MuleEvent` | `InvokerMessageProcessor.createResultEvent(MuleEvent event, Object result)`
`protected MuleEvent` | `AbstractFilteringMessageProcessor.handleUnaccepted(MuleEvent event)`
`MuleEvent` | `TransactionalInterceptingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `StopFurtherMessageProcessingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `SecurityFilterMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `NullMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `InvokerMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ExceptionHandlingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `AsyncInterceptingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `AbstractResponseMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `AbstractFilteringMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `AbstractDynamicMessageProcessor.process(MuleEvent event)`
`protected MuleEvent` | `AbstractInterceptingMessageProcessor.processNext(MuleEvent event)`
`protected void` | `SedaStageInterceptingMessageProcessor.processNextAsync(MuleEvent event)`
`protected void` | `AsyncInterceptingMessageProcessor.processNextAsync(MuleEvent event)`
`protected MuleEvent` | `AsyncInterceptingMessageProcessor.processNextTimed(MuleEvent event)`
`protected MuleEvent` | `ResponseMessageProcessorAdapter.processResponse(MuleEvent event)`
`protected abstract MuleEvent` | `AbstractResponseMessageProcessor.processResponse(MuleEvent processNext)`
`protected abstract MessageProcessor` | `AbstractDynamicMessageProcessor.resolveMessageProcessor(MuleEvent event)` Determines which MessageProcessor should be used.
`void` | `SedaStageInterceptingMessageProcessor.start()`
`void` | `ResponseMessageProcessorAdapter.start()`
`void` | `AsyncInterceptingMessageProcessor.start()`
`void` | `AbstractMessageProcessorOwner.start()`
`void` | `SedaStageInterceptingMessageProcessor.stop()`
`void` | `ResponseMessageProcessorAdapter.stop()`
`void` | `AsyncInterceptingMessageProcessor.stop()`
`void` | `AbstractMessageProcessorOwner.stop()`

Uses of MuleException in org.mule.processor.chain

Methods in org.mule.processor.chain that throw MuleException
`MessageProcessorChain` | `DefaultMessageProcessorChainBuilder.build()` This builder supports the chaining together of message processors that intercept and also those that don't.
`protected MuleEvent` | `InterceptingChainLifecycleWrapper.doProcess(MuleEvent event)`
`protected MuleEvent` | `DefaultMessageProcessorChain.doProcess(MuleEvent event)`
`protected abstract MuleEvent` | `AbstractMessageProcessorChain.doProcess(MuleEvent event)`
`protected MessageProcessor` | `AbstractMessageProcessorChainBuilder.initializeMessageProcessor(Object processor)`
`MuleEvent` | `AbstractMessageProcessorChain.process(MuleEvent event)`
`void` | `AbstractMessageProcessorChain.start()`
`void` | `AbstractMessageProcessorChain.stop()`

Uses of MuleException in org.mule.registry

Methods in org.mule.registry that throw MuleException
`Object` | `MuleRegistryHelper.applyLifecycle(Object object)` Will execute any lifecycle phases on an object without actually registering the object in the registry.
`Object` | `MuleRegistryHelper.applyLifecycle(Object object, String phase)`
`Object` | `MuleRegistryHelper.applyProcessors(Object object)` Will execute any processors on an object without actually registering the object in the registry.
`Object` | `MuleRegistryHelper.applyProcessors(Object object, int flags)` Will execute any processors on an object without actually registering the object in the registry.
`Object` | `MuleRegistryHelper.applyProcessorsAndLifecycle(Object object)` Will execute any processors on an object and fire any lifecycle methods according to the current lifecycle without actually registering the object in the registry.
`void` | `MuleRegistryHelper.registerAgent(Agent agent)`
`void` | `MuleRegistryHelper.registerConnector(Connector connector)`
`void` | `MuleRegistryHelper.registerEndpoint(ImmutableEndpoint endpoint)`
`void` | `MuleRegistryHelper.registerEndpointBuilder(String name, EndpointBuilder builder)`
`void` | `MuleRegistryHelper.registerFlowConstruct(FlowConstruct flowConstruct)`
`void` | `MuleRegistryHelper.registerModel(Model model)`
`void` | `MuleRegistryHelper.registerService(Service service)`
`void` | `MuleRegistryHelper.registerTransformer(Transformer transformer)`
`void` | `MuleRegistryHelper.unregisterAgent(String agentName)`
`void` | `MuleRegistryHelper.unregisterConnector(String connectorName)`
`void` | `MuleRegistryHelper.unregisterEndpoint(String endpointName)`
`void` | `MuleRegistryHelper.unregisterFlowConstruct(String flowConstructName)`
`void` | `MuleRegistryHelper.unregisterModel(String modelName)`
`void` | `MuleRegistryHelper.unregisterService(String serviceName)`
`void` | `MuleRegistryHelper.unregisterTransformer(String transformerName)`

Uses of MuleException in org.mule.retry

Subclasses of MuleException in org.mule.retry
`class` | `RetryPolicyExhaustedException` This exception is thrown when a Retry policy has made all the retry attempts it wants to make and is still failing.

Uses of MuleException in org.mule.routing

Subclasses of MuleException in org.mule.routing
`class` | `AggregationException` TODO document

Methods in org.mule.routing that return MuleException
`protected MuleException` | `MessageFilter.filterUnacceptedException(MuleEvent event)`

Methods in org.mule.routing that throw MuleException
`boolean` | `RoundRobin.isMatch(MuleMessage message)`
`boolean` | `FirstSuccessful.isMatch(MuleMessage message)`
`MuleEvent` | `WireTap.process(MuleEvent event)`
`MuleEvent` | `Resequencer.process(MuleEvent event)`
`MuleEvent` | `AbstractSplitter.process(MuleEvent event)`
`MuleEvent` | `AbstractSelectiveRouter.process(MuleEvent event)`
`MuleEvent` | `AbstractMatchingRouter.process(MuleEvent event)`
`MuleEvent` | `AbstractAggregator.process(MuleEvent event)`
`protected MuleEvent` | `AbstractMatchingRouter.processDefaultRoute(MuleEvent event)`
`protected MuleEvent` | `IdempotentMessageFilter.processNext(MuleEvent event)`
`protected List<MuleEvent>` | `AbstractSplitter.processParts(List parts, MuleEvent event)`
`protected abstract List<MuleMessage>` | `AbstractSplitter.splitMessage(MuleEvent event)`
`void` | `MessageProcessorFilterPair.start()`
`void` | `MessageFilter.start()`
`void` | `AbstractSelectiveRouter.start()`
`void` | `MessageProcessorFilterPair.stop()`
`void` | `MessageFilter.stop()`
`void` | `AbstractSelectiveRouter.stop()`

Uses of MuleException in org.mule.routing.correlation

Subclasses of MuleException in org.mule.routing.correlation
`class` | `CorrelationTimeoutException`

Uses of MuleException in org.mule.routing.outbound

Methods in org.mule.routing.outbound that throw MuleException
`void` | `OutboundPassThroughRouter.addRoute(MessageProcessor target)`
`void` | `FilteringOutboundRouter.addRoute(MessageProcessor target)`
`void` | `AbstractOutboundRouter.addRoute(MessageProcessor route)`
`protected OutboundEndpoint` | `AbstractRecipientList.getRecipientEndpoint(MuleMessage message, Object recipient)`
`protected OutboundEndpoint` | `AbstractRecipientList.getRecipientEndpointFromString(MuleMessage message, String recipient)`
`protected OutboundEndpoint` | `AbstractRecipientList.getRecipientEndpointFromUri(EndpointURI uri)`
`boolean` | `TransformerRouter.isMatch(MuleMessage message)` Deprecated.
`boolean` | `FilteringOutboundRouter.isMatch(MuleMessage message)`
`protected MessageProcessor` | `EndpointSelector.lookupEndpoint(String endpointName)`
`MuleEvent` | `AbstractOutboundRouter.process(MuleEvent event)`
`void` | `AbstractOutboundRouter.removeRoute(MessageProcessor route)`
`protected MuleEvent` | `AbstractOutboundRouter.sendRequest(MuleEvent routedEvent, MuleMessage message, MessageProcessor route, boolean awaitResponse)`
`protected MuleEvent` | `AbstractOutboundRouter.sendRequestEvent(MuleEvent routedEvent, MuleMessage message, MessageProcessor route, boolean awaitResponse)` Send message event to destination.
`void` | `AbstractOutboundRouter.setMessageProcessors(List<MessageProcessor> routes)` Deprecated.
`void` | `OutboundPassThroughRouter.setRoutes(List<MessageProcessor> endpoints)`
`void` | `AbstractOutboundRouter.setRoutes(List<MessageProcessor> routes)`
`void` | `AbstractOutboundRouter.start()`
`void` | `AbstractOutboundRouter.stop()`

Uses of MuleException in org.mule.routing.requestreply

Methods in org.mule.routing.requestreply that throw MuleException
`MuleEvent` | `SimpleRequestReplyReplier.process(MuleEvent event)`
`MuleEvent` | `ReplyToPropertyRequestReplyReplier.process(MuleEvent event)`
`MuleEvent` | `AbstractAsyncRequestReplyRequester.process(MuleEvent event)`
`protected void` | `ReplyToPropertyRequestReplyReplier.processReplyTo(MuleEvent event, MuleEvent result, ReplyToHandler replyToHandler, Object replyTo)`
`protected void` | `SimpleAsyncRequestReplyRequester.sendAsyncRequest(MuleEvent event)`
`protected void` | `AbstractAsyncRequestReplyRequester.sendAsyncRequest(MuleEvent event)`
`protected void` | `SimpleAsyncRequestReplyRequester.setAsyncReplyProperties(MuleEvent event)`
`void` | `SimpleAsyncRequestReplyRequester.start()`
`void` | `SimpleAsyncRequestReplyRequester.stop()`

Uses of MuleException in org.mule.security

Methods in org.mule.security that throw MuleException
`protected void` | `AbstractEndpointSecurityFilter.updatePayload(MuleMessage message, Object payload, MuleEvent event)`

Uses of MuleException in org.mule.service

Methods in org.mule.service that throw MuleException
`void` | `ServiceCompositeMessageSource.addSource(MessageSource source)`
`protected void` | `AbstractService.buildServiceMessageProcessorChain()`
`protected void` | `ServiceCompositeMessageSource.createMessageProcessorChain()`
`protected void` | `ServiceAsyncReplyCompositeMessageSource.createMessageProcessorChain()`
`void` | `AbstractService.dispatchEvent(MuleEvent event)` Deprecated.
`protected void` | `AbstractService.doForceStop()`
`protected void` | `AbstractService.doPause()` Custom components can execute code necessary to put the service in a paused state here.
`protected void` | `AbstractService.doResume()` Custom components can execute code necessary to resume a service once it has been paused If a developer overloads this method the doPause() method MUST also be overloaded to avoid inconsistent state in the service
`protected void` | `AbstractService.doStart()`
`protected void` | `AbstractService.doStop()`
`void` | `ServiceLifecycleManager.fireDisposePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `ServiceLifecycleManager.fireInitialisePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `ServiceLifecycleManager.firePausePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `ServiceLifecycleManager.fireResumePhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `ServiceLifecycleManager.fireStartPhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `ServiceLifecycleManager.fireStopPhase(LifecycleCallback<FlowConstruct> callback)`
`void` | `AbstractService.forceStop()`
`void` | `Pausable.pause()`
`void` | `AbstractService.pause()` Pauses event processing for a single Mule Service.
`MuleEvent` | `AbstractService.process(MuleEvent event)`
`void` | `ServiceCompositeMessageSource.removeSource(MessageSource source)`
`void` | `Resumable.resume()`
`void` | `AbstractService.resume()` Resumes a single Mule Service that has been paused.
`MuleEvent` | `AbstractService.sendEvent(MuleEvent event)` Deprecated.
`void` | `ServiceCompositeMessageSource.setMessageSources(List<MessageSource> sources)`
`void` | `ServiceCompositeMessageSource.start()`
`void` | `AbstractService.start()`
`protected void` | `AbstractService.startIfStartable(Object candidate)`
`void` | `ServiceCompositeMessageSource.stop()`
`void` | `AbstractService.stop()`
`protected void` | `AbstractService.stopIfStoppable(Object candidate)`

Constructors in org.mule.service that throw MuleException
`ServiceLifecycleManager(FlowConstruct service, MuleContext muleContext)`

Uses of MuleException in org.mule.service.processor

Methods in org.mule.service.processor that throw MuleException
`MuleEvent` | `ServiceStatisticsMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ServiceSetEventRequestContextMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ServiceOutboundStatisticsMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ServiceOutboundMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ServiceLoggingMessageProcessor.process(MuleEvent event)`
`MuleEvent` | `ServiceInternalMessageProcessor.process(MuleEvent event)` We do all this together here rather than chaining them in order to conserve 2.x exception handling behaviour
`protected void` | `ServiceInternalMessageProcessor.processReplyTo(MuleEvent event, MuleEvent result, ReplyToHandler replyToHandler, Object replyTo)`

Uses of MuleException in org.mule.session

Methods in org.mule.session that throw MuleException
`void` | `DefaultMuleSession.initAfterDeserialisation(MuleContext muleContext)` Invoked after deserialization.
`MuleSession` | `SimpleSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`MuleSession` | `SerializeOnlySessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`MuleSession` | `SerializeAndEncodeSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`MuleSession` | `NullSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`MuleSession` | `LegacySessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)` Deprecated.
`void` | `SimpleSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`void` | `SerializeOnlySessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`void` | `NullSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`void` | `LegacySessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`void` | `SimpleSessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`
`void` | `SerializeOnlySessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`
`void` | `SerializeAndEncodeSessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`
`void` | `NullSessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`
`void` | `LegacySessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)` Deprecated.

Constructors in org.mule.session that throw MuleException
`DefaultMuleSession(MuleMessage message, SessionHandler requestSessionHandler, FlowConstruct flowConstruct, MuleContext muleContext)` Deprecated. Use DefaultMuleSession(Service service, MuleContext muleContext) instead
`DefaultMuleSession(MuleMessage message, SessionHandler requestSessionHandler, MuleContext muleContext)` Deprecated. Use DefaultMuleSession(MuleContext muleContext) instead

Uses of MuleException in org.mule.source

Methods in org.mule.source that throw MuleException
`void` | `StartableCompositeMessageSource.addSource(MessageSource source)`
`void` | `StartableCompositeMessageSource.removeSource(MessageSource source)`
`void` | `StartableCompositeMessageSource.setMessageSources(List<MessageSource> sources)`
`void` | `StartableCompositeMessageSource.start()`
`void` | `StartableCompositeMessageSource.stop()`

Uses of MuleException in org.mule.tck

Methods in org.mule.tck that throw MuleException
`void` | `AbstractScriptConfigBuilderTestCase.testEndpointConfig()`
`void` | `AbstractConfigBuilderTestCase.testEndpointConfig()`
`void` | `AbstractScriptConfigBuilderTestCase.testGlobalEndpointConfig()`
`void` | `AbstractConfigBuilderTestCase.testGlobalEndpointConfig()`

Uses of MuleException in org.mule.tck.exceptions

Subclasses of MuleException in org.mule.tck.exceptions
`class` | `FunctionalTestException`

Uses of MuleException in org.mule.transaction

Subclasses of MuleException in org.mule.transaction
`class` | `IllegalTransactionStateException` `IllegalTransactionStateException` TODO (document class)
`class` | `TransactionInProgressException` `TransactionInProgressException` is thrown if a new transaction is started when there is one already in progress.
`class` | `TransactionNotInProgressException` `TransactionNotInProgressException` TODO (document class)
`class` | `TransactionRollbackException`
`class` | `TransactionStatusException`

Uses of MuleException in org.mule.transformer

Methods in org.mule.transformer that throw MuleException
`MuleEvent` | `AbstractTransformer.process(MuleEvent event)`

Uses of MuleException in org.mule.transformer.wire

Methods in org.mule.transformer.wire that throw MuleException
`Object` | `TransformerPairWireFormat.read(InputStream in)`
`void` | `TransformerPairWireFormat.write(OutputStream out, Object o, String encoding)`

Uses of MuleException in org.mule.transport

Subclasses of MuleException in org.mule.transport
`class` | `ConnectException` When this exception is thrown it will trigger a retry (reconnection) policy to go into effect if one is configured.

Methods in org.mule.transport that throw MuleException
`void` | `KeyedPoolMessageRequesterFactoryAdapter.activate(InboundEndpoint endpoint, MessageRequester requester)`
`void` | `AbstractMessageRequesterFactory.activate(InboundEndpoint endpoint, MessageRequester requester)`
`void` | `KeyedPoolMessageDispatcherFactoryAdapter.activate(OutboundEndpoint endpoint, MessageDispatcher dispatcher)`
`void` | `AbstractMessageDispatcherFactory.activate(OutboundEndpoint endpoint, MessageDispatcher dispatcher)`
`protected void` | `AbstractMessageReceiver.applyInboundTransformers(MuleEvent event)`
`protected void` | `AbstractMessageRequester.applyInboundTransformers(MuleMessage message)`
`protected void` | `KeyedPoolMessageDispatcherFactoryAdapter.applyLifecycle(MessageDispatcher dispatcher)`
`protected void` | `KeyedPoolMessageRequesterFactoryAdapter.applyLifecycle(MessageRequester requester, boolean created)`
`protected void` | `AbstractMessageDispatcher.applyOutboundTransformers(MuleEvent event)`
`protected void` | `AbstractMessageReceiver.applyResponseTransformers(MuleEvent event)`
`protected void` | `AbstractMessageDispatcher.applyResponseTransformers(MuleEvent event)`
`protected void` | `AbstractTransportMessageHandler.callDoStartWhenItIsConnected()` This method will block until `AbstractTransportMessageHandler.connected` is true and then will call `AbstractTransportMessageHandler.doStart()`.
`MessageRequester` | `UnsupportedMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageRequester` | `KeyedPoolMessageRequesterFactoryAdapter.create(InboundEndpoint endpoint)`
`abstract MessageRequester` | `AbstractMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `UnsupportedMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`MessageDispatcher` | `KeyedPoolMessageDispatcherFactoryAdapter.create(OutboundEndpoint endpoint)`
`abstract MessageDispatcher` | `AbstractMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`MessageProcessor` | `AbstractConnector.createDispatcherMessageProcessor(OutboundEndpoint endpoint)`
`protected MuleEvent` | `AbstractMessageReceiver.createMuleEvent(MuleMessage message, OutputStream outputStream)`
`MuleMessage` | `AbstractTransportMessageHandler.createMuleMessage(Object transportMessage)` Uses this object's `MuleMessageFactory` to create a new `MuleMessage` instance.
`MuleMessage` | `AbstractTransportMessageHandler.createMuleMessage(Object transportMessage, MuleMessage previousMessage, String encoding)` Uses this object's `MuleMessageFactory` to create a new `MuleMessage` instance.
`MuleMessage` | `AbstractTransportMessageHandler.createMuleMessage(Object transportMessage, String encoding)` Uses this object's `MuleMessageFactory` to create a new `MuleMessage` instance.
`protected MuleMessage` | `AbstractTransportMessageHandler.createNullMuleMessage()` Uses this object's `MuleMessageFactory` to create a new `MuleMessage` instance.
`void` | `TransactedPollingMessageReceiver.doStart()`
`protected void` | `AbstractTransportMessageHandler.doStart()`
`protected void` | `AbstractPollingMessageReceiver.doStart()`
`protected abstract void` | `AbstractConnector.doStart()` Template method to perform any work when starting the connectoe
`protected void` | `AbstractTransportMessageHandler.doStop()`
`protected void` | `AbstractPollingMessageReceiver.doStop()`
`protected abstract void` | `AbstractConnector.doStop()` Template method to perform any work when stopping the connectoe
`void` | `ConnectorLifecycleManager.fireDisposePhase(LifecycleCallback<Connector> callback)`
`void` | `ConnectableLifecycleManager.fireDisposePhase(LifecycleCallback<O> callback)`
`void` | `ConnectorLifecycleManager.fireInitialisePhase(LifecycleCallback<Connector> callback)`
`void` | `ConnectableLifecycleManager.fireInitialisePhase(LifecycleCallback<O> callback)`
`void` | `ConnectorLifecycleManager.fireStartPhase(LifecycleCallback<Connector> callback)`
`void` | `ConnectableLifecycleManager.fireStartPhase(LifecycleCallback<O> callback)`
`void` | `ConnectorLifecycleManager.fireStopPhase(LifecycleCallback<Connector> callback)`
`void` | `ConnectableLifecycleManager.fireStopPhase(LifecycleCallback<O> callback)`
`protected WorkManager` | `AbstractConnector.getDispatcherWorkManager()` Returns a work manager for message dispatchers.
`protected OutboundEndpoint` | `DefaultReplyToHandler.getEndpoint(MuleEvent event, String endpointUri)`
`OutputStream` | `AbstractConnector.getOutputStream(OutboundEndpoint endpoint, MuleEvent event)` Will get the output stream for this type of transport.
`protected WorkManager` | `AbstractConnector.getReceiverWorkManager()` Returns a work manager for message receivers.
`protected WorkManager` | `AbstractConnector.getRequesterWorkManager()` Returns a work manager for message requesters.
`protected abstract WorkManager` | `AbstractTransportMessageHandler.getWorkManager()`
`protected WorkManager` | `AbstractMessageRequester.getWorkManager()`
`protected void` | `AbstractConnector.initWorkManagers()`
`MuleEvent` | `AbstractMessageDispatcher.process(MuleEvent event)`
`void` | `DefaultReplyToHandler.processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)`
`MuleEvent` | `AbstractMessageReceiver.routeMessage(MuleMessage message)`
`MuleEvent` | `AbstractMessageReceiver.routeMessage(MuleMessage message, MuleSession session, Transaction trans, OutputStream outputStream)`
`MuleEvent` | `AbstractMessageReceiver.routeMessage(MuleMessage message, Transaction trans)`
`MuleEvent` | `AbstractMessageReceiver.routeMessage(MuleMessage message, Transaction trans, OutputStream outputStream)`
`void` | `AbstractTransportMessageHandler.start()` This method will start the connectable, calling `AbstractTransportMessageHandler.connect()` if it is needed.
`void` | `AbstractConnector.start()`
`protected void` | `AbstractConnector.startAfterConnect()`
`void` | `AbstractTransportMessageHandler.stop()`
`void` | `AbstractConnector.stop()`

Uses of MuleException in org.mule.transport.ajax

Methods in org.mule.transport.ajax that throw MuleException
`MessageDispatcher` | `AjaxMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `AjaxMessageReceiver.doStart()`
`void` | `AjaxReplyToHandler.processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)`
`void` | `BayeuxAware.setBayeux(org.mortbay.cometd.AbstractBayeux bayeux)`

Uses of MuleException in org.mule.transport.ajax.container

Methods in org.mule.transport.ajax.container that throw MuleException
`void` | `AjaxServletConnector.setBayeux(org.mortbay.cometd.AbstractBayeux bayeux)`

Uses of MuleException in org.mule.transport.ajax.embedded

Methods in org.mule.transport.ajax.embedded that throw MuleException
`protected void` | `AjaxConnector.doStart()`

Uses of MuleException in org.mule.transport.ejb

Methods in org.mule.transport.ejb that throw MuleException
`MessageDispatcher` | `EjbMessageDispatcherFactory.create(OutboundEndpoint endpoint)`

Uses of MuleException in org.mule.transport.email

Methods in org.mule.transport.email that throw MuleException
`MessageRequester` | `RetrieveMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `SmtpMessageDispatcherFactory.create(OutboundEndpoint endpoint)` Creates a new message dispatcher instance, initialised with the passed endpoint.
`protected void` | `RetrieveMessageReceiver.doStart()`
`protected void` | `AbstractMailConnector.doStart()`
`protected void` | `AbstractMailConnector.doStop()`

Uses of MuleException in org.mule.transport.file

Methods in org.mule.transport.file that throw MuleException
`MessageRequester` | `FileMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `FileMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `FileConnector.doStart()`
`protected void` | `FileConnector.doStop()`
`Object` | `FileMessageRequester.getDelegateSession()` There is no associated session for a file connector
`Object` | `FileMessageDispatcher.getDelegateSession()` There is no associated session for a file connector
`protected static File` | `FileMessageDispatcher.getNextFile(String dir, Object filter)`
`OutputStream` | `FileConnector.getOutputStream(OutboundEndpoint endpoint, MuleEvent event)` Well get the output stream (if any) for this type of transport.
`void` | `FileMessageReceiver.processFile(File sourceFile)`

Constructors in org.mule.transport.file that throw MuleException
`FileMessageRequester(InboundEndpoint endpoint)`

Uses of MuleException in org.mule.transport.ftp

Methods in org.mule.transport.ftp that throw MuleException
`MessageRequester` | `FtpMessageRequesterFactory.create(InboundEndpoint endpoint)` Creates a new message requester instance, initialised with the passed endpoint.
`MessageDispatcher` | `FtpMessageDispatcherFactory.create(OutboundEndpoint endpoint)` Creates a new message dispatcher instance, initialised with the passed endpoint.
`protected void` | `FtpConnector.doStart()`
`protected void` | `FtpConnector.doStop()`
`OutputStream` | `FtpConnector.getOutputStream(OutboundEndpoint endpoint, MuleEvent event)` Well get the output stream (if any) for this type of transport.

Uses of MuleException in org.mule.transport.http

Methods in org.mule.transport.http that throw MuleException
`protected HttpResponse` | `HttpMessageReceiver.HttpWorker.buildFailureResponse(RequestLine requestLine, MuleMessage message)`
`MessageRequester` | `HttpClientMessageRequesterFactory.create(InboundEndpoint endpoint)` Creates a new message requester instance, initialised with the passed endpoint.
`MessageDispatcher` | `HttpsClientMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`MessageDispatcher` | `HttpClientMessageDispatcherFactory.create(OutboundEndpoint endpoint)` Creates a new message dispatcher instance, initialised with the passed endpoint.
`protected HttpResponse` | `HttpMessageReceiver.HttpWorker.doBad(RequestLine requestLine)`
`protected HttpResponse` | `HttpMessageReceiver.HttpWorker.doOtherValid(RequestLine requestLine, String method)`
`protected HttpResponse` | `HttpMessageReceiver.HttpWorker.doRequest(HttpRequest request)`
`protected MuleMessage` | `HttpClientMessageDispatcher.getResponseFromMethod(HttpMethod httpMethod, ExceptionPayload ep)`
`protected MuleMessage` | `HttpClientMessageDispatcher.handleRedirect(HttpMethod method, MuleEvent event)`
`protected HttpResponse` | `HttpMessageReceiver.HttpWorker.processRequest(HttpRequest request)`
`MuleSession` | `HttpSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message)`
`void` | `HttpSessionHandler.retrieveSessionInfoFromMessage(MuleMessage message, MuleSession session)` Deprecated. Use retrieveSessionInfoFromMessage(MuleMessage message) instead
`void` | `HttpSessionHandler.storeSessionInfoToMessage(MuleSession session, MuleMessage message)`
`protected HttpResponse` | `HttpMessageReceiver.transformResponse(Object response, MuleEvent event)`

Uses of MuleException in org.mule.transport.http.components

Subclasses of MuleException in org.mule.transport.http.components
`class` | `RestServiceException`

Uses of MuleException in org.mule.transport.ibean

Methods in org.mule.transport.ibean that throw MuleException
`MessageDispatcher` | `IBeansMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`void` | `IBeansConnector.doStart()`
`void` | `IBeansConnector.doStop()`

Constructors in org.mule.transport.ibean that throw MuleException
`IBeansMessageDispatcher(OutboundEndpoint endpoint)`
`IBeansMessageReceiver(Connector connector, Service service, InboundEndpoint endpoint)`

Uses of MuleException in org.mule.transport.jdbc

Methods in org.mule.transport.jdbc that throw MuleException
`MessageRequester` | `JdbcMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `JdbcMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `JdbcConnector.doStart()`
`protected void` | `JdbcConnector.doStop()`

Uses of MuleException in org.mule.transport.jms

Methods in org.mule.transport.jms that throw MuleException
`protected void` | `JmsMessageDispatcher.applyOutboundTransformers(MuleEvent event)`
`MessageRequester` | `JmsMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `JmsMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `TransactedSingleResourceJmsMessageReceiver.doStart()`
`protected void` | `MultiConsumerJmsMessageReceiver.doStart()`
`protected void` | `JmsMessageReceiver.doStart()` Deprecated.
`protected void` | `JmsConnector.doStart()`
`protected void` | `TransactedSingleResourceJmsMessageReceiver.doStop()`
`protected void` | `MultiConsumerJmsMessageReceiver.doStop()`
`protected void` | `JmsMessageReceiver.doStop()` Deprecated.
`protected void` | `JmsConnector.doStop()`
`void` | `JmsReplyToHandler.processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)`

Uses of MuleException in org.mule.transport.jms.redelivery

Subclasses of MuleException in org.mule.transport.jms.redelivery
`class` | `MessageRedeliveredException`

Methods in org.mule.transport.jms.redelivery that throw MuleException
`void` | `RedeliveryHandler.handleRedelivery(Message message, ImmutableEndpoint endpoint, FlowConstruct flow)` Process the redelivered message.
`void` | `JmsXRedeliveryHandler.handleRedelivery(Message message, ImmutableEndpoint endpoint, FlowConstruct flow)` process the redelivered message.
`void` | `CountingRedeliveryHandler.handleRedelivery(Message message, ImmutableEndpoint endpoint, FlowConstruct flow)` process the redelivered message.
`abstract void` | `AbstractRedeliveryHandler.handleRedelivery(Message message, ImmutableEndpoint endpoint, FlowConstruct flow)`

Uses of MuleException in org.mule.transport.polling

Methods in org.mule.transport.polling that throw MuleException
`protected void` | `MessageProcessorPollingConnector.doStart()`
`protected void` | `MessageProcessorPollingConnector.doStop()`

Uses of MuleException in org.mule.transport.quartz

Methods in org.mule.transport.quartz that throw MuleException
`MessageDispatcher` | `QuartzMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `QuartzMessageReceiver.doStart()`
`protected void` | `QuartzConnector.doStart()`
`protected void` | `QuartzMessageReceiver.doStop()`
`protected void` | `QuartzConnector.doStop()`

Uses of MuleException in org.mule.transport.quartz.config

Methods in org.mule.transport.quartz.config that throw MuleException
`InboundEndpoint` | `ScheduleConfigBuilder.buildScheduler()`
`protected AnnotatedEndpointData` | `ScheduleAnnotationParser.createEndpointData(Annotation annotation)`
`protected QuartzConnector` | `ScheduleAnnotationParser.getConnector()`
`protected String[]` | `ScheduleAnnotationParser.getProperties(Schedule schedule)`
`InboundEndpoint` | `ScheduleAnnotationParser.parseInboundEndpoint(Annotation annotation, Map metaInfo)`

Constructors in org.mule.transport.quartz.config that throw MuleException
`ScheduleConfigBuilder(String scheduleId, MuleContext muleContext)`

Uses of MuleException in org.mule.transport.quartz.jobs

Methods in org.mule.transport.quartz.jobs that throw MuleException
`void` | `PollEndpointJob.start()`
`void` | `PollEndpointJob.stop()`

Uses of MuleException in org.mule.transport.rmi

Methods in org.mule.transport.rmi that throw MuleException
`MessageDispatcher` | `RmiMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `RmiConnector.doStart()`
`protected void` | `RmiCallbackMessageReceiver.doStart()`
`protected void` | `RmiConnector.doStop()`
`protected void` | `RmiCallbackMessageReceiver.doStop()`
`Method` | `RmiConnector.getMethodObject(Remote remoteObject, MuleEvent event)` Helper method for Dispatchers and Receives to extract the correct method from a Remote object
`MuleEvent` | `RmiCallbackMessageReceiver.routeMessage(Object payload)`

Uses of MuleException in org.mule.transport.service

Subclasses of MuleException in org.mule.transport.service
`class` | `TransportFactoryException` `TransportFactoryException` is thrown by the endpoint factory if the endpoint service cannot be found in the META-INF/services directory or if any part of the endpoint cannot be instanciated.
`class` | `TransportServiceException` `TransportServiceException` is thrown if a ProviderServicedescriptor has a service error set.
`class` | `TransportServiceNotFoundException` `TransportServiceNotFoundException` is thorown if no matching service endpoint descriptor is found for the connector protocol.

Methods in org.mule.transport.service that throw MuleException
`MessageReceiver` | `TransportServiceDescriptor.createMessageReceiver(Connector connector, FlowConstruct flowConstruct, InboundEndpoint endpoint)`
`MessageReceiver` | `DefaultTransportServiceDescriptor.createMessageReceiver(Connector connector, FlowConstruct flowConstruct, InboundEndpoint endpoint)`
`MessageReceiver` | `TransportServiceDescriptor.createMessageReceiver(Connector connector, FlowConstruct flowConstruct, InboundEndpoint endpoint, Object... args)`
`MessageReceiver` | `DefaultTransportServiceDescriptor.createMessageReceiver(Connector connector, FlowConstruct flowConstruct, InboundEndpoint endpoint, Object... args)`

Uses of MuleException in org.mule.transport.servlet

Methods in org.mule.transport.servlet that throw MuleException
`protected void` | `ServletMessageReceiver.doStart()`
`protected void` | `ServletConnector.doStart()`
`protected void` | `ServletMessageReceiver.doStop()`
`protected void` | `ServletConnector.doStop()`
`protected InboundEndpoint` | `MuleRESTReceiverServlet.getEndpointForURI(HttpServletRequest httpServletRequest)`
`protected MuleEvent` | `MuleReceiverServlet.routeMessage(MessageReceiver receiver, MuleMessage requestMessage, HttpServletRequest request)`

Uses of MuleException in org.mule.transport.servlet.jetty

Methods in org.mule.transport.servlet.jetty that throw MuleException
`protected void` | `JettyHttpConnector.doStart()`
`protected void` | `JettyHttpConnector.doStop()`
`void` | `JettyContinuationsReplyToHandler.processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)`
`protected MuleEvent` | `JettyContinuationsReceiverServlet.routeMessage(MessageReceiver receiver, MuleMessage requestMessage, HttpServletRequest request)`
`void` | `JettyHttpConnector.MuleReceiverConnectorHolder.start()`
`void` | `ConnectorHolder.start()`
`void` | `AbstractConnectorHolder.start()`
`void` | `JettyHttpConnector.MuleReceiverConnectorHolder.stop()`
`void` | `ConnectorHolder.stop()`
`void` | `AbstractConnectorHolder.stop()`
`void` | `JettyHttpConnector.unregisterListener(MessageReceiver receiver)`

Uses of MuleException in org.mule.transport.soap.axis

Methods in org.mule.transport.soap.axis that throw MuleException
`MessageRequester` | `AxisMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `AxisMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`void` | `AxisServiceComponent.doGet(MuleEventContext context, AxisStringWriter response)`
`protected void` | `AxisMessageReceiver.doStart()`
`protected void` | `AxisConnector.doStart()` Template method to perform any work when starting the connectoe
`protected void` | `AxisMessageReceiver.doStop()`
`protected void` | `AxisConnector.doStop()` Template method to perform any work when stopping the connectoe
`static Class[]` | `AxisServiceProxy.getInterfacesForComponent(Service service)`
`protected Service` | `AxisConnector.getOrCreateAxisComponent()`
`protected void` | `AxisConnector.registerReceiverWithMuleService(MessageReceiver receiver, EndpointURI ep)`
`protected void` | `AxisConnector.unregisterReceiverWithMuleService(MessageReceiver receiver, EndpointURI ep)`

Uses of MuleException in org.mule.transport.soap.axis.extensions

Methods in org.mule.transport.soap.axis.extensions that throw MuleException
`protected OutboundEndpoint` | `UniversalSender.lookupEndpoint(String uri)`

Uses of MuleException in org.mule.transport.soap.axis.wsdl

Methods in org.mule.transport.soap.axis.wsdl that throw MuleException
`MessageDispatcher` | `AxisWsdlMessageDispatcherFactory.create(OutboundEndpoint endpoint)`

Uses of MuleException in org.mule.transport.stdio

Methods in org.mule.transport.stdio that throw MuleException
`MessageDispatcher` | `StdioMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`OutputStream` | `PromptStdioConnector.getOutputStream(ImmutableEndpoint endpoint, MuleMessage message)`

Uses of MuleException in org.mule.transport.tcp

Methods in org.mule.transport.tcp that throw MuleException
`MessageRequester` | `TcpMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `TcpMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`MessageDispatcher` | `LocalSocketTcpMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `TcpMessageReceiver.doStart()`
`protected void` | `TcpConnector.doStart()`
`protected void` | `TcpMessageReceiver.doStop()`
`protected void` | `TcpConnector.doStop()`
`OutputStream` | `TcpConnector.getOutputStream(ImmutableEndpoint endpoint, MuleMessage message)`

Uses of MuleException in org.mule.transport.udp

Methods in org.mule.transport.udp that throw MuleException
`MessageRequester` | `UdpMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `UdpMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `UdpMessageReceiver.doStart()`
`protected void` | `UdpConnector.doStart()`
`protected void` | `UdpMessageReceiver.doStop()`
`protected void` | `UdpConnector.doStop()`

Uses of MuleException in org.mule.transport.vm

Methods in org.mule.transport.vm that throw MuleException
`MessageRequester` | `VMMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `VMMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `VMConnector.doStart()`
`protected void` | `VMConnector.doStop()`
`MuleMessage` | `VMMessageReceiver.onCall(MuleMessage message)`
`void` | `VMMessageReceiver.onMessage(MuleMessage message)`

Uses of MuleException in org.mule.transport.xmpp

Methods in org.mule.transport.xmpp that throw MuleException
`MessageRequester` | `XmppMessageRequesterFactory.create(InboundEndpoint endpoint)`
`MessageDispatcher` | `XmppMessageDispatcherFactory.create(OutboundEndpoint endpoint)`
`protected void` | `XmppMessageReceiver.doStart()`
`protected void` | `XmppConnector.doStart()`
`protected void` | `XmppMessageReceiver.doStop()`
`protected void` | `XmppConnector.doStop()`
`protected void` | `XmppPollingMessageReceiver.processMessage(org.jivesoftware.smack.packet.Message xmppMessage)`

Uses of MuleException in org.mule.util.pool

Methods in org.mule.util.pool that throw MuleException
`void` | `DefaultLifecycleEnabledObjectPool.start()`
`void` | `DefaultLifecycleEnabledObjectPool.stop()`

Uses of MuleException in org.mule.util.xa

Subclasses of MuleException in org.mule.util.xa
`class` | `ResourceManagerException`
`class` | `ResourceManagerSystemException`

Uses of MuleException in org.mule.work

Methods in org.mule.work that throw MuleException
`void` | `MuleWorkManager.start()`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.