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

## Uses of Interface
org.mule.api.context.MuleContextAware

Packages that use MuleContextAware
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.config |
org.mule.api.context.notification |
org.mule.api.endpoint | Endpoint interfaces.
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.routing | Interfaces that define inbound and outbound routing API.
org.mule.api.transformer | Contains the interfaces for transformers and exceptions for the Transformer API.
org.mule.api.transformer.wire |
org.mule.api.util |
org.mule.component |
org.mule.component.simple | A collection of simple mule components that can be useful to simplify configuration while testing.
org.mule.config | Providers Mule Xml configuration support and general configuration classes.
org.mule.config.bootstrap |
org.mule.config.dsl.routers |
org.mule.config.endpoint |
org.mule.config.pool |
org.mule.config.processors |
org.mule.config.spring | Support claases for Load Mule from Spring.
org.mule.config.spring.editors |
org.mule.config.spring.factories |
org.mule.config.spring.parsers.specific | Targetted support for specific components in the Mule system.
org.mule.config.spring.processors |
org.mule.config.support |
org.mule.config.transformer |
org.mule.context.notification | Internal server notification types fired via the MuleManager.
org.mule.endpoint | Implemtation of Mule endpoint uris.
org.mule.endpoint.outbound |
org.mule.enricher |
org.mule.example.bookstore.transformers |
org.mule.example.errorhandler |
org.mule.example.geomail.transformers |
org.mule.example.hello |
org.mule.example.loanbroker.routers |
org.mule.example.loanbroker.transformers |
org.mule.example.notifications |
org.mule.example.scripting |
org.mule.exception |
org.mule.expression |
org.mule.expression.transformers |
org.mule.interceptor |
org.mule.lifecycle |
org.mule.lifecycle.phases |
org.mule.lifecycle.processor |
org.mule.model |
org.mule.model.seda |
org.mule.module.atom |
org.mule.module.atom.endpoint |
org.mule.module.atom.routing |
org.mule.module.atom.transformers |
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.client.remoting.notification |
org.mule.module.cxf |
org.mule.module.cxf.builder |
org.mule.module.cxf.component |
org.mule.module.cxf.config |
org.mule.module.cxf.endpoint |
org.mule.module.ibeans.config |
org.mule.module.ibeans.spi |
org.mule.module.jaas.filters |
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.jersey |
org.mule.module.json.transformers | Transfromers for converting from JavaBeans and collections to JSON and back again.
org.mule.module.management.agent | Management agents including agents for Jdmk, MX4J, and Log4J
org.mule.module.pgp.filters |
org.mule.module.rss.endpoint |
org.mule.module.rss.transformers |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.scripting.expression |
org.mule.module.scripting.transformer |
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.spring.remoting |
org.mule.module.spring.security.filters.http |
org.mule.module.sxc |
org.mule.module.ws.config.spring.factories |
org.mule.module.xml.expression |
org.mule.module.xml.filters | Filters that apply specifically to xml using xml querying mechanisms.
org.mule.module.xml.routing |
org.mule.module.xml.transformer | Xml and Xslt Transformer implementations.
org.mule.module.xml.transformer.jaxb |
org.mule.module.xml.transformer.wire |
org.mule.processor |
org.mule.processor.chain |
org.mule.registry |
org.mule.retry |
org.mule.retry.policies |
org.mule.routing | Defines the core routing patterns supported by mule.
org.mule.routing.filters | Filters are often used by routers to determine if the event should be accepted by the router.
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.security.filters | Core sercurity filter types.
org.mule.service |
org.mule.service.processor |
org.mule.tck.functional | Helper classes and interfaces used by Mule fnctional tests.
org.mule.tck.testmodels.services |
org.mule.tck.transformer |
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.codec | Transformers for Base64, UC and UU encoding/decoding.
org.mule.transformer.compression | Transformers for compressing and uncompressing message payloads.
org.mule.transformer.encryption | Transformers for encrypting and decrypting message payloads.
org.mule.transformer.simple | Basic transformer implementations.
org.mule.transformer.wire |
org.mule.transport.email.transformers | Contains transformers to convert to and from the java.mail.Message type.
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers.
org.mule.transport.file.transformers | Transformers for converting to and from the FileMessage type.
org.mule.transport.http.components |
org.mule.transport.http.transformers |
org.mule.transport.jms.transformers | Contains transformers to convert to and from different javax.jms.Message types
org.mule.transport.quartz.config |
org.mule.transport.quartz.jobs |
org.mule.transport.service | Provides SPI support for building mule connectors and providers using service descriptors.
org.mule.transport.servlet.events |
org.mule.transport.servlet.transformers |
org.mule.transport.xmpp.transformers |
org.mule.util | Common helper classes for reading/writing files setting bean properties and SPI helpers.
org.mule.util.queue | A resource manager that allow access to transactional queues with optional persistence.
org.mule.util.store |
org.mule.work | A javax.resource.spi.WorkManager implementation.

Uses of MuleContextAware in org.mule

Classes in org.mule that implement MuleContextAware
`class` | `AbstractAgent` Implements common methods for all Agents.
`class` | `RouteableExceptionStrategy` `RouteableExceptionStrategy` allows transforming and routing exceptions to outbound routers.

Uses of MuleContextAware in org.mule.agent

Classes in org.mule.agent that implement MuleContextAware
`class` | `AbstractNotificationLoggerAgent` `AbstractNotificationLoggerAgent` Receives Mule server notifications and logs them and can optionally route them to an endpoint.
`class` | `EndpointNotificationLoggerAgent` `EndpointAbstractEventLoggerAgent` will forward server notifications to a configurered endpoint uri.
`class` | `Log4jNotificationLoggerAgent` `AbstractNotificationLoggerAgent` Receives Mule server notifications and logs them and can optionally route them to an endpoint

Uses of MuleContextAware in org.mule.api.config

Subinterfaces of MuleContextAware in org.mule.api.config
`interface` | `ThreadingProfile` Mule uses a few different pools i.e.

Uses of MuleContextAware in org.mule.api.context.notification

Classes in org.mule.api.context.notification that implement MuleContextAware
`class` | `ServerNotification` `ServerNotification` is an event triggered by something happening in the Server itself such as the server starting or a service being registered.

Uses of MuleContextAware in org.mule.api.endpoint

Subinterfaces of MuleContextAware in org.mule.api.endpoint
`interface` | `EndpointBuilder` Constructs endpoints.
`interface` | `EndpointFactory` Endpoint factory creates immutable instances of `ImmutableEndpoint`.

Uses of MuleContextAware in org.mule.api.model

Subinterfaces of MuleContextAware in org.mule.api.model
`interface` | `Model` The `Model` encapsulates and manages the runtime behaviour of a Mule Server instance.

Uses of MuleContextAware in org.mule.api.processor

Classes in org.mule.api.processor that implement MuleContextAware
`class` | `LoggerMessageProcessor` MessageProcessor implementation that logs the current element of a value evaluated from it using an expression evaluator.

Uses of MuleContextAware in org.mule.api.routing

Subinterfaces of MuleContextAware in org.mule.api.routing
`interface` | `OutboundRouter` `OutboundRouter` is used to control outbound routing behaviour for an event.
`interface` | `OutboundRouterCollection` `RouterCollection` defines the interface for a MessageRouter that manages more than one router.

Uses of MuleContextAware in org.mule.api.transformer

