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

## Uses of Interface
org.mule.api.lifecycle.Stoppable

Packages that use Stoppable
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.agent |
org.mule.api.component |
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.service |
org.mule.api.transport | Contains the interfaces that comprise a provider implementation.
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.support |
org.mule.example.notifications |
org.mule.model |
org.mule.model.direct |
org.mule.model.pipeline |
org.mule.model.seda |
org.mule.module.client.remoting |
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.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.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.service |
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.bpm |
org.mule.transport.cxf |
org.mule.transport.cxf.component |
org.mule.transport.cxf.wsdl |
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.jdbc | Provides jdbc transport.
org.mule.transport.jms | Provides Jms transport connectivity with support for all Jms features.
org.mule.transport.jms.activemq | Provides Jms connectivity with ActiveMQ-specific workarounds and improvements.
org.mule.transport.jms.weblogic | Provides Jms connectivity with Weblogic-specific workarounds and improvements.
org.mule.transport.jms.websphere | Provides Jms connectivity with Websphere-specific workarounds and improvements.
org.mule.transport.jnp |
org.mule.transport.multicast | IP multicast connectivity for Mule.
org.mule.transport.quartz |
org.mule.transport.rmi |
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.wsdl |
org.mule.transport.soap.component |
org.mule.transport.ssl | Provides tcp connectivity over Ssl for Mule.
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.queue | A resource manager that allow access to transactional queues with optional persistence.

Uses of Stoppable in org.mule

Classes in org.mule that implement Stoppable
`class` | `AbstractAgent` Implements common methods for all Agents.
`class` | `DefaultMuleContext`

Uses of Stoppable in org.mule.agent

Classes in org.mule.agent that implement Stoppable
`class` | `AbstractNotificationLoggerAgent` `AbstractNotificationLoggerAgent` Receives Mule server notifications and logs them and can optionally route them to an endpoint.
`class` | `ConfigScannerAgent` EXPERIMENTAL!!! This agent scans a defined directory for dropped configuration files.
`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 Stoppable in org.mule.api

Subinterfaces of Stoppable in org.mule.api
`interface` | `MuleContext`

Uses of Stoppable in org.mule.api.agent

Subinterfaces of Stoppable in org.mule.api.agent
`interface` | `Agent` `Agent` is a server plugin that can be initialised, started and destroyed along with the MuleContext itself.

Uses of Stoppable in org.mule.api.component

Subinterfaces of Stoppable in org.mule.api.component
`interface` | `Component` A `Component` is a invoked by a `Service` for each incoming `MuleEvent` routed on by the `InboundRouterCollection`.
`interface` | `JavaComponent` `JavaComponent` is a Java `Component` implementation used to invoke Java component implementations.
`interface` | `LifecycleAdapter` `LifecycleAdapter` is a wrapper around a pojo service that adds Lifecycle methods to the pojo.

Uses of Stoppable in org.mule.api.lifecycle

Subinterfaces of Stoppable in org.mule.api.lifecycle
`interface` | `Lifecycle` `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.

Constructors in org.mule.api.lifecycle with parameters of type Stoppable
`StopException(Message message, Stoppable component)`
`StopException(Message message, Throwable cause, Stoppable component)`
`StopException(Throwable cause, Stoppable component)`

Uses of Stoppable in org.mule.api.model

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

Uses of Stoppable in org.mule.api.service

Subinterfaces of Stoppable in org.mule.api.service
`interface` | `Service` `Service` is the internal representation of a Mule Managed service.

Uses of Stoppable in org.mule.api.transport

Subinterfaces of Stoppable in org.mule.api.transport
`interface` | `Connectable` Interface for objects that should connect to a resource.
`interface` | `Connector` `Connector` is the mechanism used to connect to external systems and protocols in order to send and receive data.
`interface` | `MessageDispatcher` Combine `MessageDispatching` with various lifecycle methods for the actual instances doing message sending.
`interface` | `MessageReceiver` `MessageReceiver` is used to receive data from an external system.
`interface` | `MessageRequester` Combine `MessageRequesting` with various lifecycle methods for the actual instances doing message sending.

