Uses of Interface
org.apache.camel.Exchange

Packages that use Exchange
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.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.log   
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.vm The VM Component for asynchronous SEDA exchanges on a BlockingQueue within the current JVM; so across CamelContext instances. 
org.apache.camel.impl Default implementation classes for Camel Core 
org.apache.camel.language   
org.apache.camel.language.simple   
org.apache.camel.model Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. 
org.apache.camel.model.language Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. 
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.loadbalancer Various load balancer processors 
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 Exchange in org.apache.camel
 

Classes in org.apache.camel with type parameters of type Exchange
 class CamelTemplate<E extends Exchange>
          A client helper object (named like Spring's TransactionTemplate & JmsTemplate et al) for working with Camel and sending Message instances in an Exchange to an Endpoint.
 interface Component<E extends Exchange>
          A component is a factory of Endpoint objects.
 interface Consumer<E extends Exchange>
          A consumer of message exchanges from an Endpoint
 interface Endpoint<E extends Exchange>
          An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges
 interface Expression<E extends Exchange>
          An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression.
 interface PollingConsumer<E extends Exchange>
          Represents a Polling Consumer where the caller polls for messages when it is ready.
 interface Producer<E extends Exchange>
          Provides a channel on which clients can create and invoke message exchanges on an Endpoint
 interface ProducerTemplate<E extends Exchange>
           
 class Route<E extends Exchange>
          A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
 

Methods in org.apache.camel that return Exchange
 Exchange Exchange.copy()
          Creates a copy of the current message exchange so that it can be forwarded to another destination
 Exchange ExpectedBodyTypeException.getExchange()
           
 Exchange CamelExchangeException.getExchange()
          Returns the exchange which caused the exception
 Exchange Message.getExchange()
          Returns the exchange this message is related to
 

Methods in org.apache.camel with parameters of type Exchange
 void Exchange.copyFrom(Exchange source)
          Copies the data into this exchange from the given exchange #param source is the source from which headers and messages will be copied
 E Endpoint.createExchange(Exchange exchange)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
 void Processor.process(Exchange exchange)
          Processes the message exchange
protected static String NoSuchPropertyException.reason(Exchange exchange, String propertyName)
           
 E Endpoint.toExchangeType(Exchange exchange)
          Converts the given exchange to this endpoints required type
 

Constructors in org.apache.camel with parameters of type Exchange
CamelExchangeException(String message, Exchange exchange)
           
ExpectedBodyTypeException(Exchange exchange, Class expectedBodyType)
           
InvalidPayloadException(Exchange exchange, Class<?> type)
           
InvalidTypeException(Exchange exchange, Object value, Class<?> type)
           
NoSuchPropertyException(Exchange exchange, String propertyName, Class<?> type)
           
ValidationException(Exchange exchange, String message)
           
 

Uses of Exchange in org.apache.camel.builder
 

Classes in org.apache.camel.builder with type parameters of type Exchange
 interface PredicateFactory<E extends Exchange>
          A Factory of Predicate objects typically implemented by a builder such as @{XPathBuilder}
 class ValueBuilder<E extends Exchange>
          A builder of expressions or predicates based on values.
 

Methods in org.apache.camel.builder with type parameters of type Exchange
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.and(Predicate<E> left, Predicate<E> right)
          A helper method to combine multiple predicates by a logical AND
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.append(Expression<E> left, Expression<E> right)
          Appends the String evaluations of the two expressions together
static
<E extends Exchange>
ValueBuilder<E>
Builder.body()
          Returns a predicate and value builder for the inbound body on an exchange
static
<E extends Exchange,T>
ValueBuilder<E>
Builder.bodyAs(Class<T> type)
          Returns a predicate and value builder for the inbound message body as a specific type
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.bodyExpression()
          Returns the expression for the exchanges inbound message body
static
<E extends Exchange,T>
Expression<E>
ExpressionBuilder.bodyExpression(Class<T> type)
          Returns the expression for the exchanges inbound message body converted to the given type
static
<E extends Exchange>
ValueBuilder<E>
Builder.constant(Object value)
          Returns a constant expression
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.constantExpression(Object value)
          Returns an expression for the contant value
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.contains(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.convertTo(Expression expression, Class type)
          Returns an expression which converts the given expression to the given type
static
<E extends Exchange>
String
ExpressionBuilder.evaluateStringExpression(Expression<E> expression, E exchange)
          Evaluates the expression on the given exchange and returns the String representation
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.exchangeExpression()
          Returns the expression for the exchange
static
<E extends Exchange>
ValueBuilder<E>
Builder.header(String name)
          Returns a predicate and value builder for headers on an exchange
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.headerExpression(String headerName)
          Returns an expression for the header value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.inMessageExpression()
          Returns the expression for the IN message
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isInstanceOf(Expression<E> expression, Class type)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNotEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNotNull(Expression<E> expression)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNull(Expression<E> expression)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.not(Predicate<E> predicate)
          A helper method to return the logical not of the given predicate
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.or(Predicate<E> left, Predicate<E> right)
          A helper method to combine multiple predicates by a logical OR
static
<E extends Exchange>
ValueBuilder<E>
Builder.outBody()
          Returns a predicate and value builder for the outbound body on an exchange
static
<E extends Exchange,T>
ValueBuilder<E>
Builder.outBody(Class<T> type)
          Returns a predicate and value builder for the outbound message body as a specific type
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.outBodyExpression()
          Returns the expression for the out messages body
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.outHeaderExpression(String headerName)
          Returns an expression for the out header value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.propertyExpression(String propertyName)
          Returns an expression for the property value with the given name
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.regex(Expression<E> expression, Pattern pattern)
          Returns a predicate which is true if the expression matches the given regular expression
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.regex(Expression<E> expression, String regex)
          Returns a predicate which is true if the expression matches the given regular expression
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, Expression<E> replacementExpression)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, String replacement)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexTokenize(Expression<E> expression, String regexTokenizer)
          Returns a tokenize expression which will tokenize the string with the given regex