Subinterfaces of MuleContextAware in org.mule.api.transformer
`interface` | `MessageTransformer` A transformer intended to transform Mule messages rather than arbitrary objects
`interface` | `Transformer` `Transformer` can be chained together to covert message payloads from one object type to another.

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

Subinterfaces of MuleContextAware in org.mule.api.transformer.wire
`interface` | `WireFormat`

Uses of MuleContextAware in org.mule.api.util

Subinterfaces of MuleContextAware in org.mule.api.util
`interface` | `StreamCloserService` Simple service to close streams of different types.

Uses of MuleContextAware in org.mule.component

Classes in org.mule.component that implement MuleContextAware
`class` | `AbstractComponent` Abstract `Component` to be used by all `Component` implementations.
`class` | `AbstractJavaComponent` Abstract implementation of JavaComponent adds JavaComponent specific's: `EntryPointResolverSet`, `org.mule.api.routing.BindingCollection` and `ObjectFactory`.
`class` | `DefaultJavaComponent` Default implementation of `JavaComponent`.
`class` | `PooledJavaComponent` `PooledJavaComponent` implements pooling.
`class` | `SimpleCallableJavaComponent` Simple `JavaComponent` implementation to be used when `LifecycleAdapter` is not required because i) the object instance implements `Callable` and so entry-point resolution is required and ii) component bindings are not used. An `ObjectFactory` can be set but must return object instances that implement `Callable`.

Uses of MuleContextAware in org.mule.component.simple

Classes in org.mule.component.simple that implement MuleContextAware
`class` | `PassThroughComponent` `PassThroughComponent` will simply return the payload back as the result.

Uses of MuleContextAware in org.mule.config

Classes in org.mule.config that implement MuleContextAware
`class` | `ChainedThreadingProfile` This was written (perhaps too far in advance) with an eye to how we will manage default values in a dynamic environment.
`class` | `DefaultMuleConfiguration` Configuration info.
`class` | `ImmutableThreadingProfile`
`static class` | `ImmutableThreadingProfile.DefaultWorkManagerFactory`
`class` | `MutableThreadingProfile` Partial mutability for a threading profile.

Uses of MuleContextAware in org.mule.config.bootstrap

Classes in org.mule.config.bootstrap that implement MuleContextAware
`class` | `SimpleRegistryBootstrap` This object will load objects defined in a file called `registry-bootstrap.properties` into the local registry.

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

Classes in org.mule.config.dsl.routers that implement MuleContextAware
`class` | `ContentBasedRouter` TODO

Uses of MuleContextAware in org.mule.config.endpoint

Classes in org.mule.config.endpoint that implement MuleContextAware
`class` | `AbstractEndpointAnnotationParser` TODO
`class` | `RegistryBackedAnnotationsParserFactory` Loads the default expression, router and endpoint parsers provided by Mule.

Uses of MuleContextAware in org.mule.config.pool

Classes in org.mule.config.pool that implement MuleContextAware
`class` | `DefaultThreadPoolFactory`
`class` | `ThreadPoolFactory` Uses a standard JDK's SPI discovery mechanism to locate implementations.

Uses of MuleContextAware in org.mule.config.processors

Classes in org.mule.config.processors that implement MuleContextAware
`class` | `DecoratingAnnotatedServiceProcessor` This object processor allows users to register annotated services directly to the registry and have them configured correctly.
`class` | `LookupInjectionProcessor` TODO

Uses of MuleContextAware in org.mule.config.spring

Classes in org.mule.config.spring that implement MuleContextAware
`class` | `MuleConfigurationConfigurator` This class is a "SmartFactoryBean" which allows a few XML attributes to be set on the otherwise read-only MuleConfiguration.
`class` | `ServerNotificationManagerConfigurator`

Uses of MuleContextAware in org.mule.config.spring.editors

Classes in org.mule.config.spring.editors that implement MuleContextAware
`class` | `MulePropertyEditorRegistrar` The preferred way to configure property editors in Spring 2/3 is to implement a registrar

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

Classes in org.mule.config.spring.factories that implement MuleContextAware
`class` | `AbstractEndpointFactoryBean` Abstract spring FactoryBean used to creating endpoints via spring.
`class` | `AbstractFlowConstructFactoryBean`
`class` | `AsyncMessageProcessorsFactoryBean`
`class` | `BridgeFactoryBean`
`class` | `InboundEndpointFactoryBean` Spring FactoryBean used to create concrete instances of inbound endpoints
`class` | `MessageProcessorFilterPairFactoryBean`
`class` | `MuleTransactionManagerFactoryBean` Creates a reference to the TransactionManager configured on the MuleContext.
`class` | `OutboundEndpointFactoryBean` Spring FactoryBean used to create concrete instances of outbound endpoints
`class` | `PollInboundEndpointFactoryBean` Spring FactoryBean used to create concrete instances of inbound endpoints
`class` | `PollingMessageSourceFactoryBean`
`class` | `SimpleServiceFactoryBean` Builds SimpleService instances by using the SimpleServiceBuilder.
`class` | `ValidatorFactoryBean`

Uses of MuleContextAware in org.mule.config.spring.parsers.specific

Classes in org.mule.config.spring.parsers.specific that implement MuleContextAware
`class` | `SimpleComponentFactoryBean` TODO

Uses of MuleContextAware in org.mule.config.spring.processors

Classes in org.mule.config.spring.processors that implement MuleContextAware
`class` | `DecoratingFlowAnnotationsBeanProcessor` TODO
`class` | `PropertyPlaceholderProcessor` TODO
`class` | `TransformerAnnotatedBeanProcessor` TODO

Uses of MuleContextAware in org.mule.config.support

Classes in org.mule.config.support that implement MuleContextAware
`class` | `InheritedModel` TODO

Uses of MuleContextAware in org.mule.config.transformer

Classes in org.mule.config.transformer that implement MuleContextAware
`class` | `AnnotatedTransformerObjectProcessor` Will check all method level annotations to see if there are any `Transformer` annotations present.
`class` | `AnnotatedTransformerProxy` Creates a Mule `Transformer` proxy around a transform method.

Uses of MuleContextAware in org.mule.context.notification

Classes in org.mule.context.notification that implement MuleContextAware
`class` | `ComponentMessageNotification` These notifications are fired when before and after a service component is invoked.
`class` | `ConnectionNotification` Is fired by a connector when a connection is made or disconnected.
`class` | `CustomNotification` `CustomNotification` Custom notifications can be used by components and other objects such as routers, transformers, agents, etc to communicate a change of state to each other.
`class` | `EndpointMessageNotification` These notifications are fired when either a message is either: received by an endpoint, sent or dispatched from an endpoint or requested from an endpoint.
`class` | `ExceptionNotification` This class is from Mule 2.2.5.
`class` | `FlowConstructNotification` `FlowConstructNotification` is fired when an event such as the flow construct starting occurs.
`class` | `ManagementNotification` `ManagementNotification` is fired when monitored resources such as internal queues reach capacity
`class` | `MessageProcessorNotification`
`class` | `ModelNotification` `ModelNotification` is fired when an event such as the model starting occurs.
`class` | `MuleContextNotification` `MuleContextNotification` is fired when an event such as the mule context starting occurs.
`class` | `RegistryNotification` `RegistryNotification` is fired when an event such as a Registry being started occurs.
`class` | `RoutingNotification` Is fired by routers.
`class` | `SecurityNotification` `SecurityNotification` is fired when a request for authorisation failed.
`class` | `ServerNotificationManager` A reworking of the event manager that allows efficient behaviour without global on/off switches in the config.
`class` | `ServiceNotification` `ServiceNotification` is fired when an event such as the service starting occurs.
`class` | `TransactionNotification`