Uses of Stoppable in org.mule.component

Classes in org.mule.component that implement Stoppable
`class` | `AbstractComponent` Abstract `Component` to be used by all `Component` implementations.
`class` | `AbstractJavaComponent` Abstract implementation of JavaComponent adds JavaComponent specific's: `EntryPointResolverSet`, `BindingCollection` and `ObjectFactory`.
`class` | `DefaultJavaComponent` Default implementation of `JavaComponent`.
`class` | `DefaultLifecycleAdapter` `DefaultLifecycleAdapter` provides lifecycle methods for all Mule managed components.
`class` | `NullLifecycleAdapter` `NullLifecycleAdapter` is a lifecycle adaptor implementation that performs no Mule lifecycle propagation to Mule service component implementations.
`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 Stoppable in org.mule.component.simple

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

Uses of Stoppable in org.mule.config.support

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

Uses of Stoppable in org.mule.example.notifications

Classes in org.mule.example.notifications that implement Stoppable
`class` | `HeartbeatAgent` A simple agent that fire `HeartbeatNotification` events at a given frequency to notify that the server is alive and well.

Uses of Stoppable in org.mule.model

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

Uses of Stoppable in org.mule.model.direct

Classes in org.mule.model.direct that implement Stoppable
`class` | `DirectModel`
`class` | `DirectService` A direct service invokes the service service directly without any threading, even when the invocation is asynchronous

Uses of Stoppable in org.mule.model.pipeline

Classes in org.mule.model.pipeline that implement Stoppable
`class` | `PipelineModel`
`class` | `PipelineService`

Uses of Stoppable in org.mule.model.seda

Classes in org.mule.model.seda that implement Stoppable
`class` | `SedaModel` A mule service service model that uses Seda principals to achieve high throughput by Quing events for compoonents and processing them concurrently.
`class` | `SedaService` A Seda service runs inside a Seda Model and is responsible for managing a Seda Queue and thread pool for a Mule sevice service.

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

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

Uses of Stoppable in org.mule.module.jca

Classes in org.mule.module.jca that implement Stoppable
`class` | `JcaComponent`
`class` | `JcaModel` Creates a model suitable for Jca execution
`class` | `JcaService` `JcaService` Is the type of service used in Mule when embedded inside an app server using JCA.

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

Classes in org.mule.module.management.agent that implement Stoppable
`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` | `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 Stoppable in org.mule.module.management.mbean

Subinterfaces of Stoppable in org.mule.module.management.mbean
`interface` | `ServiceServiceMBean` `ServiceServiceMBean` defines the management interface for a mule managed service.

Classes in org.mule.module.management.mbean that implement Stoppable
`class` | `ServiceService` `ServiceService` exposes service information about a Mule Managed service.

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

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

Uses of Stoppable in org.mule.service

Classes in org.mule.service that implement Stoppable
`class` | `AbstractService` A base implementation for all Services in Mule

Uses of Stoppable in org.mule.transport

Classes in org.mule.transport that implement Stoppable
`class` | `AbstractConnectable` Provide a default dispatch (client) support for handling threads lifecycle and validation.
`class` | `AbstractConnector` `AbstractConnector` provides base functionality for all connectors provided with Mule.
`class` | `AbstractJndiConnector` This class acts as common baseclass for both Rmi & EjbConnector Resolves Jndi root for connector usage
`class` | `AbstractMessageDispatcher` Provide a default dispatch (client) support for handling threads lifecycle and validation.
`class` | `AbstractMessageReceiver` `AbstractMessageReceiver` provides common methods for all Message Receivers provided with Mule.
`class` | `AbstractMessageRequester` The Message Requester is used to explicitly request messages from a message channel or resource rather than subscribing to inbound events or polling for messages.
`class` | `AbstractPollingMessageReceiver` `AbstractPollingMessageReceiver` implements a base class for polling message receivers.
`class` | `TransactedPollingMessageReceiver` The TransactedPollingMessageReceiver is an abstract receiver that handles polling and transaction management.
`class` | `UnsupportedMessageDispatcher`
`class` | `UnsupportedMessageRequester`

