Uses of Interface
org.apache.camel.Processor

Packages that use Processor
org.apache.camel The core Camel API 
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.builder.xml Support for XPath based Expressions and Predicates as well as an XSLT processor 
org.apache.camel.component.bean The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO 
org.apache.camel.component.dataset A DataSet Endpoint for testing of endpoints using defined DataSets 
org.apache.camel.component.direct The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint. 
org.apache.camel.component.file The File Component for working with file systems. 
org.apache.camel.component.jmx The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. 
org.apache.camel.component.list The List Component which is a simple in memory component which maintains a List of all message exchanges which can be useful for debugging, tooling or visualistion. 
org.apache.camel.component.mock The Mock Component which is used for testing of routing and mediation rules. 
org.apache.camel.component.seda The SEDA Component for asynchronous SEDA exchanges on a BlockingQueue within a single CamelContext 
org.apache.camel.component.timer The Timer Component extends the POJO component to provide a simple timer 
org.apache.camel.converter A set of helper classes for converting from different types of Java object to be used by the Type Conversion Support 
org.apache.camel.impl Default implementation classes for Camel Core 
org.apache.camel.impl.converter Default implementation classes the Type Conversion Strategies 
org.apache.camel.management Camel JMX export services. 
org.apache.camel.model The JAXB POJOs for the XML Configuration of the routing rules. 
org.apache.camel.model.loadbalancer The LoadBalancer and the LoadBalancerStrategy JAXB Objects 
org.apache.camel.processor A collection of Processor implementations which are used to implement the Enterprise Integration Patterns 
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 
org.apache.camel.processor.resequencer Helper classes for the Resequencer pattern. 
org.apache.camel.processor.validation Performs XML validation using JAXP for validating against XSD or RelaxNG 
org.apache.camel.spi Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. 
org.apache.camel.util Utility classes used by the core of Camel and useful for Camel component developers 
 

Uses of Processor in org.apache.camel
 

Subinterfaces of Processor in org.apache.camel
 interface AsyncProcessor
          A more complex version of Processor which supports asynchronous processing of the Exchange.
 interface Producer<E extends Exchange>
          Provides a channel on which clients can create and invoke message exchanges on an Endpoint
 

Methods in org.apache.camel that return Processor
protected  Processor CamelTemplate.createBodyAndHeaderProcessor(Object body, String header, Object headerValue)
           
protected  Processor CamelTemplate.createSetBodyProcessor(Object body)
           
 