Uses of MuleContextAware in org.mule.endpoint

Classes in org.mule.endpoint that implement MuleContextAware
`class` | `AbstractEndpointBuilder` Abstract endpoint builder used for externalizing the complex creation logic of endpoints out of the endpoint instance itself.
`class` | `AbstractMetaEndpointBuilder` A base class used for Meta endpoint builders such as RSS or ATOM.
`class` | `DefaultEndpointFactory`
`class` | `EndpointURIEndpointBuilder`

Uses of MuleContextAware in org.mule.endpoint.outbound

Classes in org.mule.endpoint.outbound that implement MuleContextAware
`class` | `OutboundResponsePropertiesMessageProcessor` Propagates properties from request message to response message as defined by `OutboundEndpoint.getResponseProperties()`.
`class` | `OutboundTxRollbackMessageProcessor` MessageProcessor implementation that stops outbound flow is the current transaction has been rolled back.

Uses of MuleContextAware in org.mule.enricher

Classes in org.mule.enricher that implement MuleContextAware
`class` | `MessageEnricher`

Uses of MuleContextAware in org.mule.example.bookstore.transformers

Classes in org.mule.example.bookstore.transformers that implement MuleContextAware
`class` | `AddBookResponse` A call to addBook() returns a Long representing the number of books in the catalog.
`class` | `HttpRequestToBook` Transforms a Map of HttpRequest parameters into a Book object.
`class` | `OrderToEmailTransformer` Composes an e-mail notification message to be sent based on the Book Order.

Uses of MuleContextAware in org.mule.example.errorhandler

Classes in org.mule.example.errorhandler that implement MuleContextAware
`class` | `ErrorMessageToException` The `ErrorMessageToException` transformer extracts and returns the exception encapsulated by the ErrorMessage message payload.
`class` | `ErrorMessageToExceptionBean` The `ErrorMessageToExceptionBean` transformer returns the exception bean encapsulated by the ErrorMessage message payload.
`class` | `ExceptionBeanToErrorMessage`

Uses of MuleContextAware in org.mule.example.geomail.transformers

Classes in org.mule.example.geomail.transformers that implement MuleContextAware
`class` | `IPToSender` TODO

Uses of MuleContextAware in org.mule.example.hello

Classes in org.mule.example.hello that implement MuleContextAware
`class` | `ChatStringToString` `NameStringToChatString` is a dummy transformer used in the hello world application to transform the ChatString object into a string.
`class` | `ExceptionToString` `ExceptionToString` converts an exception to a String, returning the exception's `getMessage()` result.
`class` | `HttpRequestToNameString`
`class` | `NameStringToChatString` `NameStringToChatString` converts from a NameString object to a ChatString object.
`class` | `StdinToNameString` The transformation removes break-lines and newlines from the string, which potentially could have been added during a `stdin` input operation.
`class` | `StringToNameString` `StringToNameString` converts from a String to a NameString object.

Uses of MuleContextAware in org.mule.example.loanbroker.routers

Classes in org.mule.example.loanbroker.routers that implement MuleContextAware
`class` | `BankQuotesInboundAggregator` `BankQuotesInboundAggregator` receives a number of quotes and selects the lowest
`class` | `BankQuotesResponseAggregator` `BankQuotesInboundAggregator` receives a number of quotes and selects the lowest

Uses of MuleContextAware in org.mule.example.loanbroker.transformers

Classes in org.mule.example.loanbroker.transformers that implement MuleContextAware
`class` | `CreditProfileXmlToCreditProfile`
`class` | `LoanQuoteRequestToCreditProfileArgs` Extracts the customer information from the request into an array of arguments used to invoke the Credit Agency MuleSession bean
`class` | `RestRequestToCustomerRequest` Converts parameters on the message into a CustomerQuoteRequest object

Uses of MuleContextAware in org.mule.example.notifications

Classes in org.mule.example.notifications that implement MuleContextAware
`class` | `DummySecurityFilter` TODO
`class` | `HeartbeatAgent` A simple agent that fire `HeartbeatNotification` events at a given frequency to notify that the server is alive and well.
`class` | `HeartbeatNotification` A simple notification that fires repeatedly to notify tha the Mule server is alive and well.

Uses of MuleContextAware in org.mule.example.scripting

Classes in org.mule.example.scripting that implement MuleContextAware
`class` | `SimpleMathTransformer` A simple transformer which adds/subtracts/multiplies/divides a constant factor to numeric messages.

Uses of MuleContextAware in org.mule.exception

Classes in org.mule.exception that implement MuleContextAware
`class` | `AbstractExceptionListener` `AbstractExceptionListener` is a base implementation that custom Exception Listeners can override.
`class` | `AbstractMessagingExceptionStrategy` `DefaultExceptionStrategy` provides a default exception handling strategy.
`class` | `DefaultServiceExceptionStrategy` `DefaultServiceExceptionStrategy` is the default exception handler for components.
`class` | `DefaultSystemExceptionStrategy` Log exception, fire a notification, and clean up transaction if any.

Uses of MuleContextAware in org.mule.expression

Classes in org.mule.expression that implement MuleContextAware
`class` | `DefaultExpressionManager` Provides universal access for evaluating expressions embedded in Mule configurations, such as Xml, Java, scripting and annotations.
`class` | `EndpointInfoExpressionEvaluator` Looks up information about a global endpoint
`class` | `MessagePayloadExpressionEvaluator` Returns the message payload.
`class` | `MuleContextExpressionEvaluator` This property extractor exposes mule context information as expressions.
`class` | `MuleExpressionEvaluator` This evaluator provide a powerful expression language for querying mule information at runtime.
`class` | `RegistryExpressionEvaluator` Looks up information about objects in the Registry
`class` | `StringExpressionEvaluator` Will process an expression string that can contain other expressions

Uses of MuleContextAware in org.mule.expression.transformers

Classes in org.mule.expression.transformers that implement MuleContextAware
`class` | `AbstractExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.
`class` | `BeanBuilderTransformer` This transformer uses the returnClass to create the return object and then will populate the bean with arguments defined as expressions
`class` | `ExpressionArgument` TODO
`class` | `ExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.

Uses of MuleContextAware in org.mule.interceptor

Classes in org.mule.interceptor that implement MuleContextAware
`class` | `AbstractEnvelopeInterceptor` `EnvelopeInterceptor` is an intercepter that will fire before and after an event is received.
`class` | `InterceptorStack` Maintains a list of interceptors that can be applied to components.
`class` | `LoggingInterceptor` `LoggingInterceptor` is a simple interceptor that logs a message before and after the event processing.
`class` | `ProcessingTimeInterceptor` Calculate and record the processing time for a message processing chain
`class` | `TimerInterceptor` `TimerInterceptor` simply times and displays the time taken to process an event.

Uses of MuleContextAware in org.mule.lifecycle

Classes in org.mule.lifecycle that implement MuleContextAware
`class` | `MuleContextLifecycleManager` This is a specialized class that extends `RegistryLifecycleManager` and will invoke lifecycle on the registry instance for the MuleContext.

Uses of MuleContextAware in org.mule.lifecycle.phases