Uses of Stoppable in org.mule.transport.ajax

Classes in org.mule.transport.ajax that implement Stoppable
`class` | `AjaxMessageDispatcher` Will dispatch Mule events to ajax clients available in Bayeux that are listening to this endpoint.
`class` | `AjaxMessageReceiver` Registers a receiver service with Bayeux.

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

Classes in org.mule.transport.ajax.container that implement Stoppable
`class` | `AjaxServletConnector` A servlet connector that binds to the container and makes a configured Bayeux available to dispatchers and receivers.

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

Classes in org.mule.transport.ajax.embedded that implement Stoppable
`class` | `AjaxConnector` Creates an 'embedded' Ajax server using Jetty and allows Mule to receiver and send events to browsers.

Uses of Stoppable in org.mule.transport.bpm

Classes in org.mule.transport.bpm that implement Stoppable
`class` | `ProcessComponent`
`class` | `ProcessConnector` The BPM provider allows Mule events to initiate and/or advance processes in an external or embedded Business Process Management System (BPMS).
`class` | `ProcessMessageDispatcher` Initiates or advances a workflow process from an outgoing Mule event.
`class` | `ProcessMessageReceiver` Generates an incoming Mule event from an executing workflow process.

Uses of Stoppable in org.mule.transport.cxf

Classes in org.mule.transport.cxf that implement Stoppable
`class` | `CxfConnector` Connects Mule to a CXF bus instance.
`class` | `CxfMessageDispatcher` The CxfMessageDispatcher is used for making Soap client requests to remote services.
`class` | `CxfMessageReceiver` Create a CXF service.
`class` | `CxfMessageRequester` `AxisMessageDispatcher` is used to make soap requests via the Axis soap client.
`class` | `CxfServiceComponent` The CXF receives messages from Mule, converts them into CXF messages and dispatches them into the receiving CXF destination.

Uses of Stoppable in org.mule.transport.cxf.component

Classes in org.mule.transport.cxf.component that implement Stoppable
`class` | `WebServiceWrapperComponent`

Uses of Stoppable in org.mule.transport.cxf.wsdl

Classes in org.mule.transport.cxf.wsdl that implement Stoppable
`class` | `CxfWsdlConnector` TODO document
`class` | `CxfWsdlMessageDispatcher` TODO document

Uses of Stoppable in org.mule.transport.ejb

Classes in org.mule.transport.ejb that implement Stoppable
`class` | `EjbConnector` Provides Connection configurstion for EJB endpoints
`class` | `EjbMessageDispatcher` Invokes a method on an EJB object stored in Jndi.
`class` | `EjbMessageReceiver` Will repeatedly call a method on an EJB object.

Uses of Stoppable in org.mule.transport.email

Classes in org.mule.transport.email that implement Stoppable
`class` | `AbstractMailConnector` Abstract superclass for mail connectors.
`class` | `AbstractRetrieveMailConnector` Support for connecting to and receiving email from a mailbox (the exact protocol depends on the subclass).
`class` | `AbstractTlsRetrieveMailConnector` Support for connecting to and receiving email from a secure mailbox (the exact protocol depends on the subclass).
`class` | `GmailSmtpConnector` This class just sets some extra SMTP properties so it works with GMail.
`class` | `ImapConnector` Receives messages from an IMAP mailbox
`class` | `ImapsConnector` Creates a secure IMAP connection
`class` | `Pop3Connector` `Pop3Connector` is used to connect and receive mail from a POP3 mailbox.
`class` | `Pop3sConnector` Creates a secure connection to a POP3 mailbox
`class` | `RetrieveMessageReceiver` Poll a mailbox for messages, remove the messages and route them as events into Mule.
`class` | `RetrieveMessageRequester` This dispatcher can only be used to receive message (as opposed to listening for them).
`class` | `SmtpConnector` `SmtpConnector` is used to connect to and send data to an SMTP mail server
`class` | `SmtpMessageDispatcher` `SmtpMessageDispatcher` will dispatch Mule events as Mime email messages over an SMTP gateway.
`class` | `SmtpsConnector` Creates a secure SMTP connection