static
<E extends Exchange>
ValueBuilder<E>
Builder.systemProperty(String name)
          Returns an expression for the given system property
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemProperty(String name)
          Returns an expression for the given system property
static
<E extends Exchange>
ValueBuilder<E>
Builder.systemProperty(String name, String defaultValue)
          Returns an expression for the given system property
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemProperty(String name, String defaultValue)
          Returns an expression for the given system property
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemPropertyExpression(String propertyName)
          Returns an expression for a system property value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemPropertyExpression(String propertyName, String defaultValue)
          Returns an expression for a system property value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.tokenizeExpression(Expression<E> expression, String token)
          Returns a tokenize expression which will tokenize the string with the given token
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.toPredicate(Expression<E> expression)
          Converts the given expression into an Predicate
 

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

Classes in org.apache.camel.builder.xml with type parameters of type Exchange
 class XPathBuilder<E extends Exchange>
          Creates an XPath expression builder
 

Methods in org.apache.camel.builder.xml that return Exchange
 Exchange MessageVariableResolver.getExchange()
           
 

Methods in org.apache.camel.builder.xml that return types with arguments of type Exchange
 Expression<Exchange> XPathLanguage.createExpression(String expression)
           
 Predicate<Exchange> XPathLanguage.createPredicate(String expression)
           
 

Methods in org.apache.camel.builder.xml with parameters of type Exchange
protected  void XsltBuilder.configureTransformer(Transformer transformer, Exchange exchange)
          Configures the transformerwith exchange specific parameters
protected  Source XsltBuilder.getSource(Exchange exchange)
          Converts the inbound body to a Source
 void XsltBuilder.process(Exchange exchange)
           
 void MessageVariableResolver.setExchange(Exchange exchange)
           
 

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

Classes in org.apache.camel.component.bean that implement Exchange
 class BeanExchange
           
 

Methods in org.apache.camel.component.bean that return Exchange
 Exchange BeanExchange.newInstance()
           
 

Methods in org.apache.camel.component.bean with parameters of type Exchange
protected  MethodInfo BeanInfo.chooseMethod(Object pojo, Exchange exchange)
          Lets try choose one of the available methods to invoke if we can match the message body to the body parameter
 MethodInvocation BeanInfo.createInvocation(Method method, Object pojo, Exchange exchange)
           
 MethodInvocation BeanInfo.createInvocation(Object pojo, Exchange exchange)
           
 MethodInvocation MethodInfo.createMethodInvocation(Object pojo, Exchange messageExchange)
           
protected  Object MethodInfo.invoke(Method mth, Object pojo, Object[] arguments, Exchange exchange)
           
 void BeanInvocation.invoke(Object pojo, Exchange exchange)
          This causes us to invoke the endpoint Pojo using reflection.
 void BeanProcessor.process(Exchange exchange)
           
 

Constructors in org.apache.camel.component.bean with parameters of type Exchange
AmbiguousMethodCallException(Exchange exchange, List<MethodInfo> methods)
           
 

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