Classes in org.mule.lifecycle.phases that implement MuleContextAware
`class` | `ContainerManagedLifecyclePhase` A container-managed lifecycle phase is called by the container itself.
`class` | `DefaultLifecyclePhase` Represents a configurable lifecycle phase.
`class` | `MuleContextDisposePhase` Objects are disposed of via the Registry since the Registry manages the creation/initialisation of the objects it must also take care of disposing them.
`class` | `MuleContextInitialisePhase` The MuleContextInitialisePhase defines the lifecycle behaviour when the Mule context is initialised.
`class` | `MuleContextStartPhase` The Start phase for the MuleContext.
`class` | `MuleContextStopPhase` The Stop phase for the Management context LifecycleManager.
`class` | `NotInLifecyclePhase` This lifecycle phase marks the 'pre-lifecycle' phase of an object.

Uses of MuleContextAware in org.mule.lifecycle.processor

Classes in org.mule.lifecycle.processor that implement MuleContextAware
`class` | `ProcessIfStartedMessageProcessor`
`class` | `ProcessIfStartedWaitIfPausedMessageProcessor`
`class` | `ProcessIfStartedWaitIfSyncPausedMessageProcessor`

Uses of MuleContextAware in org.mule.model

Classes in org.mule.model that implement MuleContextAware
`class` | `AbstractModel` `MuleModel` is the default implementation of the Model.

Uses of MuleContextAware in org.mule.model.seda

Classes in org.mule.model.seda that implement MuleContextAware
`class` | `SedaModel` A mule service service model that uses SEDA principals to achieve high throughput by Queuing events for components and processing them concurrently.

Uses of MuleContextAware in org.mule.module.atom

Classes in org.mule.module.atom that implement MuleContextAware
`class` | `AbderaServiceComponent` This component receives requests from Mule and passes them off to Abdera.

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

Classes in org.mule.module.atom.endpoint that implement MuleContextAware
`class` | `AtomEndpointBuilder` An endpoint factory used for creating an ATOM endpoint
`class` | `AtomInboundEndpointFactoryBean` A spring factory for creating an ATOM endpoint.

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

Classes in org.mule.module.atom.routing that implement MuleContextAware
`class` | `FeedSplitter` An inbound router that will split a Feed into entries.

Uses of MuleContextAware in org.mule.module.atom.transformers

Classes in org.mule.module.atom.transformers that implement MuleContextAware
`class` | `AtomEntryBuilderTransformer`
`class` | `BaseToOutputHandler` Converts Abdera model elements which extend `Base` to OutputHandlers.
`class` | `ObjectToFeed` `ObjectToInputStream` converts serilaizable object to a input stream but treats `java.lang.String` differently by converting to bytes using the `String.getBytes()` method.

Uses of MuleContextAware in org.mule.module.bpm

Classes in org.mule.module.bpm that implement MuleContextAware
`class` | `ProcessComponent` A service backed by the execution of a business process such as jBPM.

Uses of MuleContextAware in org.mule.module.client

Classes in org.mule.module.client that implement MuleContextAware
`class` | `AbstractEventTransformer` `AbstractEventTransformer` adds support for adding method details to the result message.

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

Classes in org.mule.module.client.remoting that implement MuleContextAware
`class` | `RemoteDispatcherAgent` `RemoteDispatcherAgent` manages the server endpoint that receives Admin and remote client requests

Uses of MuleContextAware in org.mule.module.client.remoting.notification

Classes in org.mule.module.client.remoting.notification that implement MuleContextAware
`class` | `RemoteDispatcherNotification` `RemoteDispatcherNotification` is used to invoke actions on a remote mule server

Uses of MuleContextAware in org.mule.module.cxf

Classes in org.mule.module.cxf that implement MuleContextAware
`class` | `CxfComponentExceptionStrategy` This exception strategy forces the exception thrown from a web service invocation to be passed as-is, not wrapped in a Mule exception object.
`class` | `CxfConfiguration` Provides global CXF configuration defaults.
`class` | `CxfInboundMessageProcessor` The CxfInboundMessageProcessor performs inbound CXF processing, sending an event through the CXF service, then on to the next MessageProcessor.
`class` | `CxfOutboundMessageProcessor` The CxfOutboundMessageProcessor performs outbound CXF processing, sending an event through the CXF client, then on to the next MessageProcessor.

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

Classes in org.mule.module.cxf.builder that implement MuleContextAware
`class` | `AbstractClientMessageProcessorBuilder` An abstract builder for non proxy clients.
`class` | `AbstractInboundMessageProcessorBuilder` An abstract builder for CXF services.
`class` | `AbstractOutboundMessageProcessorBuilder`
`class` | `JaxWsClientMessageProcessorBuilder` Builds a JAX-WS client based `CxfOutboundMessageProcessor`.
`class` | `LocalClientMessageProcessorBuilder` This builder uses a service that is already configured to build a CXF client and it's corresponding MessageProcessor.
`class` | `ProxyClientMessageProcessorBuilder` Creates an outbound proxy based on a specially configure CXF Client.
`class` | `ProxyServiceMessageProcessorBuilder` Creates an inbound proxy based on a specially configure CXF Server.
`class` | `SimpleClientMessageProcessorBuilder`
`class` | `WebServiceMessageProcessorBuilder` Builds a CXF web service MessageProcessor using either the JAX-WS or simple frontends.
`class` | `WsdlClientMessageProcessorBuilder` Builds an outbound CXF MessageProcessor based on a WSDL using CXF's `DynamicClientFactory`.

Uses of MuleContextAware in org.mule.module.cxf.component

Classes in org.mule.module.cxf.component that implement MuleContextAware
`class` | `AbstractWebServiceWrapperComponent`
`class` | `WebServiceWrapperComponent`

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

Classes in org.mule.module.cxf.config that implement MuleContextAware
`class` | `JaxWsClientFactoryBean`
`class` | `ProxyClientFactoryBean`
`class` | `ProxyServiceFactoryBean`
`class` | `SimpleClientFactoryBean`
`class` | `WebServiceFactoryBean`

Uses of MuleContextAware in org.mule.module.cxf.endpoint

Classes in org.mule.module.cxf.endpoint that implement MuleContextAware
`class` | `CxfEndpointBuilder`
`class` | `WsdlCxfEndpointBuilder`

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

Classes in org.mule.module.ibeans.config that implement MuleContextAware
`class` | `CallAnnotationParser` The parser responsible for parsing `Call` annotations.
`class` | `IBeansLoader` Responsible for discovering and loading available iBeans into the registry.
`class` | `IntegrationBeanAnnotatedObjectProcessor`
`class` | `MockIntegrationBeansAnnotationProcessor` Will process any fields on an object with the `MockIntegrationBean` annotation, inserting a Mockito Mock object.

Uses of MuleContextAware in org.mule.module.ibeans.spi

Classes in org.mule.module.ibeans.spi that implement MuleContextAware
`class` | `ErrorExpressionFilter` An implementation of a `ErrorFilter` that allows for error filter expressions to be configured on an iBean

Uses of MuleContextAware in org.mule.module.jaas.filters

Classes in org.mule.module.jaas.filters that implement MuleContextAware
`class` | `JaasSecurityFilter`

Uses of MuleContextAware in org.mule.module.jca

Classes in org.mule.module.jca that implement MuleContextAware
`class` | `JcaComponent`
`class` | `JcaModel` Creates a model suitable for Jca execution

Uses of MuleContextAware in org.mule.module.jersey

Classes in org.mule.module.jersey that implement MuleContextAware
`class` | `JerseyResourcesComponent` Wraps a set of components which can get invoked by Jersey.

Uses of MuleContextAware in org.mule.module.json.transformers