Uses of Stoppable in org.mule.transport.file

Classes in org.mule.transport.file that implement Stoppable
`class` | `FileConnector` `FileConnector` is used for setting up listeners on a directory and for writing files to a directory.
`class` | `FileMessageDispatcher` `FileMessageDispatcher` is used to read/write files to the filesystem
`class` | `FileMessageReceiver` `FileMessageReceiver` is a polling listener that reads files from a directory.
`class` | `FileMessageRequester` `FileMessageDispatcher` is used to read/write files to the filesystem

Uses of Stoppable in org.mule.transport.ftp

Classes in org.mule.transport.ftp that implement Stoppable
`class` | `FtpConnector`
`class` | `FtpMessageDispatcher`
`class` | `FtpMessageReceiver`
`class` | `FtpMessageRequester`

Uses of Stoppable in org.mule.transport.http

Classes in org.mule.transport.http that implement Stoppable
`class` | `HttpClientMessageDispatcher` `HttpClientMessageDispatcher` dispatches Mule events over HTTP.
`class` | `HttpClientMessageRequester` Rquests Mule events over HTTP.
`class` | `HttpConnector` `HttpConnector` provides a way of receiving and sending http requests and responses.
`class` | `HttpMessageReceiver` `HttpMessageReceiver` is a simple http server that can be used to listen for HTTP requests on a particular port.
`class` | `HttpPollingConnector` The HttpPollingConnectors allows for inbound Http endpoints to be configured with an address which it shall use to poll for a result.
`class` | `HttpsClientMessageDispatcher`
`class` | `HttpsConnector` `HttpsConnector` provides Secure http connectivity on top of what is already provided with the Mule `HttpConnector`.
`class` | `HttpsMessageReceiver`
`class` | `HttpsPollingConnector` `HttpsPollingConnector` provides Secure http connectivity on top of what is already provided with the Mule `HttpPollingConnector`.
`class` | `PollingHttpMessageReceiver` Will poll an http URL and use the response as the input for a service request.

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

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

Uses of Stoppable in org.mule.transport.jdbc

Classes in org.mule.transport.jdbc that implement Stoppable
`class` | `JdbcConnector`
`class` | `JdbcMessageDispatcher` The Jdbc Message dispatcher is responsible for executing SQL queries against a database.
`class` | `JdbcMessageReceiver` TODO
`class` | `JdbcMessageRequester`

Uses of Stoppable in org.mule.transport.jms

Classes in org.mule.transport.jms that implement Stoppable
`class` | `JmsConnector` `JmsConnector` is a JMS 1.0.2b compliant connector that can be used by a Mule endpoint.
`class` | `JmsMessageDispatcher` `JmsMessageDispatcher` is responsible for dispatching messages to JMS destinations.
`class` | `JmsMessageReceiver` Deprecated. use `MultiConsumerJmsMessageReceiver` (set by default).
`class` | `JmsMessageRequester` `JmsMessageDispatcher` is responsible for dispatching messages to JMS destinations.
`class` | `MultiConsumerJmsMessageReceiver` In Mule an endpoint corresponds to a single receiver.
`class` | `SingleJmsMessageReceiver` Registers a single Jms MessageListener for an endpoint
`class` | `TransactedSingleResourceJmsMessageReceiver`
`class` | `XaTransactedJmsMessageReceiver`

Uses of Stoppable in org.mule.transport.jms.activemq