Methods in org.apache.camel with parameters of type Processor
 Consumer<E> Endpoint.createConsumer(Processor processor)
          Creates a new Event Driven Consumer which consumes messages from the endpoint using the given processor
 E CamelTemplate.request(Endpoint<E> endpoint, Processor processor)
          Send the body to an endpoint returning any result output body
 E ProducerTemplate.request(Endpoint<E> endpoint, Processor processor)
          Send the body to an endpoint returning any result output body
 E CamelTemplate.request(String endpoint, Processor processor)
          Send the body to an endpoint returning any result output body
 E ProducerTemplate.request(String endpoint, Processor processor)
          Send the body to an endpoint returning any result output body
 E CamelTemplate.send(Endpoint<E> endpoint, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E ProducerTemplate.send(Endpoint<E> endpoint, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E ProducerTemplate.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(Endpoint<E> endpoint, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(Processor processor)
          Sends an exchange to the default endpoint using a supplied
 E ProducerTemplate.send(Processor processor)
          Sends an exchange to the default endpoint using a supplied
 E CamelTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E ProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E ProducerTemplate.send(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(String endpointUri, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied
 

Uses of Processor in org.apache.camel.builder
 

Methods in org.apache.camel.builder that return Processor
 Processor DeadLetterChannelBuilder.createErrorHandler(Processor processor)
           
 Processor ErrorHandlerBuilder.createErrorHandler(Processor processor)
          Creates the error handler interceptor
 Processor NoErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor ProcessorFactory.createProcessor()
           
 Processor ConstantProcessorBuilder.createProcessor()
           
 Processor DeadLetterChannelBuilder.getDefaultDeadLetterEndpoint()
           
static Processor ProcessorBuilder.removeFaultHeader(String name)
          Removes the header on the FAULT message
static Processor ProcessorBuilder.removeHeader(String name)
          Removes the header on the IN message
static Processor ProcessorBuilder.removeOutHeader(String name)
          Removes the header on the OUT message
static Processor ProcessorBuilder.removeProperty(String name)
          Removes the property on the exchange
static Processor ProcessorBuilder.setBody(Expression expression)
          Creates a processor which sets the body of the IN message to the value of the expression
static Processor ProcessorBuilder.setFaultBody(Expression expression)
          Creates a processor which sets the body of the FAULT message to the value of the expression
static Processor ProcessorBuilder.setFaultHeader(String name, Expression expression)
          Sets the header on the FAULT message
static Processor ProcessorBuilder.setHeader(String name, Expression expression)
          Sets the header on the IN message
static Processor ProcessorBuilder.setOutBody(Expression expression)
          Creates a processor which sets the body of the OUT message to the value of the expression
static Processor ProcessorBuilder.setOutHeader(String name, Expression expression)
          Sets the header on the OUT message
static Processor ProcessorBuilder.setProperty(String name, Expression expression)
          Sets the property on the exchange
static Processor ProcessorBuilder.throwException(Exception ex)
          Throws an exception
 

Methods in org.apache.camel.builder with parameters of type Processor
 Processor DeadLetterChannelBuilder.createErrorHandler(Processor processor)
           
 Processor ErrorHandlerBuilder.createErrorHandler(Processor processor)
          Creates the error handler interceptor
 Processor NoErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 void DeadLetterChannelBuilder.setDefaultDeadLetterEndpoint(Processor defaultDeadLetterEndpoint)
          Sets the default dead letter endpoint used
 

Constructors in org.apache.camel.builder with parameters of type Processor
ConstantProcessorBuilder(Processor processor)
           
DeadLetterChannelBuilder(Processor processor)
           
 

Uses of Processor in org.apache.camel.builder.xml
 

Classes in org.apache.camel.builder.xml that implement Processor
 class XsltBuilder
          Creates a Processor which performs an XSLT transformation of the IN message body
 

Uses of Processor in org.apache.camel.component.bean
 

Classes in org.apache.camel.component.bean that implement Processor
 class BeanProcessor
          A Processor which converts the inbound exchange to a method invocation on a POJO
 

Methods in org.apache.camel.component.bean that return Processor
protected  Processor BeanProcessor.getProcessor()
           
 Processor RegistryBean.getProcessor()
           
 Processor BeanHolder.getProcessor()
           
 Processor ConstantBeanHolder.getProcessor()
           
 

Uses of Processor in org.apache.camel.component.dataset
 

Methods in org.apache.camel.component.dataset that return Processor
 Processor SimpleDataSet.getInputTransformer()
           
 Processor DataSetSupport.getOutputTransformer()
           
 

Methods in org.apache.camel.component.dataset with parameters of type Processor
 Consumer<Exchange> DataSetEndpoint.createConsumer(Processor processor)
           
 void SimpleDataSet.setInputTransformer(Processor inputTransformer)
           
 void DataSetSupport.setOutputTransformer(Processor outputTransformer)
           
 

Constructors in org.apache.camel.component.dataset with parameters of type Processor
DataSetConsumer(DataSetEndpoint endpoint, Processor processor)
           
 

Uses of Processor in org.apache.camel.component.direct
 

Classes in org.apache.camel.component.direct that implement Processor
 class DirectProducer<E extends Exchange>
           
 

Methods in org.apache.camel.component.direct with parameters of type Processor
 Consumer<E> DirectEndpoint.createConsumer(Processor processor)
           
 

Uses of Processor in org.apache.camel.component.file
 

Classes in org.apache.camel.component.file that implement Processor
 class FileProducer
          A Producer implementation for File
 

Methods in org.apache.camel.component.file with parameters of type Processor
 Consumer<FileExchange> FileEndpoint.createConsumer(Processor processor)
           
 

Constructors in org.apache.camel.component.file with parameters of type Processor
FileConsumer(FileEndpoint endpoint, Processor processor)
           
 

Uses of Processor in org.apache.camel.component.jmx
 

Methods in org.apache.camel.component.jmx with parameters of type Processor
 Consumer<JMXExchange> JMXEndpoint.createConsumer(Processor proc)
           
 

Constructors in org.apache.camel.component.jmx with parameters of type Processor
JMXConsumer(JMXEndpoint endpoint, Processor processor)
           
 

Uses of Processor in org.apache.camel.component.list
 

Methods in org.apache.camel.component.list with parameters of type Processor
 Consumer<Exchange> ListEndpoint.createConsumer(Processor processor)
           
 

Uses of Processor in org.apache.camel.component.mock
 

Methods in org.apache.camel.component.mock that return Processor
 Processor MockEndpoint.getReporter()
           
 

Methods in org.apache.camel.component.mock with parameters of type Processor
 Consumer<Exchange> MockEndpoint.createConsumer(Processor processor)
           
 void MockEndpoint.setReporter(Processor reporter)
          Allows a processor to added to the endpoint to report on progress of the test
 void MockEndpoint.whenAnyExchangeReceived(Processor processor)
          Set the processor that will be invoked when the some message is received.
 void MockEndpoint.whenExchangeReceived(int index, Processor processor)
          Set the processor that will be invoked when the index message is received.
 

Uses of Processor in org.apache.camel.component.seda
 

Classes in org.apache.camel.component.seda that implement Processor
 class CollectionProducer
          A simple Producer which just appends to a Collection the Exchange object.
 

Methods in org.apache.camel.component.seda with parameters of type Processor
 Consumer SedaEndpoint.createConsumer(Processor processor)
           
 

Constructors in org.apache.camel.component.seda with parameters of type Processor
SedaConsumer(SedaEndpoint endpoint, Processor processor)
           
 

Uses of Processor in org.apache.camel.component.timer
 

Methods in org.apache.camel.component.timer with parameters of type Processor
 Consumer<Exchange> TimerEndpoint.createConsumer(Processor processor)
           
 

Constructors in org.apache.camel.component.timer with parameters of type Processor
TimerConsumer(TimerEndpoint endpoint, Processor processor)
           
 

Uses of Processor in org.apache.camel.converter
 

Methods in org.apache.camel.converter that return Processor
 Processor CamelConverter.toProcessor(Expression<Exchange> expresion)
           
 Processor CamelConverter.toProcessor(Predicate<Exchange> predicate)
           
 

Uses of Processor in org.apache.camel.impl
 

Classes in org.apache.camel.impl that implement Processor
 class DefaultProducer<E extends Exchange>
          A default implementation of @{link Producer} for implementation inheritence
 class EventDrivenPollingConsumer<E extends Exchange>
          A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
 

Methods in org.apache.camel.impl that return Processor
 Processor RouteContext.createProceedProcessor()
           
 Processor RouteContext.createProcessor(ProcessorType node)
           
 Processor DefaultConsumer.getProcessor()
           
 Processor ProcessorEndpoint.getProcessor()
           
 Processor EventDrivenConsumerRoute.getProcessor()
           
 Processor NoPolicy.wrap(Processor processor)
           
 

Methods in org.apache.camel.impl with parameters of type Processor
 void RouteContext.addEventDrivenProcessor(Processor processor)
           
 Consumer<E> DefaultPollingEndpoint.createConsumer(Processor processor)
           
 void EventDrivenConsumerRoute.setProcessor(Processor processor)
           
 Processor NoPolicy.wrap(Processor processor)
           
 

Constructors in org.apache.camel.impl with parameters of type Processor
DefaultConsumer(Endpoint<E> endpoint, Processor processor)
           
DefaultScheduledPollConsumer(DefaultEndpoint<E> defaultEndpoint, Processor processor)
           
DefaultScheduledPollConsumer(Endpoint<E> endpoint, Processor processor, ScheduledExecutorService executor)
           
EventDrivenConsumerRoute(Endpoint endpoint, Processor processor)
           
ProcessorEndpoint(String endpointUri, CamelContext context, Processor processor)
           
ProcessorEndpoint(String endpointUri, Component component, Processor processor)
           
ProcessorEndpoint(String endpointUri, Processor processor)
           
ProcessorPollingConsumer(Endpoint endpoint, Processor processor)
           
ScheduledPollConsumer(DefaultEndpoint<E> endpoint, Processor processor)
           
ScheduledPollConsumer(Endpoint<E> endpoint, Processor processor, ScheduledExecutorService executor)
           
 

Uses of Processor in org.apache.camel.impl.converter
 

Classes in org.apache.camel.impl.converter that implement Processor
static class AsyncProcessorTypeConverter.ProcessorToAsynProcessorBridge
           
 

Methods in org.apache.camel.impl.converter with parameters of type Processor
static AsyncProcessor AsyncProcessorTypeConverter.convert(Processor value)
           
 

Uses of Processor in org.apache.camel.management
 

Classes in org.apache.camel.management that implement Processor
 class InstrumentationProcessor
           
 

Uses of Processor in org.apache.camel.model
 

Methods in org.apache.camel.model that return Processor
protected  Processor ProcessorType.createCompositeProcessor(List<Processor> list)
          Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
protected  Processor MulticastType.createCompositeProcessor(List<Processor> list)
           
 Processor ProcessorType.createOutputsProcessor(RouteContext routeContext)
           
protected  Processor ProcessorType.createOutputsProcessor(RouteContext routeContext, Collection<ProcessorType<?>> outputs)
           
protected  Processor LoadBalanceType.createOutputsProcessor(RouteContext routeContext, Collection<ProcessorType<?>> outputs)
           
 Processor ToType.createProcessor(RouteContext routeContext)
           
 Processor ProcessorRef.createProcessor(RouteContext routeContext)
           
 Processor MarshalType.createProcessor(RouteContext routeContext)
           
 Processor IdempotentConsumerType.createProcessor(RouteContext routeContext)
           
 Processor RoutingSlipType.createProcessor(RouteContext routeContext)
           
 Processor InterceptorRef.createProcessor(RouteContext routeContext)
           
 Processor BeanRef.createProcessor(RouteContext routeContext)
           
 Processor DelayerType.createProcessor(RouteContext routeContext)
           
 Processor PolicyRef.createProcessor(RouteContext routeContext)
           
 Processor TryType.createProcessor(RouteContext routeContext)
           
 Processor ThreadType.createProcessor(RouteContext routeContext)
           
 Processor FinallyType.createProcessor(RouteContext routeContext)
           
 Processor TransformType.createProcessor(RouteContext routeContext)
           
 Processor RecipientListType.createProcessor(RouteContext routeContext)
           
 Processor ChoiceType.createProcessor(RouteContext routeContext)
           
 Processor UnmarshalType.createProcessor(RouteContext routeContext)
           
 Processor ProceedType.createProcessor(RouteContext routeContext)
           
 Processor ThrottlerType.createProcessor(RouteContext routeContext)
           
 Processor ThrowFaultType.createProcessor(RouteContext routeContext)
           
 Processor OtherwiseType.createProcessor(RouteContext routeContext)
           
 Processor SetHeaderType.createProcessor(RouteContext routeContext)
           
 Processor ConvertBodyType.createProcessor(RouteContext routeContext)
           
 Processor SplitterType.createProcessor(RouteContext routeContext)
           
 Processor ProcessorType.createProcessor(RouteContext routeContext)
           
 Processor MulticastType.createProcessor(RouteContext routeContext)
           
 Processor ResequencerType.createProcessor(RouteContext routeContext)
           
 Processor InterceptType.createProcessor(RouteContext routeContext)
           
 Processor LoadBalanceType.createProcessor(RouteContext routeContext)
           
 Processor ExceptionType.getErrorHandler()
           
protected  Processor ProcessorType.makeProcessor(RouteContext routeContext)
          Creates the processor and wraps it in any necessary interceptors and error handlers
protected  Processor ProcessorType.wrapInErrorHandler(Processor processor)
          A strategy method to allow newly created processors to be wrapped in an error handler.
 Processor ProcessorType.wrapProcessor(RouteContext routeContext, Processor processor)
          Wraps the child processor in whatever necessary interceptors and error handlers
protected  Processor ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext, Processor target)
          A strategy method which allows derived classes to wrap the child processor in some kind of interceptor
 

Methods in org.apache.camel.model with parameters of type Processor
 Type ProcessorType.process(Processor processor)
          Adds the custom processor to this destination which could be a final destination, or could be a transformation in a pipeline
protected  Processor ProcessorType.wrapInErrorHandler(Processor processor)
          A strategy method to allow newly created processors to be wrapped in an error handler.
 Processor ProcessorType.wrapProcessor(RouteContext routeContext, Processor processor)
          Wraps the child processor in whatever necessary interceptors and error handlers
protected  Processor ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext, Processor target)
          A strategy method which allows derived classes to wrap the child processor in some kind of interceptor
 

Method parameters in org.apache.camel.model with type arguments of type Processor
protected  Processor ProcessorType.createCompositeProcessor(List<Processor> list)
          Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
protected  Processor MulticastType.createCompositeProcessor(List<Processor> list)
           
 

Constructors in org.apache.camel.model with parameters of type Processor
ProcessorRef(Processor processor)
           
 

Uses of Processor in org.apache.camel.model.loadbalancer
 

Classes in org.apache.camel.model.loadbalancer that implement Processor
 class LoadBalancerType
           
 class RandomLoadBalanceStrategy
           
 class RoundRobinLoadBalanceStrategy
           
 class StickyLoadBalanceStrategy
           
 class TopicLoadBalanceStrategy
           
 

Methods in org.apache.camel.model.loadbalancer that return types with arguments of type Processor
 List<Processor> LoadBalancerType.getProcessors()
           
 

Methods in org.apache.camel.model.loadbalancer with parameters of type Processor
 void LoadBalancerType.addProcessor(Processor processor)
           
 void LoadBalancerType.removeProcessor(Processor processor)
           
 

Uses of Processor in org.apache.camel.processor
 

Subinterfaces of Processor in org.apache.camel.processor
 interface ErrorHandler
          An interface used to represent an error handler
 

Classes in org.apache.camel.processor that implement Processor
 class CatchProcessor
           
 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 CompositeProcessor
          Represents a composite pattern, aggregating a collection of processors together as a single processor
 class ConvertBodyProcessor
          A processor which converts the payload of the input message to be of the given type
 class DeadLetterChannel
          Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
 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
 class DelegateProcessor
          A Delegate pattern which delegates processing to a nested processor which can be useful for implementation inheritance when writing an Policy
 class ErrorHandlerSupport
          Support class for ErrorHandler implementations.
 class FilterProcessor
           
 class HandleFaultProcessor
           
 class Interceptor
          An interceptor which provides the processing logic as a pluggable processor which allows the DelegateProcessor.proceed(Exchange) method to be called at some point
 class Logger
          A Processor which just logs to a Log object which can be used as an exception handler instead of using a dead letter queue.
 class LoggingErrorHandler
          An ErrorHandler which uses commons-logging to dump the error
 class MarshalProcessor
          Marshals the body of the incoming message using the given data format
 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 ProceedProcessor
          A Processor which proceeds on an Interceptor
 class RecipientList
          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 RoutingSlip
          Implements a Routing Slip pattern where the list of actual endpoints to send a message exchange to are dependent on the value of a message header.
 class SendProcessor
           
 class SetHeaderProcessor
          A processor which sets the header on the IN message
 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 ThreadProcessor
          A processor that forces async processing of the exchange using a thread pool.
 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 ThroughputLogger
           
 class ThrowFaultProcessor
          The processor which implements the ThrowFault DSL
 class TransformProcessor
          A processor which sets the body on the OUT message with an expression
 class TryProcessor
          Implements try/catch/finally type processing
 class UnitOfWorkProcessor
          Handles calling the UnitOfWork.done() method when processing of an exchange is complete.
 class UnmarshalProcessor
          Unmarshals the body of the incoming message using the given data format
 

Fields in org.apache.camel.processor declared as Processor
protected  Processor DelegateProcessor.processor
           
 

Methods in org.apache.camel.processor that return Processor
 Processor DeadLetterChannel.getDeadLetter()
          Returns the dead letter that message exchanges will be sent to if the redelivery attempts fail
 Processor Interceptor.getInterceptorLogic()
           
 Processor ChoiceProcessor.getOtherwise()
           
 Processor DeadLetterChannel.getOutput()
          Returns the output processor
 Processor LoggingErrorHandler.getOutput()
          Returns the output processor
 Processor BatchProcessor.getProcessor()
           
 Processor DelegateProcessor.getProcessor()
           
static Processor Pipeline.newInstance(List<Processor> processors)
           
 

Methods in org.apache.camel.processor that return types with arguments of type Processor
 Collection<Processor> MulticastProcessor.getProcessors()
          Returns the producers to multicast to
 Collection<Processor> CompositeProcessor.getProcessors()
           
static
<E extends Exchange>
Collection<Processor>
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
          A helper method to convert a list of endpoints into a list of processors
 

Methods in org.apache.camel.processor with parameters of type Processor
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
 void Interceptor.setInterceptorLogic(Processor interceptorLogic)
           
 void DelegateProcessor.setProcessor(Processor processor)
           
 

Method parameters in org.apache.camel.processor with type arguments of type Processor
static Processor Pipeline.newInstance(List<Processor> processors)
           
 

Constructors in org.apache.camel.processor with parameters of type Processor
Aggregator(Endpoint endpoint, Processor processor, AggregationCollection collection)
           
Aggregator(Endpoint endpoint, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy)
           
Aggregator(Endpoint endpoint, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy, Predicate aggregationCompletedPredicate)
           
BatchProcessor(Endpoint endpoint, Processor processor, Collection<Exchange> collection)
           
CatchProcessor(List<Class> exceptions, Processor processor)
           
ChoiceProcessor(List<FilterProcessor> filters, Processor otherwise)
           
DeadLetterChannel(Processor output, Processor deadLetter)
           
DeadLetterChannel(Processor output, Processor deadLetter, RedeliveryPolicy redeliveryPolicy, Logger logger, ExceptionPolicyStrategy exceptionPolicyStrategy)
           
Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)
           
DelayProcessorSupport(Processor processor)
           
DelegateProcessor(Processor processor)
           
FilterProcessor(Predicate<Exchange> predicate, Processor processor)
           
Interceptor(Processor interceptorLogic)
           
LoggingErrorHandler(Processor output)
           
LoggingErrorHandler(Processor output, Log log, LoggingLevel level)
           
Resequencer(Endpoint endpoint, Processor processor, Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, List<Expression> expressions)
           
Resequencer(Endpoint endpoint, Processor processor, Set<Exchange> collection)
           
SetHeaderProcessor(String name, Expression expression, Processor childProcessor)
           
Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy)
           
Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ThreadPoolExecutor threadPoolExecutor)
           