Classes in org.apache.camel.component.direct with type parameters of type Exchange
 class DirectComponent<E extends Exchange>
          Represents the component that manages DirectEndpoint.
 class DirectEndpoint<E extends Exchange>
          Represents a direct endpoint that synchronously invokes the consumers of the endpoint when a producer sends a message to it.
 

Methods in org.apache.camel.component.direct with parameters of type Exchange
protected  void DirectEndpoint.process(Exchange exchange)
           
 

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

Classes in org.apache.camel.component.file that implement Exchange
 class FileExchange
          A Exchange for File
 

Methods in org.apache.camel.component.file that return Exchange
 Exchange FileExchange.newInstance()
           
 

Methods in org.apache.camel.component.file with parameters of type Exchange
 void FileProducer.process(Exchange exchange)
           
 

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

Classes in org.apache.camel.component.jmx that implement Exchange
 class JMXExchange
          A Exchange for a jmx notification
 

Uses of Exchange in org.apache.camel.component.log
 

Methods in org.apache.camel.component.log that return types with arguments of type Exchange
protected  Endpoint<Exchange> LogComponent.createEndpoint(String uri, String remaining, Map parameters)
           
 

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

Classes in org.apache.camel.component.mock with type parameters of type Exchange
 class AssertionClause<E extends Exchange>
          A builder of assertions on message exchanges
 

Methods in org.apache.camel.component.mock that return Exchange
 Exchange MockEndpoint.assertExchangeReceived(int index)
          Asserts that the given index of message is received (starting at zero)
 Exchange MockEndpoint.createExchange()
           
 

Methods in org.apache.camel.component.mock that return types with arguments of type Exchange
 Consumer<Exchange> MockEndpoint.createConsumer(Processor processor)
           
protected  Endpoint<Exchange> MockComponent.createEndpoint(String uri, String remaining, Map parameters)
           
 Producer<Exchange> MockEndpoint.createProducer()
           
 List<Exchange> MockEndpoint.getReceivedExchanges()
           
 

Methods in org.apache.camel.component.mock with parameters of type Exchange
protected  void MockEndpoint.onExchange(Exchange exchange)
           
 

Method parameters in org.apache.camel.component.mock with type arguments of type Exchange
 void MockEndpoint.assertMessagesAscending(Expression<Exchange> expression)
          Asserts that the messages have ascending values of the given expression
 void MockEndpoint.assertMessagesDescending(Expression<Exchange> expression)
          Asserts that the messages have descending values of the given expression
protected  void MockEndpoint.assertMessagesSorted(Expression<Exchange> expression, boolean ascending)
           
 void MockEndpoint.assertNoDuplicates(Expression<Exchange> expression)
           
 void MockEndpoint.expectsAscending(Expression<Exchange> expression)
          Adds an expectation that messages received should have ascending values of the given expression such as a user generated counter value
 void MockEndpoint.expectsDescending(Expression<Exchange> expression)
          Adds an expectation that messages received should have descending values of the given expression such as a user generated counter value
 void MockEndpoint.expectsNoDuplicates(Expression<Exchange> expression)
          Adds an expectation that no duplicate messages should be received using the expression to determine the message ID
 

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

Classes in org.apache.camel.component.seda with type parameters of type Exchange
 class QueueComponent<E extends Exchange>
          An implementation of the Queue components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext
 class SedaComponent<E extends Exchange>
          An implementation of the SEDA components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext
 class SedaConsumer<E extends Exchange>
           
 class SedaEndpoint<E extends Exchange>
          An implementation of the Queue components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext
 

Uses of Exchange in org.apache.camel.component.vm
 

Classes in org.apache.camel.component.vm with type parameters of type Exchange
 class VmComponent<E extends Exchange>
          An implementation of the VM components for asynchronous SEDA exchanges on a BlockingQueue within the classloader tree containing the camel-core.jar.
 

Fields in org.apache.camel.component.vm with type parameters of type Exchange
protected static Map<String,BlockingQueue<Exchange>> VmComponent.queues
           
 

Methods in org.apache.camel.component.vm that return types with arguments of type Exchange
protected  BlockingQueue<Exchange> VmComponent.getBlockingQueue(String uri)
           
 

Uses of Exchange in org.apache.camel.impl
 