Classes in org.mule.transport.jms.activemq that implement Stoppable
`class` | `ActiveMQJmsConnector` ActiveMQ 4.x-specific JMS connector.
`class` | `ActiveMQXAJmsConnector`

Uses of Stoppable in org.mule.transport.jms.weblogic

Classes in org.mule.transport.jms.weblogic that implement Stoppable
`class` | `WeblogicJmsConnector` Weblogic-specific JMS connector.

Uses of Stoppable in org.mule.transport.jms.websphere

Classes in org.mule.transport.jms.websphere that implement Stoppable
`class` | `WebsphereJmsConnector` Websphere-specific JMS connector.
`class` | `WebsphereTransactedJmsMessageReceiver`

Uses of Stoppable in org.mule.transport.jnp

Classes in org.mule.transport.jnp that implement Stoppable
`class` | `JnpConnector` `JnpConnector` uses the Java Naming protocol to bind to remote objects

Uses of Stoppable in org.mule.transport.multicast

Classes in org.mule.transport.multicast that implement Stoppable
`class` | `MulticastConnector` `MulticastConnector` can dispatch mule events using ip multicasting
`class` | `MulticastMessageReceiver`

Uses of Stoppable in org.mule.transport.quartz

Classes in org.mule.transport.quartz that implement Stoppable
`class` | `QuartzConnector` Creates a connection to a Quartz scheduler.
`class` | `QuartzMessageDispatcher` Can schedule a Job with the Quartz scheduler.
`class` | `QuartzMessageReceiver` Listens for Quartz sheduled events using the Receiver Job and fires events to the service associated with this receiver.

Uses of Stoppable in org.mule.transport.rmi

Classes in org.mule.transport.rmi that implement Stoppable
`class` | `RmiCallbackMessageReceiver` TODO
`class` | `RmiConnector` `RmiConnector` can bind or send to a given RMI port on a given host.
`class` | `RmiMessageDispatcher` `RmiMessageDispatcher` will send transformed mule events over RMI-JRMP.
`class` | `RmiMessageReceiver` Will repeatedly call a method on a Remote object.

Uses of Stoppable in org.mule.transport.servlet

Classes in org.mule.transport.servlet that implement Stoppable
`class` | `ServletConnector` `ServletConnector` is a channel adapter between Mule and a servlet engine.
`class` | `ServletMessageReceiver` `ServletMessageReceiver` is a receiver that is invoked from a Servlet when an event is received.

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

Classes in org.mule.transport.servlet.jetty that implement Stoppable
`class` | `JettyHttpConnector` The `JettyConnector` can be using to embed a Jetty server to receive requests on an http inound endpoint.
`class` | `JettyHttpMessageReceiver` `JettyHttpMessageReceiver` is a simple http server that can be used to listen for http requests on a particular port
`class` | `JettyHttpsConnector` The `JettyHttpsConnector` can be using to embed a Jetty server to receive requests on an http inbound endpoint.

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

Classes in org.mule.transport.soap.axis that implement Stoppable
`class` | `AxisConnector` `AxisConnector` is used to maintain one or more Services for Axis server instance.
`class` | `AxisMessageDispatcher` `AxisMessageDispatcher` is used to make soap requests via the Axis soap client.
`class` | `AxisMessageReceiver` `AxisMessageReceiver` is used to register a component as a service with a Axis server.
`class` | `AxisMessageRequester` `AxisMessageDispatcher` is used to make soap requests via the Axis soap client.

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

Classes in org.mule.transport.soap.axis.wsdl that implement Stoppable
`class` | `AxisWsdlConnector` TODO document
`class` | `AxisWsdlMessageDispatcher` Creates and Axis client services from WSDL and invokes it.

Uses of Stoppable in org.mule.transport.soap.component

Classes in org.mule.transport.soap.component that implement Stoppable
`class` | `AbstractWebServiceWrapperComponent`