StreamResequencer(Processor processor, SequenceElementComparator<Exchange> comparator, int capacity)
          Creates a new StreamResequencer instance.
Throttler(Processor processor, long maximumRequestsPerPeriod)
           
Throttler(Processor processor, long maximumRequestsPerPeriod, long timePeriodMillis)
           
TransformProcessor(Expression expression, Processor childProcessor)
           
TryProcessor(Processor tryProcessor, List<CatchProcessor> catchClauses, Processor finallyProcessor)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Processor
CompositeProcessor(Collection<Processor> processors)
           
MulticastProcessor(Collection<Processor> processors)
           
MulticastProcessor(Collection<Processor> processors, AggregationStrategy aggregationStrategy)
           
MulticastProcessor(Collection<Processor> processors, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ThreadPoolExecutor executor)
           
Pipeline(Collection<Processor> processors)
           
 

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

Classes in org.apache.camel.processor.idempotent that implement Processor
 class IdempotentConsumer
          An implementation of the Idempotent Consumer pattern.
 

Methods in org.apache.camel.processor.idempotent that return Processor
 Processor IdempotentConsumer.getNextProcessor()
           
 

Constructors in org.apache.camel.processor.idempotent with parameters of type Processor
IdempotentConsumer(Expression<Exchange> messageIdExpression, MessageIdRepository messageIdRepository, Processor nextProcessor)
           
 

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