Classes in org.apache.camel.impl with type parameters of type Exchange
 class BinaryPredicateSupport<E extends Exchange>
          A useful base class for Predicate implementations
 class DefaultComponent<E extends Exchange>
           
 class DefaultComponentResolver<E extends Exchange>
          The default implementation of ComponentResolver which tries to find components by using the URI scheme prefix and searching for a file of the URI scheme name in the META-INF/services/org/apache/camel/component/ directory on the classpath.
 class DefaultConsumer<E extends Exchange>
           
 class DefaultEndpoint<E extends Exchange>
          A default endpoint useful for implementation inheritance
 class DefaultPollingConsumer<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.
 class DefaultProducer<E extends Exchange>
          A default implementation of @{link Producer} for implementation inheritence
 class EventDrivenConsumerRoute<E extends Exchange>
          A Route which starts with an Event Driven Consumer
 class ExpressionSupport<E extends Exchange>
          A useful base class for Predicate and Expression implementations
 class PollingConsumerSupport<E extends Exchange>
          A useful base class for implementations of PollingConsumer
 class PredicateSupport<E extends Exchange>
          A useful base class for Predicate implementations
 class ScheduledPollConsumer<E extends Exchange>
          A useful base class for any consumer which is polling based
 class ScheduledPollEndpoint<E extends Exchange>
          A base class for Endpoint which creates a ScheduledPollConsumer
 

Classes in org.apache.camel.impl that implement Exchange
 class DefaultExchange
          A default implementation of Exchange
 

Methods in org.apache.camel.impl that return Exchange
 Exchange DefaultExchange.copy()
           
 Exchange ProcessorEndpoint.createExchange()
           
 Exchange MessageSupport.getExchange()
           
 Exchange DefaultExchange.newInstance()
           
 

Methods in org.apache.camel.impl that return types with arguments of type Exchange
 Consumer<Exchange> ProcessorEndpoint.createConsumer(Processor processor)
           
 Producer<Exchange> ProcessorEndpoint.createProducer()
           
 

Methods in org.apache.camel.impl with parameters of type Exchange
 E DefaultEndpoint.convertTo(Class<E> type, Exchange exchange)
          Converts the given exchange to the specified exchange type
<T> T
DefaultExchangeConverter.convertTo(Class<T> type, Exchange exchange)
           
 void DefaultExchange.copyFrom(Exchange exchange)
           
 E DefaultEndpoint.createExchange(Exchange exchange)
           
protected  void ProcessorEndpoint.onExchange(Exchange exchange)
           
 void DefaultPollingConsumer.process(Exchange exchange)
           
 void MessageSupport.setExchange(Exchange exchange)
           
 E DefaultEndpoint.toExchangeType(Exchange exchange)
           
 

Uses of Exchange in org.apache.camel.language
 

Methods in org.apache.camel.language that return types with arguments of type Exchange
 Expression<Exchange> ExpressionEvaluationException.getExpression()
           
 

Constructors in org.apache.camel.language with parameters of type Exchange
ExpressionEvaluationException(Expression<Exchange> expression, Exchange exchange, Throwable cause)
           
 

Constructor parameters in org.apache.camel.language with type arguments of type Exchange
ExpressionEvaluationException(Expression<Exchange> expression, Exchange exchange, Throwable cause)
           
 

Uses of Exchange in org.apache.camel.language.simple
 

Methods in org.apache.camel.language.simple that return types with arguments of type Exchange
 Expression<Exchange> SimpleLanguage.createExpression(String expression)
           
 Predicate<Exchange> SimpleLanguage.createPredicate(String expression)
           
 

Uses of Exchange in org.apache.camel.model
 

Method parameters in org.apache.camel.model with type arguments of type Exchange
 DelayerType ProcessorType.delayer(Expression<Exchange> processAtExpression)
          A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on
 DelayerType ProcessorType.delayer(Expression<Exchange> processAtExpression, long delay)
          A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on
 ResequencerType ProcessorType.resequencer(Expression<Exchange> expression)
          A builder for the Resequencer pattern where an expression is evaluated to be able to compare the message exchanges to reorder them.
 

Uses of Exchange in org.apache.camel.model.language
 

Methods in org.apache.camel.model.language that return types with arguments of type Exchange
 Predicate<Exchange> ExpressionType.createPredicate(RouteContext route)
           
 

Uses of Exchange in org.apache.camel.processor
 

