Uses of Interface
org.apache.camel.Navigate

Packages that use Navigate

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.component.directvm	The Direct VM Component which synchronously invokes the consumer when a producer sends an exchange to the endpoint.
org.apache.camel.impl	Default implementation classes for Camel Core
org.apache.camel.management	Camel management
org.apache.camel.model	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.processor	A collection of Processor implementations which are used to implement the Enterprise Integration Patterns
org.apache.camel.processor.aggregate	Helper classes for the Aggregator pattern.
org.apache.camel.processor.idempotent	An implementation of the Idempotent Consumer pattern.
org.apache.camel.processor.interceptor	Helper classes for interceptors.
org.apache.camel.processor.loadbalancer	Various load balancer processors

Uses of Navigate in org.apache.camel

Subinterfaces of Navigate in org.apache.camel

Modifier and Type	Interface and Description
interface	Channel Channel acts as a channel between Processors in the route graph.

Methods in org.apache.camel that return Navigate

Modifier and Type	Method and Description
Navigate<Processor>	Route.navigate() Returns a navigator to navigate this route by navigating all the Processors.

Uses of Navigate in org.apache.camel.component.directvm

Classes in org.apache.camel.component.directvm that implement Navigate

Modifier and Type	Class and Description
class	DirectVmProcessor

Uses of Navigate in org.apache.camel.impl

Methods in org.apache.camel.impl that return Navigate

Modifier and Type	Method and Description
Navigate<Processor>	EventDrivenConsumerRoute.navigate()

Uses of Navigate in org.apache.camel.management

Classes in org.apache.camel.management that implement Navigate

Modifier and Type	Class and Description
class	InstrumentationProcessor JMX enabled processor that uses the ManagedCounter for instrumenting processing of exchanges.

Uses of Navigate in org.apache.camel.model

Subinterfaces of Navigate in org.apache.camel.model

Modifier and Type	Interface and Description
interface	ModelChannel

Uses of Navigate in org.apache.camel.processor

Classes in org.apache.camel.processor that implement Navigate

Modifier and Type	Class and Description
class	AOPProcessor Deprecated.
class	BatchProcessor Deprecated. may be removed in the future when we overhaul the resequencer EIP
class	CamelInternalProcessor Internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching ...
class	CatchProcessor A processor which catches exceptions.
class	ChoiceProcessor Implements a Choice structure where one or more predicates are used which if they are true their processors are used, with a default otherwise clause used if none match.
class	DeadLetterChannel Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
class	DefaultErrorHandler Default error handler
class	Delayer A Delayer which delays processing the exchange until the correct amount of time has elapsed using an expression to determine the delivery time.
class	DelayProcessorSupport A useful base class for any processor which provides some kind of throttling or delayed processing.
class	DelegateAsyncProcessor A Delegate pattern which delegates processing to a nested AsyncProcessor which can be useful for implementation inheritance when writing an Policy Important: This implementation does support the asynchronous routing engine.
class	DelegateProcessor A Delegate pattern which delegates processing to a nested Processor which can be useful for implementation inheritance when writing an Policy Important: This implementation does not support the asynchronous routing engine.
class	DelegateSyncProcessor A Delegate pattern which delegates synchronous processing to a nested Processor which can be useful for implementation inheritance when writing an Policy Important: This implementation does support the asynchronous routing engine, only.
class	FatalFallbackErrorHandler An ErrorHandler used as a safe fallback when processing by other error handlers such as the OnExceptionDefinition.
class	FilterProcessor The processor which implements the Message Filter EIP pattern.
class	FinallyProcessor Processor to handle do finally supporting asynchronous routing engine
class	InterceptEndpointProcessor Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
class	LoggingErrorHandler An ErrorHandler which uses commons-logging to dump the error
class	LoopProcessor The processor which sends messages in a loop.
class	MulticastProcessor Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.
class	Pipeline Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same message exchanges
class	RecipientListProcessor Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
class	RedeliveryErrorHandler Base redeliverable error handler that also supports a final dead letter queue in case all redelivery attempts fail.
class	Resequencer An implementation of the Resequencer which can reorder messages within a batch.
class	SamplingThrottler A SamplingThrottler is a special kind of throttler.
class	Splitter Implements a dynamic Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
class	StreamResequencer A resequencer that re-orders a (continuous) stream of Exchanges.
class	Throttler A Throttler will set a limit on the maximum number of message exchanges which can be sent to a processor within a specific time period.
class	TryProcessor Implements try/catch/finally type processing
class	WrapProcessor A processor which ensures wrapping processors is having lifecycle handled.

Uses of Navigate in org.apache.camel.processor.aggregate

Classes in org.apache.camel.processor.aggregate that implement Navigate

Modifier and Type	Class and Description
class	AggregateProcessor An implementation of the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.

Uses of Navigate in org.apache.camel.processor.idempotent

Classes in org.apache.camel.processor.idempotent that implement Navigate

Modifier and Type	Class and Description
class	IdempotentConsumer An implementation of the Idempotent Consumer pattern.

Uses of Navigate in org.apache.camel.processor.interceptor

Classes in org.apache.camel.processor.interceptor that implement Navigate

Modifier and Type	Class and Description
class	DefaultChannel DefaultChannel is the default Channel.
class	DelayInterceptor Deprecated. no longer in use, will be removed in next Camel release.
class	HandleFaultInterceptor
class	StreamCachingInterceptor Deprecated. no longer in use, will be removed in next Camel release.
class	TraceInterceptor An interceptor for debugging and tracing routes

Uses of Navigate in org.apache.camel.processor.loadbalancer

Classes in org.apache.camel.processor.loadbalancer that implement Navigate

Modifier and Type	Class and Description
class	CircuitBreakerLoadBalancer
class	FailOverLoadBalancer This FailOverLoadBalancer will failover to use next processor when an exception occurred This implementation mirrors the logic from the Pipeline in the async variation as the failover load balancer is a specialized pipeline.
class	LoadBalancerSupport A default base class for a LoadBalancer implementation.
class	QueueLoadBalancer A base class for LoadBalancer implementations which choose a single destination for each exchange (rather like JMS Queues)
class	RandomLoadBalancer Implements the random load balancing policy
class	RoundRobinLoadBalancer Implements the round robin load balancing policy
class	SimpleLoadBalancerSupport A default base class for a LoadBalancer implementation.
class	StickyLoadBalancer Implements a sticky load balancer using an Expression to calculate a correlation key to perform the sticky load balancing; rather like jsessionid in the web or JMSXGroupID in JMS.
class	TopicLoadBalancer A LoadBalancer implementations which sends to all destinations (rather like JMS Topics).
class	WeightedLoadBalancer
class	WeightedRandomLoadBalancer
class	WeightedRoundRobinLoadBalancer