Classes in org.mule.module.json.transformers that implement MuleContextAware
`class` | `AbstractJsonTransformer` TODO
`class` | `JsonToObject` A transformer that will convert a JSON encoded object graph to a java object.
`class` | `JsonTransformerResolver` A `TransformerResolver` implementation used to discover whether the current transform requests requires Json mashaling.
`class` | `ObjectToJson` Converts a java object to a JSON encoded object that can be consumed by other languages such as Javascript or Ruby.

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

Classes in org.mule.module.management.agent that implement MuleContextAware
`class` | `DefaultJmxSupportAgent`
`class` | `JdmkAgent` `JdmkAgent` configures an Jdmk Http Adaptor for Jmx management, statistics and configuration viewing of a Mule instance.
`class` | `JmxAgent` `JmxAgent` registers Mule Jmx management beans with an MBean server.
`class` | `JmxAgentConfigurer` Mule now binds to a platform mbeanserver by default and jmx agent is always registered via a bootstrap process.
`class` | `JmxServerNotificationAgent` An agent that propergates Mule Server notifications to Jmx.
`class` | `Log4jAgent` `Log4jAgent` exposes the configuration of the Log4J instance running in Mule for Jmx management
`class` | `Mx4jAgent` `Mx4jAgent` configures an Mx4J Http Adaptor for Jmx management, statistics and configuration viewing of a Mule instance.
`class` | `RmiRegistryAgent` Binds to an existing RMI registry or creates a new one on a defined URI.
`class` | `WrapperManagerAgent` This agent integrates Java Service Wrapper into Mule.
`class` | `YourKitProfilerAgent`

Uses of MuleContextAware in org.mule.module.pgp.filters

Classes in org.mule.module.pgp.filters that implement MuleContextAware
`class` | `PGPSecurityFilter`

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

Classes in org.mule.module.rss.endpoint that implement MuleContextAware
`class` | `RssEndpointBuilder` Creates RSS endpoints.
`class` | `RssInboundEndpointFactoryBean` TODO

Uses of MuleContextAware in org.mule.module.rss.transformers

Classes in org.mule.module.rss.transformers that implement MuleContextAware
`class` | `ObjectToRssFeed` Converts an RSS data representation into a SyndFeed object

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

Classes in org.mule.module.scripting.component that implement MuleContextAware
`class` | `Scriptable` A JSR 223 Script service.
`class` | `ScriptComponent` A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino.

Uses of MuleContextAware in org.mule.module.scripting.expression

Classes in org.mule.module.scripting.expression that implement MuleContextAware
`class` | `AbstractScriptExpressionEvaluator` An abstract `ExpressionEvaluator` that can be used for any JSR-233 script engine.
`class` | `GroovyExpressionEvaluator` An `ExpressionEvaluator` that allows the user to define Groovy expressions to extract data from the current message.

Uses of MuleContextAware in org.mule.module.scripting.transformer

Classes in org.mule.module.scripting.transformer that implement MuleContextAware
`class` | `ScriptTransformer` Runs a script to perform transformation on an object.

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

Classes in org.mule.module.spring.events that implement MuleContextAware
`class` | `MuleEventMulticaster` `MuleEventMulticaster` is an implementation of a Spring ApplicationeventMulticaster.

Uses of MuleContextAware in org.mule.module.spring.remoting

Classes in org.mule.module.spring.remoting that implement MuleContextAware
`class` | `ObjectToRemoteInvocationResultTransformer` Converts an Object to a Spring RemoteInvocationResult and then into a byte[].
`class` | `ObjectToRemoteInvocationTransformer` Transforms a byte[] into an ObjectInputStream and then into a Spring RemoteInvocation instance.

Uses of MuleContextAware in org.mule.module.spring.security.filters.http

Classes in org.mule.module.spring.security.filters.http that implement MuleContextAware
`class` | `HttpBasicAuthenticationFilter` `HttpBasicAuthenticationFilter` TODO

Uses of MuleContextAware in org.mule.module.sxc

Classes in org.mule.module.sxc that implement MuleContextAware
`class` | `SxcFilteringOutboundRouter` `FilteringRouter` is a router that accepts events based on a filter set.

Uses of MuleContextAware in org.mule.module.ws.config.spring.factories

Classes in org.mule.module.ws.config.spring.factories that implement MuleContextAware
`class` | `WSProxyFactoryBean`

Uses of MuleContextAware in org.mule.module.xml.expression

Classes in org.mule.module.xml.expression that implement MuleContextAware
`class` | `AbstractXPathExpressionEvaluator` Provides a base class for XPath property extractors.
`class` | `BeanPayloadExpressionEvaluator` TODO
`class` | `JaxpXPathExpressionEvaluator` Uses JAXP XPath processing to evaluate xpath expressions against Xml fragments and documents Note that the Jaxp Expression evaluator differs from the Mule XPATH evaluator slightly since you cna set the JaxP return type as a prefix to the expression i.e.
`class` | `JXPathExpressionEvaluator` Deprecated. Developers should use xpath, bean or groovy instead of this expression evaluator since there are some quirks with JXPath and the performance is not good.
`class` | `XPathExpressionEvaluator` Will select the text of a single node based on the property name
`class` | `XPathNodeExpressionEvaluator` Will select the text of a single node based on the property name

Uses of MuleContextAware in org.mule.module.xml.filters

Classes in org.mule.module.xml.filters that implement MuleContextAware
`class` | `JaxenFilter` `JaxenFilter` evaluates an XPath expression against an XML document using Jaxen.
`class` | `JXPathFilter` `JXPathFilter` evaluates an XPath expression against a W3C Document, XML string, or Java bean and returns true if the result is as expected.
`class` | `XPathFilter`

Uses of MuleContextAware in org.mule.module.xml.routing

Classes in org.mule.module.xml.routing that implement MuleContextAware
`class` | `FilterBasedXmlMessageSplitter` This splitter will select the endpoint to send a message part on by filtering parts using the endpoint filters.
`class` | `XmlMessageSplitter` `XmlMessageSplitter` will split a DOM4J document into nodes based on the "splitExpression" property.

Uses of MuleContextAware in org.mule.module.xml.transformer

Classes in org.mule.module.xml.transformer that implement MuleContextAware
`class` | `AbstractXmlTransformer` `AbstractXmlTransformer` offers some XSLT transform on a DOM (or other XML-ish) object.
`class` | `AbstractXStreamTransformer` `AbstractXStreamTransformer` is a base class for all XStream based transformers.
`class` | `DomDocumentToXml` `DomDocumentToXml` Transform a org.w3c.dom.Document to XML String
`class` | `JXPathExtractor` The JXPathExtractor is a simple transformer that evaluates an xpath expression against the given bean and that returns the result.
`class` | `ObjectToXml` `ObjectToXml` converts any object to XML using Xstream.
`class` | `XmlPrettyPrinter`
`class` | `XmlToDomDocument` `XmlToDomDocument` transforms a XML String to org.w3c.dom.Document.
`class` | `XmlToObject` `XmlToObject` converts xml created by the ObjectToXml transformer in to a java object graph.
`class` | `XmlToOutputHandler`
`class` | `XmlToXMLStreamReader`
`class` | `XPathExtractor` Simple transformer for using the JAXP XPath library to extract an XPath value from an XPath expression.
`class` | `XQueryTransformer` The XQuery Module gives users the ability to perform XQuery transformations on XML messages in Mule
`class` | `XsltTransformer` `XsltTransformer` performs an XSLT transform on a DOM (or other XML-ish) object.