Methods in org.apache.camel.processor with type parameters of type Exchange
static
<E extends Exchange>
Logger
DeadLetterChannel.createDefaultLogger()
           
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 that return Exchange
protected  Exchange Pipeline.copyExchangeStrategy(Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange MulticastProcessor.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
 

Methods in org.apache.camel.processor that return types with arguments of type Exchange
protected static Set<Exchange> Resequencer.createSet(Comparator<? super Exchange> comparator)
           
protected static Set<Exchange> Resequencer.createSet(Expression<Exchange> expression)
           
protected static Set<Exchange> Resequencer.createSet(List<Expression> expressions)
           
protected  Collection<Exchange> BatchProcessor.getCollection()
           
 Predicate<Exchange> FilterProcessor.getPredicate()
           
protected  Endpoint<Exchange> RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
 

Methods in org.apache.camel.processor with parameters of type Exchange
protected  Exchange Pipeline.copyExchangeStrategy(Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange MulticastProcessor.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
protected  boolean ErrorHandlerSupport.customProcessorForException(Exchange exchange, Throwable exception)
          Attempts to invoke the handler for this particular exception if one is available
protected  long Delayer.defaultProcessTime(Exchange exchange)
          A Strategy Method to allow derived implementations to decide the current system time or some other default exchange property
protected  void Throttler.delay(Exchange exchange)
           
protected  void Delayer.delay(Exchange exchange)
          Waits for an optional time period before continuing to process the exchange
protected abstract  void DelayProcessorSupport.delay(Exchange exchange)
           
protected  ExceptionType ErrorHandlerSupport.getExceptionPolicy(Exchange exchange, Throwable exception)
           
protected  void TryProcessor.handleException(Exchange exchange, Exception e)
           
protected  int DeadLetterChannel.incrementRedeliveryCounter(Exchange exchange, Throwable e)
          Increments the redelivery counter and adds the redelivered flag if the message has been redelivered
protected  void LoggingErrorHandler.logError(Exchange exchange, Throwable e)
           
protected  Object Logger.logMessage(Exchange exchange)
           
protected  Object LoggingErrorHandler.logMessage(Exchange exchange, Throwable e)
           
 void DelegateProcessor.proceed(Exchange exchange)
          Proceed with the underlying delegated processor
 void ChoiceProcessor.process(Exchange exchange)
           
 void Splitter.process(Exchange exchange)
           
 void ProceedProcessor.process(Exchange exchange)
           
 void SendProcessor.process(Exchange exchange)
           
 void CompositeProcessor.process(Exchange exchange)
           
 void DelayProcessorSupport.process(Exchange exchange)
           
 void RecipientList.process(Exchange exchange)
           
 void TryProcessor.process(Exchange exchange)
           
 void LoggingErrorHandler.process(Exchange exchange)
           
 void DeadLetterChannel.process(Exchange exchange)
           
 void MulticastProcessor.process(Exchange exchange)
           
 void Pipeline.process(Exchange exchange)
           
 void FilterProcessor.process(Exchange exchange)
           
 void Interceptor.process(Exchange exchange)
           
 void Logger.process(Exchange exchange)
           
 void DelegateProcessor.process(Exchange exchange)
           
protected  void BatchProcessor.processExchange(Exchange exchange)
          Strategy Method to process an exchange in the batch.
protected  void DelegateProcessor.processNext(Exchange exchange)
           
protected  Endpoint<Exchange> RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
protected  void DelayProcessorSupport.waitUntil(long time, Exchange exchange)
          Wait until the given system time before continuing
 

Method parameters in org.apache.camel.processor with type arguments of type Exchange
protected static Set<Exchange> Resequencer.createSet(Comparator<? super Exchange> comparator)
           
protected static Set<Exchange> Resequencer.createSet(Expression<Exchange> expression)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Exchange
BatchProcessor(Endpoint endpoint, Processor processor, Collection<Exchange> collection)
           
Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)
           
FilterProcessor(Predicate<Exchange> predicate, Processor processor)
           
RecipientList(Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, Set<Exchange> collection)
           
 

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

Methods in org.apache.camel.processor.aggregate that return Exchange
 Exchange UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
           
 Exchange AggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
          Aggregates an old and new exchange together to create a single combined exchange
 

Methods in org.apache.camel.processor.aggregate that return types with arguments of type Exchange
 Iterator<Exchange> AggregationCollection.iterator()
           
 

Methods in org.apache.camel.processor.aggregate with parameters of type Exchange
 boolean AggregationCollection.add(Exchange exchange)
           
 Exchange UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
           
 Exchange AggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
          Aggregates an old and new exchange together to create a single combined exchange
 

Constructor parameters in org.apache.camel.processor.aggregate with type arguments of type Exchange
AggregationCollection(Expression<Exchange> correlationExpression, AggregationStrategy aggregationStrategy)
           
 

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

Methods in org.apache.camel.processor.idempotent that return Exchange
 Exchange NoMessageIdException.getExchange()
          The exchange which caused this failure
 

Methods in org.apache.camel.processor.idempotent that return types with arguments of type Exchange
 Expression<Exchange> IdempotentConsumer.getMessageIdExpression()
           
 

Methods in org.apache.camel.processor.idempotent with parameters of type Exchange
protected  void IdempotentConsumer.onDuplicateMessage(Exchange exchange, String messageId)
          A strategy method to allow derived classes to overload the behaviour of processing a duplicate message
 void IdempotentConsumer.process(Exchange exchange)
           
 

Constructors in org.apache.camel.processor.idempotent with parameters of type Exchange
NoMessageIdException(Exchange exchange, Expression expression)
           
 

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

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

Methods in org.apache.camel.processor.loadbalancer that return Exchange
protected  Exchange TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
 

Methods in org.apache.camel.processor.loadbalancer with parameters of type Exchange
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor StickyLoadBalancer.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)
           