Classes in org.apache.camel.processor.interceptor that implement Processor
 class StreamCachingInterceptor
          Interceptor that converts a message into a re-readable format
 

Constructors in org.apache.camel.processor.interceptor with parameters of type Processor
StreamCachingInterceptor(Processor processor)
           
 

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

Subinterfaces of Processor in org.apache.camel.processor.loadbalancer
 interface LoadBalancer
          A strategy for load balancing across a number of Processor instances
 

Classes in org.apache.camel.processor.loadbalancer that implement Processor
 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 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)
 

Methods in org.apache.camel.processor.loadbalancer that return Processor
protected  Processor StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected abstract  Processor QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
 

Methods in org.apache.camel.processor.loadbalancer that return types with arguments of type Processor
 List<Processor> LoadBalancerSupport.getProcessors()
           
 List<Processor> LoadBalancer.getProcessors()
          Returns the current processors available to this load balancer
 

Methods in org.apache.camel.processor.loadbalancer with parameters of type Processor
 void LoadBalancerSupport.addProcessor(Processor processor)
           
 void LoadBalancer.addProcessor(Processor processor)
          Adds a new processor to the load balancer
protected  Exchange TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
 void StickyLoadBalancer.removeProcessor(Processor processor)
           
 void LoadBalancerSupport.removeProcessor(Processor processor)
           
 void LoadBalancer.removeProcessor(Processor processor)
          Removes the given processor from the load balancer
 