Uses of MuleContextAware in org.mule.module.xml.transformer.jaxb

Classes in org.mule.module.xml.transformer.jaxb that implement MuleContextAware
`class` | `JAXBMarshallerTransformer` Allows marshaling of Java objects to XML using JAXB 2.
`class` | `JAXBTransformerResolver` A `TransformerResolver` implementation used to discover whether the current transform requests requires JAXB.
`class` | `JAXBUnmarshallerTransformer` Allows un-marshaling of XML generated by JAXB to a Java object graph.

Uses of MuleContextAware in org.mule.module.xml.transformer.wire

Classes in org.mule.module.xml.transformer.wire that implement MuleContextAware
`class` | `XStreamWireFormat` Serializes objects using XStream.

Uses of MuleContextAware in org.mule.processor

Classes in org.mule.processor that implement MuleContextAware
`class` | `AbstractFilteringMessageProcessor` Abstract `InterceptingMessageProcessor` that can be easily be extended and used for filtering message flow through a `MessageProcessor` chain.
`class` | `AbstractInterceptingMessageProcessor` Abstract implementation of `InterceptingMessageProcessor` that simply provides an implementation of setNext and holds the next message processor as an attribute.
`class` | `AbstractMessageProcessorOwner` An object that owns message processors and delegates startup/shoutdown events to them
`class` | `AbstractResponseMessageProcessor`
`class` | `AsyncInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.
`class` | `ExceptionHandlingMessageProcessor`
`class` | `InvokerMessageProcessor` `InvokerMessageProcessor` invokes a specified method of an object.
`class` | `OptionalAsyncInterceptingMessageProcessor` Implementation of `AsyncInterceptingMessageProcessor` which continues processing in the same thread if the inbound endpoint has an exchange pattern that has a response or if a transaction is present.
`class` | `ResponseMessageProcessorAdapter`
`class` | `SecurityFilterMessageProcessor` Filters the flow using the `EndpointSecurityFilter` configured on the endpoint.
`class` | `SedaStageInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.
`class` | `StopFurtherMessageProcessingMessageProcessor`
`class` | `TransactionalInterceptingMessageProcessor` Wraps the invocation of the next `MessageProcessor` with a transaction.

Uses of MuleContextAware in org.mule.processor.chain

Classes in org.mule.processor.chain that implement MuleContextAware
`class` | `AbstractMessageProcessorChain` Builder needs to return a composite rather than the first MessageProcessor in the chain.
`class` | `DefaultMessageProcessorChain`
`class` | `InterceptingChainLifecycleWrapper` Builder needs to return a composite rather than the first MessageProcessor in the chain.

Uses of MuleContextAware in org.mule.registry

Classes in org.mule.registry that implement MuleContextAware
`class` | `TypeBasedTransformerResolver` Will discover transformers based on type information only.

Uses of MuleContextAware in org.mule.retry

Classes in org.mule.retry that implement MuleContextAware
`class` | `DefaultRetryContext` The RetryContext is used to store any data which carries over from attempt to attempt such as response messages.

Uses of MuleContextAware in org.mule.retry.policies

Classes in org.mule.retry.policies that implement MuleContextAware
`class` | `AbstractPolicyTemplate` Base class for RetryPolicyTemplate implementations.
`class` | `NoRetryPolicyTemplate` This policy is basically a placeholder.

Uses of MuleContextAware in org.mule.routing

Classes in org.mule.routing that implement MuleContextAware
`class` | `AbstractAggregator` `AbstractEventAggregator` will aggregate a set of messages into a single message.
`class` | `AbstractCorrelationAggregator` `AbstractCorrelationAggregatingMessageProcessor` uses the CorrelationID and CorrelationGroupSize properties of the `MuleMessage` to manage message groups.
`class` | `AbstractSelectiveRouter`
`class` | `AbstractSplitter` Splits a message invoking the next message processor one for each split part.
`class` | `ChoiceRouter` Routes the event to a single`MessageProcessor` using a `Filter` to evaluate the event being processed and find the first route that can be used.
`class` | `CollectionSplitter` Splits a message that has a list payload invoking the next message processor one for each item in the list in order.
`class` | `ExpressionMessageInfoMapping` TODO
`class` | `ExpressionSplitter` Splits a message using the expression provided invoking the next message processor one for each split part.
`class` | `FirstSuccessful` FirstSuccessful routes an event to the first target route that can accept it without throwing or returning an exception.
`class` | `IdempotentMessageFilter` `IdempotentMessageFilter` ensures that only unique messages are passed on.
`class` | `IdempotentSecureHashMessageFilter` `IdempotentSecureHashMessageFilter` ensures that only unique messages are received by a service.
`class` | `MessageChunkAggregator`
`class` | `MessageChunkSplitter` A router that breaks up the current message onto smaller parts and sends them to the same destination.
`class` | `MessageFilter` Implementation of `InterceptingMessageProcessor` that filters message flow using a `Filter`.
`class` | `MessageProcessorFilterPair` A holder for a pair of MessageProcessor and Filter.
`class` | `Resequencer` `CorrelationEventResequencer` is used to resequence events according to their dispatch sequence in the correlation group.
`class` | `RoundRobin` RoundRobin divides the messages it receives among its target routes in round-robin fashion.
`class` | `SimpleCollectionAggregator` This router will return all aggregated events as a `MuleMessageCollection`.
`class` | `WireTap` The `WireTap` MessageProcessor allows inspection of messages in a flow.

Uses of MuleContextAware in org.mule.routing.filters

Classes in org.mule.routing.filters that implement MuleContextAware
`class` | `ExpressionFilter` Allows boolean expressions to be executed on a message.

Uses of MuleContextAware in org.mule.routing.outbound

Classes in org.mule.routing.outbound that implement MuleContextAware
`class` | `AbstractMessageSplitter` `AbstractMessageSplitter` is an outbound Message Splitter used to split the contents of a received message into sub parts that can be processed by other components.
`class` | `AbstractOutboundRouter` `AbstractOutboundRouter` is a base router class that tracks statistics about message processing through the router.
`class` | `AbstractRecipientList` `AbstractRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`class` | `AbstractRoundRobinMessageSplitter` `FilteringListMessageSplitter` accepts a List as a message payload then routes list elements as messages over an endpoint where the endpoint's filter accepts the payload.
`class` | `ChainingRouter` `ChainingRouter` is used to pass a Mule event through multiple targets using the result of the first as the input for the second.
`class` | `DefaultOutboundRouterCollection` `DefaultOutboundRouterCollection` is a container of routers.
`class` | `EndpointSelector` `EndpointSelector` selects the outgoing endpoint based on a an expression evaluator ("header:endpoint" by default).
`class` | `ExceptionBasedRouter` `ExceptionBasedRouter` Will send the current event to the first endpoint that doesn't throw an exception.
`class` | `ExpressionMessageSplitter` Evaluates a single expression and adds the results of the expression as individual message parts.
`class` | `ExpressionRecipientList`
`class` | `FilteringOutboundRouter` `FilteringRouter` is a router that accepts events based on a filter set.
`class` | `ListMessageSplitter` `FilteringListMessageSplitter` accepts a List as a message payload then routes list elements as messages over an endpoint where the endpoint's filter accepts the payload.
`class` | `MessageChunkingRouter` A router that breaks up the current message onto smaller parts and sends them to the same destination.
`class` | `MulticastingRouter` `MulticastingRouter` will broadcast the current message to every endpoint registed with the router.
`class` | `OutboundPassThroughRouter` `OutboundPassThroughRouter` allows outbound routing over a single endpoint without any filtering.
`class` | `StaticRecipientList` `StaticRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`class` | `TransformerRouter` Deprecated.