protected  Exchange TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
 void TopicLoadBalancer.process(Exchange exchange)
           
 void QueueLoadBalancer.process(Exchange exchange)
           
 

Constructor parameters in org.apache.camel.processor.loadbalancer with type arguments of type Exchange
StickyLoadBalancer(Expression<Exchange> correlationExpression)
           
StickyLoadBalancer(Expression<Exchange> correlationExpression, QueueLoadBalancer loadBalancer)
           
 

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

Methods in org.apache.camel.processor.validation with parameters of type Exchange
 void DefaultValidationErrorHandler.handleErrors(Exchange exchange, Object schema)
           
 void DefaultValidationErrorHandler.handleErrors(Exchange exchange, Schema schema, DOMResult result)
           
 void ValidatorErrorHandler.handleErrors(Exchange exchange, Schema schema, DOMResult result)
          Process any errors which may have occurred during validation
 void ValidatingProcessor.process(Exchange exchange)
           
 

Constructors in org.apache.camel.processor.validation with parameters of type Exchange
NoXmlBodyValidationException(Exchange exchange)
           
SchemaValidationException(Exchange exchange, Object schema, List<SAXParseException> fatalErrors, List<SAXParseException> errors, List<SAXParseException> warnings)
           
 

Uses of Exchange in org.apache.camel.spi
 

Classes in org.apache.camel.spi with type parameters of type Exchange
 interface ComponentResolver<E extends Exchange>
          Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like DefaultComponentResolver
 

Methods in org.apache.camel.spi that return types with arguments of type Exchange
 Expression<Exchange> Language.createExpression(String expression)
           
 Predicate<Exchange> Language.createPredicate(String expression)
           
 

Methods in org.apache.camel.spi with parameters of type Exchange
<T> T
ExchangeConverter.convertTo(Class<T> type, Exchange exchange)
           
 

Uses of Exchange in org.apache.camel.util
 

Classes in org.apache.camel.util with type parameters of type Exchange
 class ExpressionComparator<E extends Exchange>
          An implementation of Comparator which takes an Expression which is evaluated on each exchange to compare
 class ProducerCache<E extends Exchange>
           
 

Methods in org.apache.camel.util with type parameters of type Exchange
static
<E extends Exchange>
String
ExpressionHelper.evaluateAsString(Expression<E> expression, E exchange)
          Evaluates the given expression on the exchange as a String value
static
<T,E extends Exchange>
T
ExpressionHelper.evaluateAsType(Expression<E> expression, E exchange, Class<T> resultType)
          Evaluates the given expression on the exchange, converting the result to the given type
static
<E extends Exchange>
Endpoint<E>
ExchangeHelper.resolveEndpoint(E exchange, Object value)
          Attempts to resolve the endpoint for the given value
 

Methods in org.apache.camel.util with parameters of type Exchange
 int ExpressionListComparator.compare(Exchange e1, Exchange e2)
           
static
<T> T
ExchangeHelper.convertToMandatoryType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type or throws an exception
static
<T> T
ExchangeHelper.convertToType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type returning null if it could not be converted
static
<T> T
ExchangeHelper.getMandatoryInBody(Exchange exchange, Class<T> type)
          Returns the mandatory inbound message body of the correct type or throws an exception if it is not present
static
<T> T
ExchangeHelper.getMandatoryProperty(Exchange exchange, String propertyName, Class<T> type)
           
 



Copyright © 2007 Apache Software Foundation. All Rights Reserved.