Uses of Stoppable in org.mule.transport.ssl

Classes in org.mule.transport.ssl that implement Stoppable
`class` | `SslConnector` `SslConnector` provides a connector for SSL connections.
`class` | `SslMessageReceiver`
`class` | `TlsConnector` `TlsConnector` Provides TLS connections

Uses of Stoppable in org.mule.transport.stdio

Classes in org.mule.transport.stdio that implement Stoppable
`class` | `PromptStdioConnector` `PromptStdioConnector` connects to the System streams in and out by default and add some basic fuctionality for writing out prompt messages.
`class` | `StdioConnector` `StdioConnector` can send and receive Mule events over IO streams.
`class` | `StdioMessageDispatcher` `StdioMessageDispatcher` is a simple stream dispatcher that obtains a stream from the Stream Connector to write to.
`class` | `StdioMessageReceiver` `StdioMessageReceiver` is a listener for events from Mule components which then simply passes the events on to the target components.

Uses of Stoppable in org.mule.transport.tcp

Classes in org.mule.transport.tcp that implement Stoppable
`class` | `TcpConnector` `TcpConnector` can bind or sent to a given TCP port on a given host.
`class` | `TcpMessageDispatcher` Send transformed Mule events over TCP.
`class` | `TcpMessageReceiver` `TcpMessageReceiver` acts like a TCP server to receive socket requests.
`class` | `TcpMessageRequester` Request transformed Mule events from TCP.

Uses of Stoppable in org.mule.transport.udp

Classes in org.mule.transport.udp that implement Stoppable
`class` | `UdpConnector` `UdpConnector` can send and receive Mule events as Datagram packets.
`class` | `UdpMessageDispatcher` `UdpMessageDispatcher` is responsible for dispatching MuleEvents as UDP packets on the network
`class` | `UdpMessageReceiver` `UdpMessageReceiver` receives UDP message packets.
`class` | `UdpMessageRequester` Responsible for requesting MuleEvents as UDP packets on the network

Uses of Stoppable in org.mule.transport.vm

Classes in org.mule.transport.vm that implement Stoppable
`class` | `VMConnector` `VMConnector` A simple endpoint wrapper to allow a Mule service to be accessed from an endpoint
`class` | `VMMessageDispatcher` `VMMessageDispatcher` is used for providing in memory interaction between components.
`class` | `VMMessageReceiver` `VMMessageReceiver` is a listener for events from a Mule service which then simply passes the events on to the target service.
`class` | `VMMessageRequester` `VMMessageDispatcher` is used for providing in memory interaction between components.

Uses of Stoppable in org.mule.transport.xmpp

Classes in org.mule.transport.xmpp that implement Stoppable
`class` | `XmppConnector` `XmppConnector` TODO
`class` | `XmppMessageDispatcher` Allows Mule events to be sent over Xmpp
`class` | `XmppMessageReceiver` `XmppMessageReceiver` is responsible for receiving Mule events over XMPP.
`class` | `XmppMessageRequester` Allows Mule events to be received over Xmpp
`class` | `XmppsConnector`

Uses of Stoppable in org.mule.util.pool

Subinterfaces of Stoppable in org.mule.util.pool
`interface` | `LifecyleEnabledObjectPool` An ObjectPool that allows Start and Stop life-cycle to be propagated pooled object.

Classes in org.mule.util.pool that implement Stoppable
`class` | `DefaultLifecycleEnabledObjectPool` A LifecyleEnabledObjectPool implementation for pooling `LifecycleAdapter` instances for implementations of `JavaComponent` that require `LifecycleAdapter` pooling such as `PooledJavaComponent`.

Uses of Stoppable in org.mule.util.queue

Subinterfaces of Stoppable in org.mule.util.queue
`interface` | `QueueManager` A Queue manager is responsible for manageing one or more Queue resources and providing common support fot transactions and persistence

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

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

Copyright © 2003-2009 MuleSource, Inc.. All Rights Reserved.