Uses of MuleContextAware in org.mule.routing.requestreply

Classes in org.mule.routing.requestreply that implement MuleContextAware
`class` | `AbstractAsyncRequestReplyRequester`
`class` | `ReplyToPropertyRequestReplyReplier`
`class` | `SimpleAsyncRequestReplyRequester`
`class` | `SimpleRequestReplyReplier`

Uses of MuleContextAware in org.mule.security

Classes in org.mule.security that implement MuleContextAware
`class` | `AbstractEndpointSecurityFilter` `AbstractEndpointSecurityFilter` provides basic initialisation for all security filters, namely configuring the SecurityManager for this instance

Uses of MuleContextAware in org.mule.security.filters

Classes in org.mule.security.filters that implement MuleContextAware
`class` | `MuleEncryptionEndpointSecurityFilter` `MuleEncryptionEndpointSecurityFilter` provides password-based encryption

Uses of MuleContextAware in org.mule.service

Classes in org.mule.service that implement MuleContextAware
`class` | `ForwardingConsumer` Deprecated.
`class` | `PausePhase` Defines a phase phase that will invoke the `Pausable.pause()` method on an object.
`class` | `ResumePhase` Resume phase happens only alfter a pause phase.

Uses of MuleContextAware in org.mule.service.processor

Classes in org.mule.service.processor that implement MuleContextAware
`class` | `ServiceAsyncRequestReplyRequestor`
`class` | `ServiceInternalMessageProcessor`
`class` | `ServiceOutboundMessageProcessor` Responsible for determining if the Service outbound phase should be used and making a copy of the event to use.

Uses of MuleContextAware in org.mule.tck.functional

Classes in org.mule.tck.functional that implement MuleContextAware
`class` | `FunctionalTestComponent` `FunctionalTestComponent` is a service that can be used by functional tests.
`class` | `FunctionalTestNotification` A `FunctionlTestNotification` is fired by the `FunctionalTestComponent` when it receives an event.
`class` | `QuietExceptionStrategy` Restrict exceptions to debug log messages
`class` | `StringAppendTestTransformer`
`class` | `TransactionalFunctionalTestComponent` This service is useful for unit tests involving transactionality because it will roll back the current transaction upon message arrival.

Uses of MuleContextAware in org.mule.tck.testmodels.services

Classes in org.mule.tck.testmodels.services that implement MuleContextAware
`class` | `TestServiceComponent` `TestServiceComponent` is a test WebServices service.

Uses of MuleContextAware in org.mule.tck.transformer

Classes in org.mule.tck.transformer that implement MuleContextAware
`class` | `NoActionTransformer` `NoActionTransformer` doesn't do any transformation on the source object and returns the source as the result.
`class` | `ValidateResponse` Throws an exception if the message does not contain "success".

Uses of MuleContextAware in org.mule.transaction

Classes in org.mule.transaction that implement MuleContextAware
`class` | `MuleTransactionConfig` `MuleTransactionConfig` defines transaction configuration for a transactional endpoint.

Uses of MuleContextAware in org.mule.transformer

Classes in org.mule.transformer that implement MuleContextAware
`class` | `AbstractDiscoverableTransformer`
`class` | `AbstractMessageAwareTransformer` Deprecated.
`class` | `AbstractMessageTransformer` `AbstractMessageTransformer` is a transformer that has a reference to the current message.
`class` | `AbstractTransformer` `AbstractTransformer` is a base class for all transformers.
`class` | `TransformerChain` A referencable chain of transformers that can be used as a single transformer
`class` | `TransformerTemplate` TODO

Uses of MuleContextAware in org.mule.transformer.codec

Classes in org.mule.transformer.codec that implement MuleContextAware
`class` | `Base64Decoder` `Base64Encoder` transforms Base64 encoded data into strings or byte arrays.
`class` | `Base64Encoder` `Base64Encoder` transforms strings or byte arrays into Base64 encoded string.
`class` | `XmlEntityDecoder` Decodes a String or byte[] containing XML entities
`class` | `XmlEntityEncoder` Encodes a string with XML entities

Uses of MuleContextAware in org.mule.transformer.compression

Classes in org.mule.transformer.compression that implement MuleContextAware
`class` | `AbstractCompressionTransformer` `AbstractCompressionTransformer` is a base class for all transformers that can compress or uncompress data when they performa message transformation.
`class` | `GZipCompressTransformer` `GZipCompressTransformer` is a transformer compressing objects into byte arrays.
`class` | `GZipUncompressTransformer` `GZipCompressTransformer` will uncompress a byte[] or InputStream

Uses of MuleContextAware in org.mule.transformer.encryption

Classes in org.mule.transformer.encryption that implement MuleContextAware
`class` | `AbstractEncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes
`class` | `DecryptionTransformer` `EncryptionTransformer` will transform an encrypted array of bytes or string into an decrypted array of bytes
`class` | `EncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes

Uses of MuleContextAware in org.mule.transformer.simple

Classes in org.mule.transformer.simple that implement MuleContextAware
`class` | `AutoTransformer` A transformer that uses the transform discovery mechanism to convert the message payload.
`class` | `BeanToMap` Conversts a simple bean object to a Map.
`class` | `ByteArrayToHexString` Converts a Byte array to a Hex String.
`class` | `ByteArrayToMuleMessage` TODO
`class` | `ByteArrayToObject` `ByteArrayToObject` works in the same way as `ByteArrayToSerializable` but checks if the byte array is a serialised object and if not will return a String created from the bytes as the returnType on the transformer.
`class` | `ByteArrayToSerializable` `ByteArrayToSerializable` converts a serialized object to its object representation
`class` | `GetBeanProperty` Looks up a property from a JavaBean using PropertyUtils.getProperty().
`class` | `HexStringToByteArray` Converts a Hex String to a Byte array
`class` | `MapLookup` `MapLookup` looks up and returns an object from a Map based on a key.
`class` | `MapToBean` Creates and object of type `AbstractTransformer.getReturnClass()` and populates values of a `Map` as bean properties on the object.
`class` | `MessagePropertiesTransformer` A configurable message transformer that allows users to add, overwrite, rename and delete properties on the current message.
`class` | `MuleMessageToByteArray` TODO
`class` | `NumberToString` `NumberToString` converts a Number to a String.
`class` | `ObjectArrayToString` `ObjectArrayToString` transformer is the opposite of StringToObjectArray - it simply converts Object[] to a String in which each element is separated by a configurable delimiter (default is a space).
`class` | `ObjectToByteArray` `ObjectToByteArray` converts serilaizable object to a byte array but treats `java.lang.String` differently by converting to bytes using the `String.getBytrs()` method.
`class` | `ObjectToInputStream` `ObjectToInputStream` converts Serializable objects to an InputStream but treats `java.lang.String`, `byte[]` and `org.mule.api.transport.OutputHandler` differently by using their byte[] content rather thqn Serializing them.
`class` | `ObjectToOutputHandler` `ObjectToOutputHandler` converts a byte array into a String.
`class` | `ObjectToString` `ObjectToString` transformer is useful for debugging.
`class` | `PropertyEditorTextToValueTransformer` `PropertyEditorTextToValueTransformer` adapts a `PropertyEditor` instance allowing it to be used to transform from a String to another type in Mule
`class` | `PropertyEditorValueToTextTransformer` `PropertyEditorValueToTextTransformer` adapts a `PropertyEditor` instance allowing it to be used to transform from a specific type to a String.
`class` | `SerializableToByteArray` `SerializableToByteArray` converts a serializable object or a String to a byte array.
`class` | `StringAppendTransformer`
`class` | `StringToBoolean` `ByteArrayToSerializable` converts a serialized object to its object representation
`class` | `StringToNumber` `StringToNumber` converts a String to a Number.
`class` | `StringToObjectArray` `StringToObjectArray` converts a String into an object array.