Method parameters in org.apache.camel.processor.loadbalancer with type arguments of type Processor
protected  Processor StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected abstract  Processor QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
 

Constructors in org.apache.camel.processor.loadbalancer with parameters of type Processor
LoadBalancerConsumer(Endpoint endpoint, Processor processor, LoadBalancer loadBalancer)
           
 

Uses of Processor in org.apache.camel.processor.resequencer
 

Constructors in org.apache.camel.processor.resequencer with parameters of type Processor
SequenceSender(Processor processor)
          Creates a new SequenceSender thread.
 

Uses of Processor in org.apache.camel.processor.validation
 

Classes in org.apache.camel.processor.validation that implement Processor
 class ValidatingProcessor
          A processor which validates the XML version of the inbound message body against some schema either in XSD or RelaxNG
 

Uses of Processor in org.apache.camel.spi
 

Methods in org.apache.camel.spi that return Processor
 Processor Policy.wrap(Processor processor)
          Wraps any applicable interceptors around the given processor
 

Methods in org.apache.camel.spi with parameters of type Processor
 Processor Policy.wrap(Processor processor)
          Wraps any applicable interceptors around the given processor
 

Uses of Processor in org.apache.camel.util
 

Methods in org.apache.camel.util with parameters of type Processor
static void EndpointHelper.pollEndpoint(Endpoint endpoint, Processor processor)
          Creates a PollingConsumer and polls all pending messages on the endpoint and invokes the given Processor to process each Exchange and then closes down the consumer and throws any exceptions thrown.
static void EndpointHelper.pollEndpoint(Endpoint endpoint, Processor processor, long timeout)
          Creates a PollingConsumer and polls all pending messages on the endpoint and invokes the given Processor to process each Exchange and then closes down the consumer and throws any exceptions thrown.
 E ProducerCache.send(Endpoint<E> endpoint, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied Processor to populate the exchange
 E ProducerCache.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied Processor to populate the exchange
 E ProducerCache.send(Endpoint<E> endpoint, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied Processor to populate the exchange.
protected  E ProducerCache.sendExchange(Endpoint<E> endpoint, Producer<E> producer, Processor processor, E exchange)
           
protected  boolean ProducerCache.sendExchange(Endpoint<E> endpoint, Producer<E> producer, Processor processor, E exchange, AsyncCallback callback)
           
 



Copyright © 2008 IONA Open Source Community. All Rights Reserved.