Uses of MuleContextAware in org.mule.transformer.wire

Classes in org.mule.transformer.wire that implement MuleContextAware
`class` | `SerializationWireFormat` Wire format using Java serialization
`class` | `SerializedMuleMessageWireFormat` Wire format using Java serialization to serialize MuleMessage objects accross the wire
`class` | `TransformerPairWireFormat` A pairing of an outbound transformer and an inbound transformer that can be used to serialize and deserialize data.

Uses of MuleContextAware in org.mule.transport.email.transformers

Classes in org.mule.transport.email.transformers that implement MuleContextAware
`class` | `EmailMessageToString` `EmailMessageToString` extracts a java mail Message contents and returns a string.
`class` | `MimeMessageToRfc822ByteArray`
`class` | `ObjectToMimeMessage` Transforms a `Message` to a `MuleMessage`, with support for attachments
`class` | `Rfc822ByteArraytoMimeMessage`
`class` | `StringToEmailMessage` `StringToEmailMessage` will convert a String to a JavaMail Message, using the String as the contents.

Uses of MuleContextAware in org.mule.transport.file

Subinterfaces of MuleContextAware in org.mule.transport.file
`interface` | `FilenameParser` `FilenameParser` is a simple expression parser interface for processing filenames

Classes in org.mule.transport.file that implement MuleContextAware
`class` | `ExpressionFilenameParser` `ExpressionFilenameParser` can use any expression language supported by Mule to construct a file name for the current message.

Uses of MuleContextAware in org.mule.transport.file.transformers

Classes in org.mule.transport.file.transformers that implement MuleContextAware
`class` | `FileToByteArray` `FileToByteArray` reads the contents of a file as a byte array.
`class` | `FileToString` `FileToString` reads file contents into a string.

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

Classes in org.mule.transport.http.components that implement MuleContextAware
`class` | `RestServiceWrapper` This service can used to proxy REST style services as local Mule Components.

Uses of MuleContextAware in org.mule.transport.http.transformers

Classes in org.mule.transport.http.transformers that implement MuleContextAware
`class` | `HttpClientMethodResponseToObject` `HttpClientMethodResponseToObject` transforms a http client response to a DefaultMuleMessage.
`class` | `HttpRequestBodyToParamMap`
`class` | `HttpResponseToString` Converts an Http Response object to String.
`class` | `MuleMessageToHttpResponse` Converts a `MuleMessage` into an Http response.
`class` | `ObjectToHttpClientMethodRequest` `ObjectToHttpClientMethodRequest` transforms a MuleMessage into a HttpClient HttpMethod that represents an HttpRequest.
`class` | `ServletRequestToOutputHandler` Adds support for converting a `HttpServletRequest` into an `OutputHandler`

Uses of MuleContextAware in org.mule.transport.jms.transformers

Classes in org.mule.transport.jms.transformers that implement MuleContextAware
`class` | `AbstractJmsTransformer` `AbstractJmsTransformer` is an abstract class that should be used for all transformers where a JMS message will be the transformed or transformee object.
`class` | `JMSMessageToObject` `JMSMessageToObject` Will convert a `javax.jms.Message` or sub-type into an object by extracting the message payload.
`class` | `ObjectToJMSMessage` `ObjectToJMSMessage` will convert any object to a `javax.jms.Message` or sub-type into an object.

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

Classes in org.mule.transport.quartz.config that implement MuleContextAware
`class` | `AbstractJobConfig` Base implementation of `JobConfig`.
`class` | `ScheduleAnnotationParser` Creates a Quartz inbound endpoint for a service

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

Classes in org.mule.transport.quartz.jobs that implement MuleContextAware
`class` | `CustomJobConfig` This configuration simply holds a reference to a user defined job to execute.
`class` | `CustomJobFromMessageConfig` This configuration simply holds a reference to a user defined job to execute.
`class` | `EndpointPollingJobConfig` Configuration for the `EndpointPollingJob` job.
`class` | `EventGeneratorJobConfig` The configuration for the `EventGeneratorJob` job.
`class` | `PollEndpointJob`
`class` | `ScheduledDispatchJobConfig` The configuration for the `ScheduledDispatchJob` job.

Uses of MuleContextAware in org.mule.transport.service

Subinterfaces of MuleContextAware in org.mule.transport.service
`interface` | `TransportServiceDescriptor` `TransportServiceDescriptor` describes the necessary information for creating a connector from a service descriptor.

Classes in org.mule.transport.service that implement MuleContextAware
`class` | `DefaultTransportServiceDescriptor`
`class` | `MetaTransportServiceDescriptor` Used to describe a Meta transport, one which only defines an endpoint, not a connector, receiver, dispatcher, etc

Uses of MuleContextAware in org.mule.transport.servlet.events

Classes in org.mule.transport.servlet.events that implement MuleContextAware
`class` | `ServletContextNotification` TODO

Uses of MuleContextAware in org.mule.transport.servlet.transformers

Classes in org.mule.transport.servlet.transformers that implement MuleContextAware
`class` | `HttpRequestToByteArray` Converts an `HttpServletRequest` into an array of bytes by extracting the payload of the request.
`class` | `HttpRequestToInputStream` Converts a `HttpServletRequest` into an `InputStream`.
`class` | `HttpRequestToParameter`
`class` | `HttpRequestToParameterMap` Returns a simple Map of the parameters sent with the HTTP Request.

Uses of MuleContextAware in org.mule.transport.xmpp.transformers

Classes in org.mule.transport.xmpp.transformers that implement MuleContextAware
`class` | `ObjectToXmppPacket` Creates an Xmpp message packet from a MuleMessage
`class` | `XmppPacketToObject`

Uses of MuleContextAware in org.mule.util

Classes in org.mule.util that implement MuleContextAware
`class` | `DefaultStreamCloserService` Closes streams of different types by looking up available `StreamCloser`'s from the Mule registry.

Uses of MuleContextAware in org.mule.util.queue

Classes in org.mule.util.queue that implement MuleContextAware
`class` | `EventFilePersistenceStrategy`
`class` | `FilePersistenceStrategy`
`class` | `TransactionalQueueManager` The Transactional Queue Manager is responsible for creating and Managing transactional Queues.

Uses of MuleContextAware in org.mule.util.store

Classes in org.mule.util.store that implement MuleContextAware
`class` | `AbstractMonitoredObjectStore<T extends Serializable>` TODO
`class` | `InMemoryObjectStore<T extends Serializable>` `InMemoryObjectStore` implements an optionally bounded in-memory store for message IDs with periodic expiry of old entries.
`class` | `TextFileObjectStore` A Simple object store that stores String objects by key to a text file.

Uses of MuleContextAware in org.mule.work

Classes in org.mule.work that implement MuleContextAware
`class` | `MuleWorkManager` `MuleWorkManager` is a JCA Work manager implementation used to manage thread allocation for Mule components and connectors.

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

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