Uses of Interface
org.apache.camel.Exchange

Packages that use Exchange

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.api.management	Service provider interfaces for management.
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.binding	The Binding Component which is a way of wrapping an Endpoint in a contract; such as a Data Format, a Content Enricher or validation step.
org.apache.camel.component.browse	The Browse 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.controlbus	The Control Bus Component which allows to manage Camel at runtime.
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.directvm	The Direct VM Component which synchronously invokes the consumer 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.file.strategy	Strategies for the File Component.
org.apache.camel.component.language	The Language Component to send messages to language endpoints executing the script.
org.apache.camel.component.log	The Log Component uses Jakarta Commons Logging to log message exchanges.
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.test	A Test Endpoint for Pattern Based Testing
org.apache.camel.component.xslt	The XSLT Component for transforming messages with XSLT
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.converter.jaxp	A number of JAXP related helper classes for converting to and from various JAXP related classes like Document and Source to be used by a TypeConverter
org.apache.camel.converter.stream	Package with converters for dealing with stream-based messages
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.language.bean	Camel Bean language.
org.apache.camel.management	Camel management
org.apache.camel.management.event	Camel management events
org.apache.camel.management.mbean	Camel management JMX MBeans
org.apache.camel.model	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.model.language	The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration.
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.binding	Helper classes for the Binding concept on Endpoints.
org.apache.camel.processor.exceptionpolicy	Exception policy startegies for Dead Letter Channel 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
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.support	Base classes that help to implement the camel API and are expected to be extended by the user
org.apache.camel.util	Utility classes used by the core of Camel.
org.apache.camel.util.component
org.apache.camel.util.toolbox	Toolbox classes to create commonly used Aggregation Strategies in a fluent manner.

Uses of Exchange in org.apache.camel

Methods in org.apache.camel that return Exchange

Modifier and Type	Method and Description
Exchange	Exchange.copy() Creates a copy of the current message exchange so that it can be forwarded to another destination
Exchange	Producer.createExchange() Creates a new exchange to send to this endpoint
Exchange	Endpoint.createExchange() Create a new exchange for communicating with this endpoint
Exchange	Producer.createExchange(Exchange exchange) Deprecated. will be removed in Camel 3.0
Exchange	Endpoint.createExchange(Exchange exchange) Deprecated. will be removed in Camel 3.0
Exchange	Producer.createExchange(ExchangePattern pattern) Creates a new exchange of the given pattern to send to this endpoint
Exchange	Endpoint.createExchange(ExchangePattern pattern) Create a new exchange for communicating with this endpoint with the specified ExchangePattern such as whether its going to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
Exchange	CamelExchangeException.getExchange() Returns the exchange which caused the exception
Exchange	Message.getExchange() Returns the exchange this message is related to
Exchange	RuntimeExchangeException.getExchange() Returns the exchange which caused the exception Can be null
Exchange	ExpressionEvaluationException.getExchange()
Exchange	ExpectedBodyTypeException.getExchange()
Exchange	PollingConsumer.receive() Waits until a message is available and then returns it.
Exchange	ConsumerTemplate.receive(Endpoint endpoint) Receives from the endpoint, waiting until there is a response.
Exchange	ConsumerTemplate.receive(Endpoint endpoint, long timeout) Receives from the endpoint, waiting until there is a response or the timeout occurs Important: See ConsumerTemplate.doneUoW(Exchange)
Exchange	PollingConsumer.receive(long timeout) Attempts to receive a message exchange, waiting up to the given timeout to expire if a message is not yet available.
Exchange	ConsumerTemplate.receive(String endpointUri) Receives from the endpoint, waiting until there is a response Important: See ConsumerTemplate.doneUoW(Exchange)
Exchange	ConsumerTemplate.receive(String endpointUri, long timeout) Receives from the endpoint, waiting until there is a response or the timeout occurs Important: See ConsumerTemplate.doneUoW(Exchange)
Exchange	PollingConsumer.receiveNoWait() Attempts to receive a message exchange immediately without waiting and returning null if a message exchange is not available yet.
Exchange	ConsumerTemplate.receiveNoWait(Endpoint endpoint) Receives from the endpoint, not waiting for a response if non exists.
Exchange	ConsumerTemplate.receiveNoWait(String endpointUri) Receives from the endpoint, not waiting for a response if non exists.
Exchange	ProducerTemplate.request(Endpoint endpoint, Processor processor) Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.
Exchange	ProducerTemplate.request(String endpointUri, Processor processor) Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.
Exchange	ProducerTemplate.send(Endpoint endpoint, Exchange exchange) Sends the exchange to the given endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor) Sends an exchange to an endpoint using a supplied processor Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(Endpoint endpoint, Processor processor) Sends an exchange to an endpoint using a supplied processor Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(Exchange exchange) Sends the exchange to the default endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(Processor processor) Sends an exchange to the default endpoint using a supplied processor Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(String endpointUri, Exchange exchange) Sends the exchange to the given endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor) Sends an exchange to an endpoint using a supplied processor Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(String endpointUri, Processor processor) Sends an exchange to an endpoint using a supplied processor Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().

Methods in org.apache.camel that return types with arguments of type Exchange

Modifier and Type	Method and Description
Future<Exchange>	ProducerTemplate.asyncCallback(Endpoint endpoint, Exchange exchange, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncCallback(Endpoint endpoint, Processor processor, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint using a supplied processor.
Future<Exchange>	ProducerTemplate.asyncCallback(String endpointUri, Exchange exchange, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncCallback(String endpointUri, Processor processor, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint using a supplied processor.
Future<Exchange>	ProducerTemplate.asyncSend(Endpoint endpoint, Exchange exchange) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncSend(Endpoint endpoint, Processor processor) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncSend(String endpointUri, Exchange exchange) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncSend(String endpointUri, Processor processor) Sends an asynchronous exchange to the given endpoint.

Methods in org.apache.camel with parameters of type Exchange

Modifier and Type	Method and Description
Future<Exchange>	ProducerTemplate.asyncCallback(Endpoint endpoint, Exchange exchange, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncCallback(String endpointUri, Exchange exchange, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncSend(Endpoint endpoint, Exchange exchange) Sends an asynchronous exchange to the given endpoint.
Future<Exchange>	ProducerTemplate.asyncSend(String endpointUri, Exchange exchange) Sends an asynchronous exchange to the given endpoint.
<T> T	TypeConverter.convertTo(Class<T> type, Exchange exchange, Object value) Converts the value to the specified type in the context of an exchange Used when conversion requires extra information from the current exchange (such as encoding).
static String	CamelExchangeException.createExceptionMessage(String message, Exchange exchange, Throwable cause) Creates an exception message with the provided details.
Exchange	Producer.createExchange(Exchange exchange) Deprecated. will be removed in Camel 3.0
Exchange	Endpoint.createExchange(Exchange exchange) Deprecated. will be removed in Camel 3.0
protected static String	RuntimeExchangeException.createMessage(String message, Exchange exchange)
boolean	AsyncProducerCallback.doInAsyncProducer(Producer producer, AsyncProcessor asyncProducer, Exchange exchange, ExchangePattern exchangePattern, AsyncCallback callback) Performs operation on the given producer to send the given exchange.
T	ProducerCallback.doInProducer(Producer producer, Exchange exchange, ExchangePattern exchangePattern) Performs operation on the given producer to send the given exchange.
void	ConsumerTemplate.doneUoW(Exchange exchange) If you have used any of the receive methods which returns a Exchange type then you need to invoke this method when you are done using the returned Exchange.
<T> T	Expression.evaluate(Exchange exchange, Class<T> type) Returns the value of the expression on the given exchange
String	RouteNode.getLabel(Exchange exchange) Gets a label about this node to be used for tracing or tooling etc.
void	Exchange.handoverCompletions(Exchange target) Handover all the on completions from this exchange to the target exchange.
<T> T	TypeConverter.mandatoryConvertTo(Class<T> type, Exchange exchange, Object value) Converts the value to the specified type in the context of an exchange Used when conversion requires extra information from the current exchange (such as encoding).
boolean	Predicate.matches(Exchange exchange) Evaluates the predicate on the message exchange and returns true if this exchange matches the predicate
String	BinaryPredicate.matchesReturningFailureMessage(Exchange exchange) Evaluates the predicate on the message exchange and returns null if this exchange matches the predicate.
void	Processor.process(Exchange exchange) Processes the message exchange
boolean	AsyncProcessor.process(Exchange exchange, AsyncCallback callback) Processes the message exchange.
protected static String	NoSuchHeaderException.reason(Exchange exchange, String propertyName)
protected static String	NoSuchPropertyException.reason(Exchange exchange, String propertyName)
Exchange	ProducerTemplate.send(Endpoint endpoint, Exchange exchange) Sends the exchange to the given endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(Exchange exchange) Sends the exchange to the default endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
Exchange	ProducerTemplate.send(String endpointUri, Exchange exchange) Sends the exchange to the given endpoint Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException().
<T> T	TypeConverter.tryConvertTo(Class<T> type, Exchange exchange, Object value) Tries to convert the value to the specified type in the context of an exchange, returning null if not possible to convert.

Constructors in org.apache.camel with parameters of type Exchange

Constructor and Description
CamelAuthorizationException(String message, Exchange exchange)
CamelAuthorizationException(String message, Exchange exchange, Throwable cause)
CamelExchangeException(String message, Exchange exchange)
CamelExchangeException(String message, Exchange exchange, Throwable cause)
CamelExecutionException(String message, Exchange exchange)
CamelExecutionException(String message, Exchange exchange, Throwable cause)
CamelUnitOfWorkException(Exchange exchange, List<Exception> causes)
ExchangeTimedOutException(Exchange exchange, long timeout)
ExchangeTimedOutException(Exchange exchange, long timeout, String message)
ExpectedBodyTypeException(Exchange exchange, Class<?> expectedBodyType)
ExpressionEvaluationException(Expression expression, Exchange exchange, Throwable cause)
ExpressionEvaluationException(Expression expression, String message, Exchange exchange, Throwable cause)
InvalidPayloadException(Exchange exchange, Class<?> type)
InvalidPayloadException(Exchange exchange, Class<?> type, Message message)
InvalidPayloadException(Exchange exchange, Class<?> type, Message message, Throwable cause)
InvalidPayloadRuntimeException(Exchange exchange, Class<?> type)
InvalidPayloadRuntimeException(Exchange exchange, Class<?> type, Message message)
InvalidPayloadRuntimeException(Exchange exchange, Class<?> type, Message message, Throwable cause)
InvalidPayloadRuntimeException(Exchange exchange, Class<?> type, Throwable cause)
NoSuchHeaderException(Exchange exchange, String headerName, Class<?> type)
NoSuchPropertyException(Exchange exchange, String propertyName, Class<?> type)
RollbackExchangeException(Exchange exchange)
RollbackExchangeException(Exchange exchange, Throwable cause)
RollbackExchangeException(String message, Exchange exchange)
RollbackExchangeException(String message, Exchange exchange, Throwable cause)
RuntimeExchangeException(String message, Exchange exchange)
RuntimeExchangeException(String message, Exchange exchange, Throwable cause)
ValidationException(Exchange exchange, String message)
ValidationException(String message, Exchange exchange, Throwable cause)

Uses of Exchange in org.apache.camel.api.management

Methods in org.apache.camel.api.management with parameters of type Exchange

Modifier and Type	Method and Description
void	PerformanceCounter.completedExchange(Exchange exchange, long time) Executed when an Exchange is complete.
void	PerformanceCounter.failedExchange(Exchange exchange) Executed when an Exchange failed.

Uses of Exchange in org.apache.camel.builder

Methods in org.apache.camel.builder that return Exchange

Modifier and Type	Method and Description
Exchange	ExchangeBuilder.build() Build up the exchange from the exchange builder

Methods in org.apache.camel.builder with parameters of type Exchange

Modifier and Type	Method and Description
<T> T	SimpleBuilder.evaluate(Exchange exchange, Class<T> type)
<T> T	ValueBuilder.evaluate(Exchange exchange, Class<T> type)
boolean	SimpleBuilder.matches(Exchange exchange)
boolean	BinaryPredicateSupport.matches(Exchange exchange)
boolean	ValueBuilder.matches(Exchange exchange)
protected abstract boolean	BinaryPredicateSupport.matches(Exchange exchange, Object leftValue, Object rightValue)
String	BinaryPredicateSupport.matchesReturningFailureMessage(Exchange exchange)

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

Methods in org.apache.camel.builder.xml with parameters of type Exchange

Modifier and Type	Method and Description
protected void	XsltBuilder.configureTransformer(Transformer transformer, Exchange exchange) Configures the transformer with exchange specific parameters
ResultHandler	DomResultHandlerFactory.createResult(Exchange exchange)
ResultHandler	FileResultHandlerFactory.createResult(Exchange exchange)
ResultHandler	StringResultHandlerFactory.createResult(Exchange exchange)
ResultHandler	ResultHandlerFactory.createResult(Exchange exchange) Creates the ResultHandler to use
ResultHandler	StreamResultHandlerFactory.createResult(Exchange exchange)
protected Object	XPathBuilder.doGetDocument(Exchange exchange, Object body)
protected Object	XPathBuilder.doInEvaluateAs(XPathExpression xpathExpression, Exchange exchange, QName resultQName)
protected Object	XPathBuilder.evaluate(Exchange exchange)
<T> T	XPathBuilder.evaluate(Exchange exchange, Class<T> type)
protected Object	XPathBuilder.evaluateAs(Exchange exchange, QName resultQName) Evaluates the expression as the given result type
protected Object	XPathBuilder.getDocument(Exchange exchange, Object body) Strategy method to extract the document from the exchange.
protected Source	XsltBuilder.getSource(Exchange exchange, Object body) Converts the inbound body to a Source, if the body is not already a Source.
protected boolean	XsltBuilder.isInputStreamNeeded(Exchange exchange) Checks whether we need an InputStream to access the message body.
protected boolean	XPathBuilder.isInputStreamNeeded(Exchange exchange) Checks whether we need an InputStream to access the message body.
protected boolean	XPathBuilder.isInputStreamNeeded(Exchange exchange, String headerName) Checks whether we need an InputStream to access the message header.
protected boolean	XPathBuilder.isInputStreamNeededForObject(Exchange exchange, Object obj) Checks whether we need an InputStream to access this object Depending on the content in the object, we may not need to convert to InputStream.
boolean	XPathBuilder.matches(Exchange exchange)
void	XsltBuilder.process(Exchange exchange)

Constructors in org.apache.camel.builder.xml with parameters of type Exchange

Constructor and Description
DefaultTransformErrorHandler(Exchange exchange)

Constructor parameters in org.apache.camel.builder.xml with type arguments of type Exchange

Constructor and Description
MessageVariableResolver(ThreadLocal<Exchange> exchange)

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

Methods in org.apache.camel.component.bean with parameters of type Exchange

Modifier and Type	Method and Description
protected Object	AbstractCamelInvocationHandler.afterInvoke(Method method, Exchange exchange, ExchangePattern pattern, boolean isFuture)
protected MethodInfo	BeanInfo.chooseMethod(Object pojo, Exchange exchange, String name) Choose one of the available methods to invoke if we can match the message body to the body parameter
static Object	BeanConverter.convertTo(Class<?> type, Exchange exchange, Object value, TypeConverterRegistry registry)
MethodInvocation	BeanInfo.createInvocation(Object pojo, Exchange exchange)
MethodInvocation	MethodInfo.createMethodInvocation(Object pojo, Exchange exchange)
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)
boolean	BeanProcessor.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.component.bean with parameters of type Exchange

Constructor and Description
AmbiguousMethodCallException(Exchange exchange, Collection<MethodInfo> methods)
MethodNotFoundException(Exchange exchange, Class<?> type, String methodName, boolean isStaticMethod)
MethodNotFoundException(Exchange exchange, Object pojo, String methodName)
MethodNotFoundException(Exchange exchange, Object pojo, String methodName, String postfix)

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

Methods in org.apache.camel.component.binding with parameters of type Exchange

Modifier and Type	Method and Description
void	BindingEndpoint.pipelineBindingProcessor(Processor bindingProcessor, Exchange exchange, Processor delegateProcessor) Applies the Binding processor to the given exchange before passing it on to the delegateProcessor (either a producer or consumer)
void	BindingConsumerProcessor.process(Exchange exchange)
void	BindingProducer.process(Exchange exchange)

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

Methods in org.apache.camel.component.browse that return types with arguments of type Exchange

Modifier and Type	Method and Description
protected List<Exchange>	BrowseEndpoint.createExchangeList()
List<Exchange>	BrowseEndpoint.getExchanges()

Methods in org.apache.camel.component.browse with parameters of type Exchange

Modifier and Type	Method and Description
protected void	BrowseEndpoint.onExchange(Exchange exchange) Invoked on a message exchange being sent by a producer

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

Methods in org.apache.camel.component.controlbus with parameters of type Exchange

Modifier and Type	Method and Description
boolean	ControlBusProducer.process(Exchange exchange, AsyncCallback callback)
protected void	ControlBusProducer.processByAction(Exchange exchange)
protected void	ControlBusProducer.processByLanguage(Exchange exchange, Language language)

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

Methods in org.apache.camel.component.dataset that return Exchange

Modifier and Type	Method and Description
Exchange	DataSetEndpoint.createExchange(long messageIndex) Creates a message exchange for the given index in the DataSet

Methods in org.apache.camel.component.dataset with parameters of type Exchange

Modifier and Type	Method and Description
protected void	DataSetSupport.applyHeaders(Exchange exchange, long messageIndex) Allows derived classes to add some custom headers for a given message
static void	DataSetEndpoint.assertEquals(String description, Object expected, Object actual, Exchange exchange)
void	DataSetSupport.assertMessageExpected(DataSetEndpoint dataSetEndpoint, Exchange expected, Exchange actual, long index)
void	DataSet.assertMessageExpected(DataSetEndpoint endpoint, Exchange expected, Exchange actual, long messageIndex) Asserts that the expected message has been received for the given index
protected void	DataSetEndpoint.assertMessageExpected(long index, Exchange expected, Exchange actual)
protected void	DataSetEndpoint.performAssertions(Exchange actual, Exchange copy)
void	DataSetSupport.populateMessage(Exchange exchange, long messageIndex)
void	DataSet.populateMessage(Exchange exchange, long messageIndex) Populates a message exchange when using the DataSet as a source of messages

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

Methods in org.apache.camel.component.direct with parameters of type Exchange

Modifier and Type	Method and Description
protected DirectConsumer	DirectBlockingProducer.getConsumer(Exchange exchange)
void	DirectProducer.process(Exchange exchange)
void	DirectBlockingProducer.process(Exchange exchange)
boolean	DirectProducer.process(Exchange exchange, AsyncCallback callback)
boolean	DirectBlockingProducer.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.component.direct with parameters of type Exchange

Constructor and Description
DirectConsumerNotAvailableException(String message, Exchange exchange)

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

Methods in org.apache.camel.component.directvm that return Exchange

Modifier and Type	Method and Description
protected Exchange	DirectVmProcessor.prepareExchange(Exchange exchange) Strategy to prepare exchange for being processed by this consumer

Methods in org.apache.camel.component.directvm with parameters of type Exchange

Modifier and Type	Method and Description
Object	DirectVmConsumerExpression.evaluate(Exchange exchange)
protected DirectVmConsumer	DirectVmBlockingProducer.getConsumer(Exchange exchange)
protected Exchange	DirectVmProcessor.prepareExchange(Exchange exchange) Strategy to prepare exchange for being processed by this consumer
void	DirectVmProducer.process(Exchange exchange)
void	DirectVmBlockingProducer.process(Exchange exchange)
boolean	DirectVmProducer.process(Exchange exchange, AsyncCallback callback)
boolean	DirectVmProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	DirectVmBlockingProducer.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.component.directvm with parameters of type Exchange

Constructor and Description
DirectVmConsumerNotAvailableException(String message, Exchange exchange)

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

Fields in org.apache.camel.component.file with type parameters of type Exchange

Modifier and Type	Field and Description
protected Comparator<Exchange>	GenericFileEndpoint.sortBy

Methods in org.apache.camel.component.file that return Exchange

Modifier and Type	Method and Description
Exchange	FileEndpoint.createExchange(GenericFile<File> file)
abstract Exchange	GenericFileEndpoint.createExchange(GenericFile<T> file)

Methods in org.apache.camel.component.file that return types with arguments of type Exchange

Modifier and Type	Method and Description
List<Exchange>	GenericFileEndpoint.getExchanges() This implementation will not load the file content.
Comparator<Exchange>	GenericFileEndpoint.getSortBy()
static Comparator<Exchange>	GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse) Returns a new sory by file language expression
static Comparator<Exchange>	GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse, boolean ignoreCase) Returns a new sory by file language expression
static Comparator<Exchange>	GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse, boolean ignoreCase, Comparator<Exchange> nested) Returns a new sort by file language expression

Methods in org.apache.camel.component.file with parameters of type Exchange

Modifier and Type	Method and Description
void	GenericFileProcessStrategy.abort(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file) Called when a begin is aborted, for example to release any resources which may have been acquired during the GenericFileProcessStrategy.begin(GenericFileOperations, GenericFileEndpoint, org.apache.camel.Exchange, GenericFile) operation.
boolean	GenericFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange) Acquires exclusive read lock to the file.
boolean	GenericFileProcessStrategy.begin(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file) Called when work is about to begin on this file.
void	GenericFile.bindToExchange(Exchange exchange) Bind this GenericFile to an Exchange
void	GenericFileProcessStrategy.commit(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file) Releases any file locks and possibly deletes or moves the file after successful processing
void	GenericFileEndpoint.configureExchange(Exchange exchange) Set up the exchange properties with the options of the file endpoint
static Object	GenericFileConverter.convertTo(Class<?> type, Exchange exchange, Object value, TypeConverterRegistry registry)
String	GenericFileProducer.createFileName(Exchange exchange)
String	GenericFileProducer.createTempFileName(Exchange exchange, String fileName)
protected boolean	GenericFileConsumer.customProcessExchange(Exchange exchange, Processor processor) Processes the exchange using a custom processor.
static InputStream	GenericFileConverter.genericFileToInputStream(GenericFile<?> file, Exchange exchange)
static Serializable	GenericFileConverter.genericFileToSerializable(GenericFile<?> file, Exchange exchange)
static String	GenericFileConverter.genericFileToString(GenericFile<?> file, Exchange exchange)
protected void	GenericFileOnCompletion.handleDoneFile(Exchange exchange)
protected void	GenericFileOnCompletion.handleException(String message, Exchange exchange, Throwable t)
void	GenericFileProducer.handleFailedWrite(Exchange exchange, Exception exception) If we fail writing out a file, we will call this method.
protected boolean	GenericFileConsumer.ignoreCannotRetrieveFile(String name, Exchange exchange, Exception cause) Whether to ignore if the file cannot be retrieved.
void	GenericFileDefaultBinding.loadContent(Exchange exchange, GenericFile<?> file)
void	FileBinding.loadContent(Exchange exchange, GenericFile<?> file)
void	GenericFileBinding.loadContent(Exchange exchange, GenericFile<?> file) Ensures the content is loaded from the file into memory
void	GenericFileOnCompletion.onComplete(Exchange exchange)
protected void	GenericFileOnCompletion.onCompletion(Exchange exchange)
void	GenericFileOnCompletion.onFailure(Exchange exchange)
void	GenericFileProducer.process(Exchange exchange)
protected boolean	GenericFileConsumer.processExchange(Exchange exchange) Processes the exchange
protected void	GenericFileProducer.processExchange(Exchange exchange, String target) Perform the work to process the fileExchange
protected void	GenericFileOnCompletion.processStrategyCommit(GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) Strategy when the file was processed and a commit should be executed.
protected void	GenericFileOnCompletion.processStrategyRollback(GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) Strategy when the file was not processed and a rollback should be executed.
void	GenericFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange) Releases the exclusive read lock granted by the acquireExclusiveReadLock method.
void	FileOperations.releaseRetreivedFileResources(Exchange exchange)
void	GenericFileOperations.releaseRetreivedFileResources(Exchange exchange) Releases the resources consumed by a retrieved file
boolean	FileOperations.retrieveFile(String name, Exchange exchange)
boolean	GenericFileOperations.retrieveFile(String name, Exchange exchange) Retrieves the file
void	GenericFileProcessStrategy.rollback(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file) Releases any file locks and possibly deletes or moves the file after unsuccessful processing
boolean	FileOperations.storeFile(String fileName, Exchange exchange)
boolean	GenericFileOperations.storeFile(String name, Exchange exchange) Stores the content as a new remote file (upload)
void	GenericFileProducer.writeFile(Exchange exchange, String fileName)

Method parameters in org.apache.camel.component.file with type arguments of type Exchange

Modifier and Type	Method and Description
protected void	GenericFileConsumer.removeExcessiveInProgressFiles(Deque<Exchange> exchanges, int limit) Drain any in progress files as we are done with this batch
void	GenericFileEndpoint.setSortBy(Comparator<Exchange> sortBy)
static Comparator<Exchange>	GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse, boolean ignoreCase, Comparator<Exchange> nested) Returns a new sort by file language expression

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

Methods in org.apache.camel.component.file.strategy with parameters of type Exchange

Modifier and Type	Method and Description
void	GenericFileProcessStrategySupport.abort(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
boolean	FileLockExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
boolean	FileChangedExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
boolean	MarkerFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
boolean	FileRenameExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
boolean	GenericFileRenameExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange)
boolean	GenericFileRenameProcessStrategy.begin(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
boolean	GenericFileDeleteProcessStrategy.begin(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
boolean	GenericFileProcessStrategySupport.begin(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
void	GenericFileRenameProcessStrategy.commit(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
void	GenericFileDeleteProcessStrategy.commit(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
void	GenericFileProcessStrategySupport.commit(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
protected void	GenericFileProcessStrategySupport.deleteLocalWorkFile(Exchange exchange)
void	FileLockExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
void	MarkerFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
void	FileRenameExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
void	GenericFileRenameExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange)
GenericFile<T>	GenericFileRenamer.renameFile(Exchange exchange, GenericFile<T> file) Renames the given file
GenericFile<T>	GenericFileExpressionRenamer.renameFile(Exchange exchange, GenericFile<T> file)
void	GenericFileRenameProcessStrategy.rollback(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
void	GenericFileDeleteProcessStrategy.rollback(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)
void	GenericFileProcessStrategySupport.rollback(GenericFileOperations<T> operations, GenericFileEndpoint<T> endpoint, Exchange exchange, GenericFile<T> file)

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

Methods in org.apache.camel.component.language with parameters of type Exchange

Modifier and Type	Method and Description
void	LanguageProducer.process(Exchange exchange)

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

Methods in org.apache.camel.component.log with parameters of type Exchange

Modifier and Type	Method and Description
boolean	LogProducer.process(Exchange exchange, AsyncCallback callback)

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

Methods in org.apache.camel.component.mock that return Exchange

Modifier and Type	Method and Description
Exchange	MockEndpoint.assertExchangeReceived(int index) Asserts that the given index of message is received (starting at zero)

Methods in org.apache.camel.component.mock that return types with arguments of type Exchange

Modifier and Type	Method and Description
List<Exchange>	MockEndpoint.getExchanges()
List<Exchange>	MockEndpoint.getReceivedExchanges()

Methods in org.apache.camel.component.mock with parameters of type Exchange

Modifier and Type	Method and Description
protected void	MockEndpoint.addReceivedExchange(Exchange copy) Adds the received exchange.
protected void	AssertionClause.applyAssertionOn(MockEndpoint endpoint, int index, Exchange exchange) Performs any assertions on the given exchange
void	MockEndpoint.handle(Exchange exchange) Handles the incoming exchange.
protected boolean	TimeClause.matches(Exchange exchange, Object leftValue, Object rightValue)
protected void	MockEndpoint.onExchange(Exchange exchange)
protected void	MockEndpoint.performAssertions(Exchange exchange, Exchange copy) Performs the assertions on the incoming exchange.

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

Fields in org.apache.camel.component.seda with type parameters of type Exchange

Modifier and Type	Field and Description
protected Collection<Exchange>	CollectionProducer.queue Deprecated.
protected BlockingQueue<Exchange>	SedaProducer.queue Deprecated. Better make use of the SedaEndpoint.getQueue() API which delivers the accurate reference to the queue currently being used.

Methods in org.apache.camel.component.seda that return Exchange

Modifier and Type	Method and Description
protected Exchange	SedaProducer.prepareCopy(Exchange exchange, boolean handover)
protected Exchange	SedaConsumer.prepareExchange(Exchange exchange) Strategy to prepare exchange for being processed by this consumer
Exchange	SedaPollingConsumer.receive()
Exchange	SedaPollingConsumer.receive(long timeout)
Exchange	SedaPollingConsumer.receiveNoWait()

Methods in org.apache.camel.component.seda that return types with arguments of type Exchange

Modifier and Type	Method and Description
protected BlockingQueue<Exchange>	SedaEndpoint.createQueue()
BlockingQueueFactory<Exchange>	SedaComponent.getDefaultQueueFactory()
List<Exchange>	SedaEndpoint.getExchanges() Returns the current pending exchanges
BlockingQueue<Exchange>	QueueReference.getQueue() Gets the queue
BlockingQueue<Exchange>	SedaEndpoint.getQueue()

Methods in org.apache.camel.component.seda with parameters of type Exchange

Modifier and Type	Method and Description
protected void	SedaProducer.addToQueue(Exchange exchange) Strategy method for adding the exchange to the queue.
protected Exchange	SedaProducer.prepareCopy(Exchange exchange, boolean handover)
protected Exchange	SedaConsumer.prepareExchange(Exchange exchange) Strategy to prepare exchange for being processed by this consumer
boolean	CollectionProducer.process(Exchange exchange, AsyncCallback callback) Deprecated.
boolean	SedaProducer.process(Exchange exchange, AsyncCallback callback)
protected void	SedaConsumer.sendToConsumers(Exchange exchange) Send the given Exchange to the consumer(s).

Method parameters in org.apache.camel.component.seda with type arguments of type Exchange

Modifier and Type	Method and Description
QueueReference	SedaComponent.getOrCreateQueue(SedaEndpoint endpoint, Integer size, Boolean multipleConsumers, BlockingQueueFactory<Exchange> customQueueFactory)
QueueReference	SedaComponent.registerQueue(SedaEndpoint endpoint, BlockingQueue<Exchange> queue)
void	SedaComponent.setDefaultQueueFactory(BlockingQueueFactory<Exchange> defaultQueueFactory)
void	SedaEndpoint.setQueue(BlockingQueue<Exchange> queue)

Constructors in org.apache.camel.component.seda with parameters of type Exchange

Constructor and Description
SedaConsumerNotAvailableException(String message, Exchange exchange)

Constructor parameters in org.apache.camel.component.seda with type arguments of type Exchange

Constructor and Description
CollectionProducer(Endpoint endpoint, Collection<Exchange> queue) Deprecated.
SedaEndpoint(String endpointUri, Component component, BlockingQueue<Exchange> queue)
SedaEndpoint(String endpointUri, Component component, BlockingQueue<Exchange> queue, int concurrentConsumers)
SedaEndpoint(String endpointUri, Component component, BlockingQueueFactory<Exchange> queueFactory, int concurrentConsumers)
SedaProducer(SedaEndpoint endpoint, BlockingQueue<Exchange> queue, WaitForTaskToComplete waitForTaskToComplete, long timeout) Deprecated. Use the other constructor.
SedaProducer(SedaEndpoint endpoint, BlockingQueue<Exchange> queue, WaitForTaskToComplete waitForTaskToComplete, long timeout, boolean blockWhenFull) Deprecated. Use the other constructor.

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

Methods in org.apache.camel.component.test with parameters of type Exchange

Modifier and Type	Method and Description
protected Object	TestEndpoint.getInBody(Exchange exchange) This method allows us to convert or coerce the expected message body into some other type

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

Methods in org.apache.camel.component.xslt with parameters of type Exchange

Modifier and Type	Method and Description
protected void	XsltEndpoint.onExchange(Exchange exchange)

Uses of Exchange in org.apache.camel.converter

Methods in org.apache.camel.converter with parameters of type Exchange

Modifier and Type	Method and Description
static String	IOConverter.getCharsetName(Exchange exchange) Deprecated.
static String	IOConverter.getCharsetName(Exchange exchange, boolean useDefault) Deprecated.
static byte[]	IOConverter.toByteArray(BufferedReader reader, Exchange exchange)
static byte[]	IOConverter.toByteArray(Reader reader, Exchange exchange)
static byte[]	IOConverter.toByteArray(String value, Exchange exchange)
static ByteBuffer	NIOConverter.toByteBuffer(String value, Exchange exchange)
static Class<?>	ObjectConverter.toClass(Object value, Exchange exchange) Returns the converted value, or null if the value is null
static InputStream	IOConverter.toInputStream(BufferedReader buffer, Exchange exchange)
static InputStream	IOConverter.toInputStream(StringBuffer buffer, Exchange exchange)
static InputStream	IOConverter.toInputStream(StringBuilder builder, Exchange exchange)
static InputStream	IOConverter.toInputStream(String text, Exchange exchange)
static ObjectInput	IOConverter.toObjectInput(InputStream stream, Exchange exchange)
static BufferedReader	IOConverter.toReader(File file, Exchange exchange)
static Reader	IOConverter.toReader(InputStream in, Exchange exchange)
static String	IOConverter.toString(byte[] data, Exchange exchange)
static String	IOConverter.toString(ByteArrayOutputStream os, Exchange exchange)
static String	NIOConverter.toString(ByteBuffer buffer, Exchange exchange)
static String	IOConverter.toString(File file, Exchange exchange)
static String	IOConverter.toString(InputStream in, Exchange exchange)
static String	IOConverter.toString(URL url, Exchange exchange)
static BufferedWriter	IOConverter.toWriter(File file, Exchange exchange)
static Writer	IOConverter.toWriter(OutputStream out, Exchange exchange)

Uses of Exchange in org.apache.camel.converter.jaxp

Methods in org.apache.camel.converter.jaxp with parameters of type Exchange

Modifier and Type	Method and Description
XMLEventReader	StaxConverter.createXMLEventReader(File file, Exchange exchange)
XMLEventReader	StaxConverter.createXMLEventReader(InputStream in, Exchange exchange)
XMLEventWriter	StaxConverter.createXMLEventWriter(OutputStream out, Exchange exchange)
XMLStreamReader	StaxConverter.createXMLStreamReader(File file, Exchange exchange)
XMLStreamReader	StaxConverter.createXMLStreamReader(InputStream in, Exchange exchange)
XMLStreamWriter	StaxConverter.createXMLStreamWriter(OutputStream outputStream, Exchange exchange)
DocumentBuilderFactory	XmlConverter.getDocumentBuilderFactory(Exchange exchange)
byte[]	DomConverter.toByteArray(NodeList nodeList, Exchange exchange)
byte[]	XmlConverter.toByteArray(Source source, Exchange exchange) Converts the given input Source into bytes
Document	XmlConverter.toDOMDocument(byte[] data, Exchange exchange) Converts the given data to a DOM document
Document	XmlConverter.toDOMDocument(File file, Exchange exchange) Converts the given File to a DOM document
Document	XmlConverter.toDOMDocument(InputSource in, Exchange exchange) Converts the given InputSource to a DOM document
Document	XmlConverter.toDOMDocument(InputStream in, Exchange exchange) Converts the given InputStream to a DOM document
Document	XmlConverter.toDOMDocument(Reader in, Exchange exchange) Converts the given InputStream to a DOM document
Document	XmlConverter.toDOMDocument(String text, Exchange exchange) Converts the given String to a DOM document
DOMSource	XmlConverter.toDOMSource(File file, Exchange exchange)
DOMSource	XmlConverter.toDOMSource(InputStream is, Exchange exchange)
DOMSource	XmlConverter.toDOMSource(Source source, Exchange exchange) Converts the source instance to a DOMSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
DOMSource	XmlConverter.toDOMSourceFromStream(StreamSource source, Exchange exchange)
InputSource	XmlConverter.toInputSource(File file, Exchange exchange)
InputSource	XmlConverter.toInputSource(InputStream is, Exchange exchange)
InputStream	XmlConverter.toInputStream(Document dom, Exchange exchange)
InputStream	XmlConverter.toInputStream(DOMSource source, Exchange exchange)
InputStream	DomConverter.toInputStream(NodeList nodeList, Exchange exchange)
Reader	XmlConverter.toReaderFromSource(Source src, Exchange exchange)
SAXSource	XmlConverter.toSAXSource(byte[] in, Exchange exchange) Converts the source instance to a SAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource	XmlConverter.toSAXSource(File file, Exchange exchange) Converts the source instance to a SAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource	XmlConverter.toSAXSource(InputStream source, Exchange exchange) Converts the source instance to a SAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource	XmlConverter.toSAXSource(Source source, Exchange exchange) Converts the source instance to a SAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource	XmlConverter.toSAXSource(String source, Exchange exchange) Converts the source instance to a SAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource	XmlConverter.toSAXSourceFromDOM(DOMSource source, Exchange exchange)
SAXSource	XmlConverter.toSAXSourceFromStAX(StAXSource source, Exchange exchange)
SAXSource	XmlConverter.toSAXSourceFromStream(StreamSource source, Exchange exchange)
StAXSource	XmlConverter.toStAXSource(byte[] in, Exchange exchange) Converts the source instance to a StAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
StAXSource	XmlConverter.toStAXSource(File file, Exchange exchange) Converts the source instance to a StAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
StAXSource	XmlConverter.toStAXSource(InputStream source, Exchange exchange) Converts the source instance to a StAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
StAXSource	XmlConverter.toStAXSource(String source, Exchange exchange) Converts the source instance to a StAXSource or returns null if the conversion is not supported (making it easy to derive from this class to add new kinds of conversion).
StreamSource	XmlConverter.toStreamSource(byte[] in, Exchange exchange)
StreamSource	XmlConverter.toStreamSource(ByteBuffer in, Exchange exchange)
StreamSource	XmlConverter.toStreamSource(Source source, Exchange exchange)
StreamSource	XmlConverter.toStreamSourceFromDOM(DOMSource source, Exchange exchange)
StreamSource	XmlConverter.toStreamSourceFromSAX(SAXSource source, Exchange exchange)
StreamSource	XmlConverter.toStreamSourceFromStAX(StAXSource source, Exchange exchange)
String	XmlConverter.toString(Node node, Exchange exchange) Converts the given input Node into text
String	DomConverter.toString(NodeList nodeList, Exchange exchange)
String	XmlConverter.toString(Source source, Exchange exchange) Converts the given input Source into text

Uses of Exchange in org.apache.camel.converter.stream

Methods in org.apache.camel.converter.stream with parameters of type Exchange

Modifier and Type	Method and Description
static byte[]	StreamCacheConverter.convertToByteArray(StreamCache cache, Exchange exchange)
static Serializable	StreamCacheConverter.convertToSerializable(StreamCache cache, Exchange exchange)
static StreamCache	StreamCacheConverter.convertToStreamCache(ByteArrayInputStream stream, Exchange exchange)
static StreamCache	StreamCacheConverter.convertToStreamCache(InputStream stream, Exchange exchange)
static StreamCache	StreamCacheConverter.convertToStreamCache(Reader reader, Exchange exchange)
static StreamCache	StreamCacheConverter.convertToStreamCache(SAXSource source, Exchange exchange)
static StreamCache	StreamCacheConverter.convertToStreamCache(StreamSource source, Exchange exchange)

Constructors in org.apache.camel.converter.stream with parameters of type Exchange

Constructor and Description
CachedOutputStream(Exchange exchange)
CachedOutputStream(Exchange exchange, boolean closedOnCompletion)
StreamSourceCache(StreamSource source, Exchange exchange)

Uses of Exchange in org.apache.camel.impl

Classes in org.apache.camel.impl that implement Exchange

Modifier and Type	Class and Description
class	DefaultExchange A default implementation of Exchange

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

Modifier and Type	Method and Description
Exchange	DefaultExchange.copy()
Exchange	DefaultProducer.createExchange()
Exchange	DefaultEndpoint.createExchange()
Exchange	InterceptSendToEndpoint.createExchange()
Exchange	SynchronousDelegateProducer.createExchange()
Exchange	DefaultProducer.createExchange(Exchange exchange) Deprecated.
Exchange	DefaultEndpoint.createExchange(Exchange exchange)
Exchange	InterceptSendToEndpoint.createExchange(Exchange exchange) Deprecated.
Exchange	SynchronousDelegateProducer.createExchange(Exchange exchange) Deprecated.
Exchange	DefaultProducer.createExchange(ExchangePattern pattern)
Exchange	DefaultEndpoint.createExchange(ExchangePattern pattern)
Exchange	InterceptSendToEndpoint.createExchange(ExchangePattern pattern)
Exchange	SynchronousDelegateProducer.createExchange(ExchangePattern pattern)
Exchange	MessageSupport.getExchange()
Exchange	ProcessorPollingConsumer.receive()
Exchange	EventDrivenPollingConsumer.receive()
Exchange	DefaultConsumerTemplate.receive(Endpoint endpoint)
Exchange	ConsumerCache.receive(Endpoint endpoint)
Exchange	DefaultConsumerTemplate.receive(Endpoint endpoint, long timeout)
Exchange	ConsumerCache.receive(Endpoint endpoint, long timeout)
Exchange	ProcessorPollingConsumer.receive(long timeout)
Exchange	EventDrivenPollingConsumer.receive(long timeout)
Exchange	DefaultConsumerTemplate.receive(String endpointUri)
Exchange	DefaultConsumerTemplate.receive(String endpointUri, long timeout)
Exchange	ProcessorPollingConsumer.receiveNoWait()
Exchange	EventDrivenPollingConsumer.receiveNoWait()
Exchange	DefaultConsumerTemplate.receiveNoWait(Endpoint endpoint)
Exchange	ConsumerCache.receiveNoWait(Endpoint endpoint)
Exchange	DefaultConsumerTemplate.receiveNoWait(String endpointUri)
Exchange	DefaultProducerTemplate.request(Endpoint endpoint, Processor processor)
Exchange	DefaultProducerTemplate.request(String endpoint, Processor processor)
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, Exchange exchange)
Exchange	ProducerCache.send(Endpoint endpoint, ExchangePattern pattern, Processor processor) Sends an exchange to an endpoint using a supplied Processor to populate the exchange
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor)
Exchange	ProducerCache.send(Endpoint endpoint, Processor processor) Sends an exchange to an endpoint using a supplied Processor to populate the exchange
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, Processor processor)
Exchange	DefaultProducerTemplate.send(Exchange exchange)
Exchange	DefaultProducerTemplate.send(Processor processor)
Exchange	DefaultProducerTemplate.send(String endpointUri, Exchange exchange)
Exchange	DefaultProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)
Exchange	DefaultProducerTemplate.send(String endpointUri, Processor processor)
protected Exchange	ProducerCache.sendExchange(Endpoint endpoint, ExchangePattern pattern, Processor processor, Exchange exchange)

Methods in org.apache.camel.impl that return types with arguments of type Exchange

Modifier and Type	Method and Description
Future<Exchange>	DefaultProducerTemplate.asyncCallback(Endpoint endpoint, Exchange exchange, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(Endpoint endpoint, Processor processor, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(String uri, Exchange exchange, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(String uri, Processor processor, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncSend(Endpoint endpoint, Exchange exchange)
Future<Exchange>	DefaultProducerTemplate.asyncSend(Endpoint endpoint, Processor processor)
Future<Exchange>	DefaultProducerTemplate.asyncSend(String uri, Exchange exchange)
Future<Exchange>	DefaultProducerTemplate.asyncSend(String uri, Processor processor)

Methods in org.apache.camel.impl with parameters of type Exchange

Modifier and Type	Method and Description
void	DefaultInflightRepository.add(Exchange exchange)
void	DefaultInflightRepository.add(Exchange exchange, String routeId)
void	BreakpointSupport.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken)
boolean	DefaultDebugger.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken)
void	DefaultUnitOfWork.afterProcess(Processor processor, Exchange exchange, AsyncCallback callback, boolean doneSync)
void	MDCUnitOfWork.afterProcess(Processor processor, Exchange exchange, AsyncCallback callback, boolean doneSync)
void	DefaultUnitOfWork.afterRoute(Exchange exchange, Route route)
boolean	DefaultHeaderFilterStrategy.applyFilterToCamelHeaders(String headerName, Object headerValue, Exchange exchange)
boolean	DefaultHeaderFilterStrategy.applyFilterToExternalHeaders(String headerName, Object headerValue, Exchange exchange)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(Endpoint endpoint, Exchange exchange, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(String uri, Exchange exchange, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncSend(Endpoint endpoint, Exchange exchange)
Future<Exchange>	DefaultProducerTemplate.asyncSend(String uri, Exchange exchange)
void	BreakpointSupport.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition)
boolean	DefaultDebugger.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition)
AsyncCallback	DefaultUnitOfWork.beforeProcess(Processor processor, Exchange exchange, AsyncCallback callback)
AsyncCallback	MDCUnitOfWork.beforeProcess(Processor processor, Exchange exchange, AsyncCallback callback)
void	DefaultUnitOfWork.beforeRoute(Exchange exchange, Route route)
void	DefaultUnitOfWork.beginSubUnitOfWork(Exchange exchange)
StreamCache	DefaultStreamCachingStrategy.cache(Exchange exchange)
UnitOfWork	DefaultUnitOfWork.createChildUnitOfWork(Exchange childExchange)
Exchange	DefaultProducer.createExchange(Exchange exchange) Deprecated.
Exchange	DefaultEndpoint.createExchange(Exchange exchange)
Exchange	InterceptSendToEndpoint.createExchange(Exchange exchange) Deprecated.
Exchange	SynchronousDelegateProducer.createExchange(Exchange exchange) Deprecated.
UnitOfWork	DefaultUnitOfWorkFactory.createUnitOfWork(Exchange exchange)
UnitOfWork	DefaultConsumer.createUoW(Exchange exchange) If the consumer needs to defer done the UnitOfWork on the processed Exchange then this method should be use to create and start the UnitOfWork on the exchange.
boolean	ProducerCache.doInAsyncProducer(Endpoint endpoint, Exchange exchange, ExchangePattern pattern, AsyncCallback callback, AsyncProducerCallback producerCallback) Sends an exchange to an endpoint using a supplied callback supporting the asynchronous routing engine.
<T> T	ProducerCache.doInProducer(Endpoint endpoint, Exchange exchange, ExchangePattern pattern, ProducerCallback<T> callback) Sends an exchange to an endpoint using a supplied callback, using the synchronous processing.
void	DefaultUnitOfWork.done(Exchange exchange)
void	DefaultConsumer.doneUoW(Exchange exchange) If the consumer needs to defer done the UnitOfWork on the processed Exchange then this method should be executed when the consumer is finished processing the message.
void	DefaultConsumerTemplate.doneUoW(Exchange exchange)
void	DefaultUnitOfWork.endSubUnitOfWork(Exchange exchange)
protected boolean	DefaultHeaderFilterStrategy.extendedFilter(HeaderFilterStrategy.Direction direction, String key, Object value, Exchange exchange)
protected Object	DefaultProducerTemplate.extractResultBody(Exchange result)
protected Object	DefaultConsumerTemplate.extractResultBody(Exchange result) Extracts the body from the given result.
protected Object	DefaultProducerTemplate.extractResultBody(Exchange result, ExchangePattern pattern)
String	DefaultRouteNode.getLabel(Exchange exchange)
String	DoFinallyRouteNode.getLabel(Exchange exchange)
String	DoCatchRouteNode.getLabel(Exchange exchange)
String	OnExceptionRouteNode.getLabel(Exchange exchange)
String	OnCompletionRouteNode.getLabel(Exchange exchange)
String	AggregateRouteNode.getLabel(Exchange exchange)
void	BridgeExceptionHandlerToErrorHandler.handleException(String message, Exchange exchange, Throwable exception)
void	LoggingExceptionHandler.handleException(String message, Exchange exchange, Throwable exception)
void	DefaultExchange.handoverCompletions(Exchange target)
void	DefaultUnitOfWork.handoverSynchronization(Exchange target)
static DefaultExchangeHolder	DefaultExchangeHolder.marshal(Exchange exchange) Creates a payload object with the information from the given exchange.
static DefaultExchangeHolder	DefaultExchangeHolder.marshal(Exchange exchange, boolean includeProperties) Creates a payload object with the information from the given exchange.
void	StringDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
void	SerializationDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
void	GzipDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
void	ZipDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
boolean	ConditionSupport.matchEvent(Exchange exchange, EventObject event)
boolean	ConditionSupport.matchProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition)
UnitOfWork	MDCUnitOfWork.newInstance(Exchange exchange)
protected void	DefaultDebugger.onAfterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken, Breakpoint breakpoint)
protected void	DefaultDebugger.onBeforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, Breakpoint breakpoint)
void	DefaultSubUnitOfWork.onDone(Exchange exchange)
boolean	DefaultDebugger.onEvent(Exchange exchange, EventObject event)
protected void	DefaultDebugger.onEvent(Exchange exchange, EventObject event, Breakpoint breakpoint)
void	BreakpointSupport.onEvent(Exchange exchange, EventObject event, ProcessorDefinition<?> definition)
protected void	ProcessorEndpoint.onExchange(Exchange exchange)
void	RoutePolicySupport.onExchangeBegin(Route route, Exchange exchange)
void	RoutePolicySupport.onExchangeDone(Route route, Exchange exchange)
void	ThrottlingInflightRoutePolicy.onExchangeDone(Route route, Exchange exchange)
void	DefaultSubUnitOfWork.onExhausted(Exchange exchange)
void	EventDrivenPollingConsumer.process(Exchange exchange)
void	SynchronousDelegateProducer.process(Exchange exchange)
void	DefaultAsyncProducer.process(Exchange exchange)
void	DefaultInflightRepository.remove(Exchange exchange)
void	DefaultInflightRepository.remove(Exchange exchange, String routeId)
void	ProducerCache.send(Endpoint endpoint, Exchange exchange) Sends the exchange to the given endpoint.
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, Exchange exchange)
Exchange	DefaultProducerTemplate.send(Exchange exchange)
Exchange	DefaultProducerTemplate.send(String endpointUri, Exchange exchange)
protected Exchange	ProducerCache.sendExchange(Endpoint endpoint, ExchangePattern pattern, Processor processor, Exchange exchange)
void	MessageSupport.setExchange(Exchange exchange)
protected void	ThrottlingInflightRoutePolicy.throttle(Route route, Exchange exchange) Throttles the route when Exchanges is done.
static void	DefaultExchangeHolder.unmarshal(Exchange exchange, DefaultExchangeHolder payload) Transfers the information from the payload to the exchange.
Object	StringDataFormat.unmarshal(Exchange exchange, InputStream stream)
Object	SerializationDataFormat.unmarshal(Exchange exchange, InputStream stream)
Object	GzipDataFormat.unmarshal(Exchange exchange, InputStream stream)
Object	ZipDataFormat.unmarshal(Exchange exchange, InputStream stream)

Constructors in org.apache.camel.impl with parameters of type Exchange

Constructor and Description
DefaultExchange(Exchange parent)
DefaultUnitOfWork(Exchange exchange)
DefaultUnitOfWork(Exchange exchange, org.slf4j.Logger logger)
MDCUnitOfWork(Exchange exchange)

Constructor parameters in org.apache.camel.impl with type arguments of type Exchange

Constructor and Description
EventDrivenPollingConsumer(Endpoint endpoint, BlockingQueue<Exchange> queue)

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

Methods in org.apache.camel.impl.converter with parameters of type Exchange

Modifier and Type	Method and Description
<T> T	StaticMethodTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	BaseTypeConverterRegistry.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	FutureTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	AsyncProcessorTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	InstanceMethodTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	EnumTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	InstanceMethodFallbackTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	ToStringTypeConverter.convertTo(Class<T> toType, Exchange exchange, Object value)
<T> T	StaticMethodFallbackTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
<T> T	PropertyEditorTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value) Deprecated.
<T> T	ArrayTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
protected TypeConversionException	BaseTypeConverterRegistry.createTypeConversionException(Exchange exchange, Class<?> type, Object value, Throwable cause)
protected Object	BaseTypeConverterRegistry.doConvertTo(Class<?> type, Exchange exchange, Object value, boolean tryConvert)
protected Object	LazyLoadingTypeConverter.doConvertTo(Class<?> type, Exchange exchange, Object value, boolean tryConvert) Deprecated.
<T> T	BaseTypeConverterRegistry.mandatoryConvertTo(Class<T> type, Exchange exchange, Object value)
<T> T	PropertyEditorTypeConverter.mandatoryConvertTo(Class<T> type, Exchange exchange, Object value) Deprecated.
<T> T	BaseTypeConverterRegistry.tryConvertTo(Class<T> type, Exchange exchange, Object value)
<T> T	PropertyEditorTypeConverter.tryConvertTo(Class<T> type, Exchange exchange, Object value) Deprecated.

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

Methods in org.apache.camel.language.bean that return Exchange

Modifier and Type	Method and Description
Exchange	RuntimeBeanExpressionException.getExchange()

Methods in org.apache.camel.language.bean with parameters of type Exchange

Modifier and Type	Method and Description
Object	BeanExpression.evaluate(Exchange exchange)
<T> T	BeanExpression.evaluate(Exchange exchange, Class<T> type)
boolean	BeanExpression.matches(Exchange exchange)

Constructors in org.apache.camel.language.bean with parameters of type Exchange

Constructor and Description
RuntimeBeanExpressionException(Exchange exchange, String beanName, String method, Throwable e)

Uses of Exchange in org.apache.camel.management

Methods in org.apache.camel.management with parameters of type Exchange

Modifier and Type	Method and Description
void	CompositePerformanceCounter.completedExchange(Exchange exchange, long time)
void	DelegatePerformanceCounter.completedExchange(Exchange exchange, long time)
void	CompositePerformanceCounter.failedExchange(Exchange exchange)
void	DelegatePerformanceCounter.failedExchange(Exchange exchange)
boolean	InstrumentationProcessor.process(Exchange exchange, AsyncCallback callback)
protected void	InstrumentationProcessor.recordTime(Exchange exchange, long duration)

Uses of Exchange in org.apache.camel.management.event

Methods in org.apache.camel.management.event that return Exchange

Modifier and Type	Method and Description
Exchange	AbstractExchangeEvent.getExchange()

Methods in org.apache.camel.management.event with parameters of type Exchange

Modifier and Type	Method and Description
EventObject	DefaultEventFactory.createExchangeCompletedEvent(Exchange exchange)
EventObject	DefaultEventFactory.createExchangeCreatedEvent(Exchange exchange)
EventObject	DefaultEventFactory.createExchangeFailedEvent(Exchange exchange)
EventObject	DefaultEventFactory.createExchangeFailureHandledEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel)
EventObject	DefaultEventFactory.createExchangeRedeliveryEvent(Exchange exchange, int attempt)
EventObject	DefaultEventFactory.createExchangeSendingEvent(Exchange exchange, Endpoint endpoint)
EventObject	DefaultEventFactory.createExchangeSentEvent(Exchange exchange, Endpoint endpoint, long timeTaken)

Constructors in org.apache.camel.management.event with parameters of type Exchange

Constructor and Description
AbstractExchangeEvent(Exchange source)
ExchangeCompletedEvent(Exchange source)
ExchangeCreatedEvent(Exchange source)
ExchangeFailedEvent(Exchange source)
ExchangeFailureHandledEvent(Exchange source, Processor failureHandler, boolean deadLetterChannel)
ExchangeRedeliveryEvent(Exchange source, int attempt)
ExchangeSendingEvent(Exchange source, Endpoint endpoint)
ExchangeSentEvent(Exchange source, Endpoint endpoint, long timeTaken)

Uses of Exchange in org.apache.camel.management.mbean

Methods in org.apache.camel.management.mbean with parameters of type Exchange

Modifier and Type	Method and Description
void	ManagedPerformanceCounter.completedExchange(Exchange exchange, long time)
void	ManagedPerformanceCounter.failedExchange(Exchange exchange)
void	JMXNotificationTraceEventHandler.traceExchange(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
Object	JMXNotificationTraceEventHandler.traceExchangeIn(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
void	JMXNotificationTraceEventHandler.traceExchangeOut(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState)

Uses of Exchange in org.apache.camel.model

Methods in org.apache.camel.model with parameters of type Exchange

Modifier and Type	Method and Description
void	LoadBalancerDefinition.process(Exchange exchange)
boolean	LoadBalancerDefinition.process(Exchange exchange, AsyncCallback callback)

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

Methods in org.apache.camel.model.language with parameters of type Exchange

Modifier and Type	Method and Description
void	ExpressionDefinition.assertMatches(String text, Exchange exchange)
Object	ExpressionDefinition.evaluate(Exchange exchange)
<T> T	ExpressionDefinition.evaluate(Exchange exchange, Class<T> type)
boolean	ExpressionDefinition.matches(Exchange exchange)

Uses of Exchange in org.apache.camel.processor

Methods in org.apache.camel.processor that return Exchange

Modifier and Type	Method and Description
protected Exchange	WireTapProcessor.configureExchange(Exchange exchange, ExchangePattern pattern)
protected Exchange	SendProcessor.configureExchange(Exchange exchange, ExchangePattern pattern)
Exchange	UnitOfWorkProducer.createExchange()
Exchange	UnitOfWorkProducer.createExchange(Exchange exchange) Deprecated.
Exchange	UnitOfWorkProducer.createExchange(ExchangePattern pattern)
static Exchange	PipelineHelper.createNextExchange(Exchange previousExchange) Strategy method to create the next exchange from the previous exchange.
protected Exchange	Pipeline.createNextExchange(Exchange previousExchange) Strategy method to create the next exchange from the previous exchange.
protected Exchange	Enricher.createResourceExchange(Exchange source, ExchangePattern pattern) Creates a new DefaultExchange instance from the given exchange.
protected Exchange	RedeliveryErrorHandler.defensiveCopyExchangeIfNeeded(Exchange exchange) Performs a defensive copy of the exchange if needed
Exchange	ProcessorExchangePair.getExchange()
protected Exchange	OnCompletionProcessor.prepareExchange(Exchange exchange) Prepares the Exchange to send as onCompletion.
protected Exchange	LoopProcessor.prepareExchange(Exchange exchange, int index, Exchange original) Prepares the exchange for the next iteration
protected Exchange	RoutingSlip.prepareExchangeForRoutingSlip(Exchange current, Endpoint endpoint)

Methods in org.apache.camel.processor that return types with arguments of type Exchange

Modifier and Type	Method and Description
protected static Set<Exchange>	Resequencer.createSet(Comparator<? super Exchange> comparator, boolean allowDuplicates, boolean reverse)
protected static Set<Exchange>	Resequencer.createSet(Expression expression, boolean allowDuplicates, boolean reverse)

Methods in org.apache.camel.processor with parameters of type Exchange

Modifier and Type	Method and Description
void	CamelInternalProcessor.MessageHistoryAdvice.after(Exchange exchange, MessageHistory history)
void	CamelInternalProcessor.RouteLifecycleAdvice.after(Exchange exchange, Object object)
void	CamelInternalProcessor.RouteInflightRepositoryAdvice.after(Exchange exchange, Object state)
void	CamelInternalProcessor.RoutePolicyAdvice.after(Exchange exchange, Object data)
void	CamelInternalProcessor.BacklogTracerAdvice.after(Exchange exchange, Object data)
void	CamelInternalProcessor.DelayerAdvice.after(Exchange exchange, Object data)
void	CamelInternalProcessor.InstrumentationAdvice.after(Exchange exchange, StopWatch watch)
void	CamelInternalProcessor.BacklogDebuggerAdvice.after(Exchange exchange, StopWatch stopWatch)
void	CamelInternalProcessor.StreamCachingAdvice.after(Exchange exchange, StreamCache sc)
void	CamelInternalProcessorAdvice.after(Exchange exchange, T data) Callback executed after processing a step in the route.
void	CamelInternalProcessor.RouteContextAdvice.after(Exchange exchange, UnitOfWork unitOfWork)
void	CamelInternalProcessor.UnitOfWorkProcessorAdvice.after(Exchange exchange, UnitOfWork uow)
void	CamelInternalProcessor.SubUnitOfWorkProcessorAdvice.after(Exchange exchange, UnitOfWork unitOfWork)
Object	CamelInternalProcessor.RouteLifecycleAdvice.before(Exchange exchange)
StopWatch	CamelInternalProcessor.InstrumentationAdvice.before(Exchange exchange)
UnitOfWork	CamelInternalProcessor.RouteContextAdvice.before(Exchange exchange)
Object	CamelInternalProcessor.RouteInflightRepositoryAdvice.before(Exchange exchange)
Object	CamelInternalProcessor.RoutePolicyAdvice.before(Exchange exchange)
Object	CamelInternalProcessor.BacklogTracerAdvice.before(Exchange exchange)
StopWatch	CamelInternalProcessor.BacklogDebuggerAdvice.before(Exchange exchange)
UnitOfWork	CamelInternalProcessor.UnitOfWorkProcessorAdvice.before(Exchange exchange)
UnitOfWork	CamelInternalProcessor.SubUnitOfWorkProcessorAdvice.before(Exchange exchange)
MessageHistory	CamelInternalProcessor.MessageHistoryAdvice.before(Exchange exchange)
StreamCache	CamelInternalProcessor.StreamCachingAdvice.before(Exchange exchange)
Object	CamelInternalProcessor.DelayerAdvice.before(Exchange exchange)
T	CamelInternalProcessorAdvice.before(Exchange exchange) Callback executed before processing a step in the route.
protected long	Throttler.calculateDelay(Exchange exchange)
protected abstract long	DelayProcessorSupport.calculateDelay(Exchange exchange)
protected long	Delayer.calculateDelay(Exchange exchange)
protected Throwable	CatchProcessor.catches(Exchange exchange, Throwable exception) Returns with the exception that is caught by this processor.
protected void	SendProcessor.checkException(Exchange exchange)
protected Exchange	WireTapProcessor.configureExchange(Exchange exchange, ExchangePattern pattern)
protected Exchange	SendProcessor.configureExchange(Exchange exchange, ExchangePattern pattern)
protected boolean	CamelInternalProcessor.continueProcessing(Exchange exchange) Strategy to determine if we should continue processing the Exchange.
static boolean	PipelineHelper.continueProcessing(Exchange exchange, String message, org.slf4j.Logger log) Should we continue processing the exchange?
protected boolean	Pipeline.continueRouting(Iterator<Processor> it, Exchange exchange)
protected boolean	TryProcessor.continueRouting(Iterator<Processor> it, Exchange exchange)
protected Processor	MulticastProcessor.createErrorHandler(RouteContext routeContext, Exchange exchange, Processor processor)
Exchange	UnitOfWorkProducer.createExchange(Exchange exchange) Deprecated.
protected String	ThroughputLogger.createLogMessage(Exchange exchange, int receivedCount)
static Exchange	PipelineHelper.createNextExchange(Exchange previousExchange) Strategy method to create the next exchange from the previous exchange.
protected Exchange	Pipeline.createNextExchange(Exchange previousExchange) Strategy method to create the next exchange from the previous exchange.
protected ProcessorExchangePair	RecipientListProcessor.createProcessorExchangePair(int index, Endpoint endpoint, Producer producer, Exchange exchange) This logic is similar to MulticastProcessor but we have to return a RecipientProcessorExchangePair instead
protected ProcessorExchangePair	MulticastProcessor.createProcessorExchangePair(int index, Processor processor, Exchange exchange, RouteContext routeContext) Creates the ProcessorExchangePair which holds the processor and exchange to be send out.
protected Iterable<ProcessorExchangePair>	RecipientListProcessor.createProcessorExchangePairs(Exchange exchange)
protected Iterable<ProcessorExchangePair>	Splitter.createProcessorExchangePairs(Exchange exchange)
protected Iterable<ProcessorExchangePair>	MulticastProcessor.createProcessorExchangePairs(Exchange exchange)
protected Exchange	Enricher.createResourceExchange(Exchange source, ExchangePattern pattern) Creates a new DefaultExchange instance from the given exchange.
protected RoutingSlip.RoutingSlipIterator	DynamicRouter.createRoutingSlipIterator(Exchange exchange)
protected RoutingSlip.RoutingSlipIterator	RoutingSlip.createRoutingSlipIterator(Exchange exchange) Creates the route slip iterator to be used.
protected UnitOfWork	CamelInternalProcessor.UnitOfWorkProcessorAdvice.createUnitOfWork(Exchange exchange)
protected UnitOfWork	CamelInternalProcessor.ChildUnitOfWorkProcessorAdvice.createUnitOfWork(Exchange exchange)
protected Processor	MulticastProcessor.createUnitOfWorkProcessor(RouteContext routeContext, Processor processor, Exchange exchange) Strategy to create the unit of work to be used for the sub route
protected Exchange	RedeliveryErrorHandler.defensiveCopyExchangeIfNeeded(Exchange exchange) Performs a defensive copy of the exchange if needed
protected void	DelayProcessorSupport.delay(long delay, Exchange exchange) Delays the given time before continuing.
protected boolean	RedeliveryErrorHandler.deliverToFailureProcessor(Processor processor, boolean isDeadLetterChannel, Exchange exchange, RedeliveryErrorHandler.RedeliveryData data, AsyncCallback callback) All redelivery attempts failed so move the exchange to the dead letter queue
protected void	RedeliveryErrorHandler.deliverToOnRedeliveryProcessor(Exchange exchange, RedeliveryErrorHandler.RedeliveryData data) Gives an optional configure redelivery processor a chance to process before the Exchange will be redelivered.
protected long	RedeliveryErrorHandler.determineRedeliveryDelay(Exchange exchange, RedeliveryPolicy redeliveryPolicy, long redeliveryDelay, int redeliveryCounter) Determines the redelivery delay time by first inspecting the Message header REDELIVERY_DELAY and if not present, defaulting to RedeliveryPolicy.calculateRedeliveryDelay(long, int)
protected void	MulticastProcessor.doAggregate(AggregationStrategy strategy, AtomicExchange result, Exchange exchange) Aggregate the Exchange with the current result.
protected void	MulticastProcessor.doAggregateInternal(AggregationStrategy strategy, AtomicExchange result, Exchange exchange) Aggregate the Exchange with the current result.
protected void	MulticastProcessor.doDone(Exchange original, Exchange subExchange, Iterable<ProcessorExchangePair> pairs, AsyncCallback callback, boolean doneSync, boolean forceExhaust) Common work which must be done when we are done multicasting.
protected static void	OnCompletionProcessor.doProcess(Processor processor, Exchange exchange) Processes the exchange by the processors
protected void	MulticastProcessor.doProcessParallel(Exchange original, AtomicExchange result, Iterable<ProcessorExchangePair> pairs, boolean streaming, AsyncCallback callback)
protected boolean	MulticastProcessor.doProcessSequential(Exchange original, AtomicExchange result, Iterable<ProcessorExchangePair> pairs, AsyncCallback callback)
boolean	RoutingSlip.doRoutingSlip(Exchange exchange, Object routingSlip, AsyncCallback callback)
String	DefaultExchangeFormatter.format(Exchange exchange)
protected AggregationStrategy	MulticastProcessor.getAggregationStrategy(Exchange exchange)
protected OnExceptionDefinition	ErrorHandlerSupport.getExceptionPolicy(Exchange exchange, Throwable exception) Attempts to find the best suited OnExceptionDefinition to be used for handling the given thrown exception.
protected Integer	Splitter.getExchangeIndex(Exchange exchange)
protected Integer	MulticastProcessor.getExchangeIndex(Exchange exchange)
protected void	RedeliveryErrorHandler.handleException(Exchange exchange, RedeliveryErrorHandler.RedeliveryData data)
protected boolean	CatchProcessor.handles(Exchange exchange) Whether this catch processor handles the exception it have caught
protected void	DelayProcessorSupport.handleSleepInterruptedException(InterruptedException e, Exchange exchange) Called when a sleep is interrupted; allows derived classes to handle this case differently
boolean	RoutingSlip.RoutingSlipIterator.hasNext(Exchange exchange) Are the more routing slip(s)?
protected boolean	RedeliveryErrorHandler.isCancelledOrInterrupted(Exchange exchange) Strategy to determine if the exchange was cancelled or interrupted
protected boolean	RedeliveryErrorHandler.isDone(Exchange exchange) Strategy to determine if the exchange is done so we can continue
protected String	CamelLogger.logMessage(Exchange exchange) Deprecated.
protected String	CamelLogger.logMessage(Exchange exchange, String message) Deprecated.
protected boolean	CatchProcessor.matchesWhen(Exchange exchange) Strategy method for matching the exception type with the current exchange.
Object	RoutingSlip.RoutingSlipIterator.next(Exchange exchange) Returns the next routing slip(s).
protected void	PollEnricher.preCheckPoll(Exchange exchange) Strategy to pre check polling.
protected Exchange	OnCompletionProcessor.prepareExchange(Exchange exchange) Prepares the Exchange to send as onCompletion.
protected Exchange	LoopProcessor.prepareExchange(Exchange exchange, int index, Exchange original) Prepares the exchange for the next iteration
protected void	RedeliveryErrorHandler.prepareExchangeAfterFailure(Exchange exchange, RedeliveryErrorHandler.RedeliveryData data, boolean shouldHandle, boolean shouldContinue)
protected void	RedeliveryErrorHandler.prepareExchangeForContinue(Exchange exchange, RedeliveryErrorHandler.RedeliveryData data)
protected void	RedeliveryErrorHandler.prepareExchangeForRedelivery(Exchange exchange, RedeliveryErrorHandler.RedeliveryData data)
protected Exchange	RoutingSlip.prepareExchangeForRoutingSlip(Exchange current, Endpoint endpoint)
protected void	MulticastProcessor.prepareSharedUnitOfWork(Exchange childExchange, Exchange parentExchange) Prepares the exchange for participating in a shared unit of work This ensures a child exchange can access its parent UnitOfWork when it participate in a shared unit of work.
void	EvaluateExpressionProcessor.process(Exchange exchange)
void	DelegateProcessor.process(Exchange exchange)
void	OnCompletionProcessor.process(Exchange exchange)
void	StreamResequencer.process(Exchange exchange)
void	DelegateAsyncProcessor.process(Exchange exchange)
void	SetBodyProcessor.process(Exchange exchange)
void	ThrowExceptionProcessor.process(Exchange exchange)
void	SortProcessor.process(Exchange exchange)
void	WireTapProcessor.process(Exchange exchange)
void	ThreadsProcessor.process(Exchange exchange)
void	LogProcessor.process(Exchange exchange)
void	StopProcessor.process(Exchange exchange)
void	RecipientList.process(Exchange exchange)
void	CamelLogProcessor.process(Exchange exchange)
void	RedeliveryErrorHandler.process(Exchange exchange)
void	RollbackProcessor.process(Exchange exchange)
void	InterceptorToAsyncProcessorBridge.process(Exchange exchange) Process invoked by the interceptor
void	SendProcessor.process(Exchange exchange)
void	MulticastProcessor.process(Exchange exchange)
void	ThroughputLogger.process(Exchange exchange)
void	UnitOfWorkProducer.process(Exchange exchange)
void	ExchangePatternProcessor.process(Exchange exchange)
void	Enricher.process(Exchange exchange)
void	Pipeline.process(Exchange exchange)
void	UnmarshalProcessor.process(Exchange exchange)
void	DefaultErrorHandler.process(Exchange exchange)
void	DeadLetterChannel.process(Exchange exchange)
void	TransformProcessor.process(Exchange exchange)
void	ConvertBodyProcessor.process(Exchange exchange)
void	MarshalProcessor.process(Exchange exchange)
void	DelegateSyncProcessor.process(Exchange exchange)
void	TryProcessor.process(Exchange exchange)
void	PollEnricher.process(Exchange exchange)
void	BatchProcessor.process(Exchange exchange) Deprecated.
void	RoutingSlip.process(Exchange exchange)
void	CamelLogger.process(Exchange exchange) Deprecated.
void	ChoiceProcessor.process(Exchange exchange)
boolean	EvaluateExpressionProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	OnCompletionProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	StreamResequencer.process(Exchange exchange, AsyncCallback callback)
boolean	DelegateAsyncProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	CatchProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	SetBodyProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	ThrowExceptionProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	SortProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	WireTapProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	FinallyProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	ThreadsProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	LogProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	Splitter.process(Exchange exchange, AsyncCallback callback)
boolean	StopProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	RecipientList.process(Exchange exchange, AsyncCallback callback)
boolean	CamelLogProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	CamelInternalProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	RedeliveryErrorHandler.process(Exchange exchange, AsyncCallback callback) Process the exchange using redelivery error handling.
boolean	RollbackProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	InterceptorToAsyncProcessorBridge.process(Exchange exchange, AsyncCallback callback)
boolean	SendProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	DelayProcessorSupport.process(Exchange exchange, AsyncCallback callback)
boolean	MulticastProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	ThroughputLogger.process(Exchange exchange, AsyncCallback callback)
boolean	FatalFallbackErrorHandler.process(Exchange exchange, AsyncCallback callback)
boolean	SamplingThrottler.process(Exchange exchange, AsyncCallback callback)
boolean	FilterProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	ExchangePatternProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	Enricher.process(Exchange exchange, AsyncCallback callback) Enriches the input data (exchange) by first obtaining additional data from an endpoint represented by an endpoint producer and second by aggregating input data and additional data.
boolean	Pipeline.process(Exchange exchange, AsyncCallback callback)
boolean	UnmarshalProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	TransformProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	ConvertBodyProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	MarshalProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	DelegateSyncProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	LoopProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	TryProcessor.process(Exchange exchange, AsyncCallback callback)
boolean	PollEnricher.process(Exchange exchange, AsyncCallback callback) Enriches the input data (exchange) by first obtaining additional data from an endpoint represented by an endpoint producer and second by aggregating input data and additional data.
boolean	BatchProcessor.process(Exchange exchange, AsyncCallback callback) Deprecated. Enqueues an exchange for later batch processing.
boolean	RoutingSlip.process(Exchange exchange, AsyncCallback callback)
boolean	CamelLogger.process(Exchange exchange, AsyncCallback callback) Deprecated.
boolean	ChoiceProcessor.process(Exchange exchange, AsyncCallback callback)
protected boolean	LoopProcessor.process(Exchange exchange, AsyncCallback callback, AtomicInteger index, AtomicInteger count, Exchange original)
protected boolean	TryProcessor.process(Exchange exchange, AsyncCallback callback, Iterator<Processor> processors, AsyncProcessor processor, Object lastHandled)
void	CamelLogProcessor.process(Exchange exchange, String message)
void	CamelLogger.process(Exchange exchange, String message) Deprecated.
void	CamelLogProcessor.process(Exchange exchange, Throwable exception)
void	CamelLogger.process(Exchange exchange, Throwable exception) Deprecated.
protected void	RedeliveryErrorHandler.processAsyncErrorHandler(Exchange exchange, AsyncCallback callback, RedeliveryErrorHandler.RedeliveryData data) This logic is only executed if we have to retry redelivery asynchronously, which have to be done from the callback.
protected boolean	Throttler.processDelay(Exchange exchange, AsyncCallback callback, long delay)
protected boolean	DelayProcessorSupport.processDelay(Exchange exchange, AsyncCallback callback, long delay)
protected boolean	RoutingSlip.processExchange(Endpoint endpoint, Exchange exchange, Exchange original, AsyncCallback callback, RoutingSlip.RoutingSlipIterator iter)
protected void	BatchProcessor.processExchange(Exchange exchange) Deprecated. Strategy Method to process an exchange in the batch.
protected void	DelegateProcessor.processNext(Exchange exchange)
protected boolean	DelegateAsyncProcessor.processNext(Exchange exchange, AsyncCallback callback) Deprecated. use DelegateAsyncProcessor.process(org.apache.camel.Exchange, org.apache.camel.AsyncCallback) instead
protected void	CamelInternalProcessor.InstrumentationAdvice.recordTime(Exchange exchange, long duration)
protected void	MulticastProcessor.removeAggregationStrategyFromExchange(Exchange exchange) Removes the associated AggregationStrategy from the Exchange which must be done after use.
protected static Endpoint	RecipientListProcessor.resolveEndpoint(Exchange exchange, Object recipient)
protected Endpoint	RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
protected Endpoint	RoutingSlip.resolveEndpoint(RoutingSlip.RoutingSlipIterator iter, Exchange exchange)
void	StreamResequencer.sendElement(Exchange exchange) Sends the exchange to the next processor.
boolean	RecipientList.sendToRecipientList(Exchange exchange, Object recipientList, AsyncCallback callback) Sends the given exchange to the recipient list
protected void	MulticastProcessor.setAggregationStrategyOnExchange(Exchange exchange, AggregationStrategy aggregationStrategy) Sets the given AggregationStrategy on the Exchange.
protected static void	MulticastProcessor.setToEndpoint(Exchange exchange, Processor processor)
protected boolean	RedeliveryErrorHandler.shouldHandleException(Exchange exchange) Strategy whether the exchange has an exception that we should try to handle.
boolean	RedeliveryPolicy.shouldRedeliver(Exchange exchange, int redeliveryCounter, Predicate retryWhile) Returns true if the policy decides that the message exchange should be redelivered.
protected void	Splitter.updateNewExchange(Exchange exchange, int index, Iterable<ProcessorExchangePair> allPairs, Iterator<ProcessorExchangePair> it)
protected void	MulticastProcessor.updateNewExchange(Exchange exchange, int index, Iterable<ProcessorExchangePair> allPairs, Iterator<ProcessorExchangePair> it)

Method parameters in org.apache.camel.processor with type arguments of type Exchange

Modifier and Type	Method and Description
protected static Set<Exchange>	Resequencer.createSet(Comparator<? super Exchange> comparator, boolean allowDuplicates, boolean reverse)

Constructor parameters in org.apache.camel.processor with type arguments of type Exchange

Constructor and Description
BatchProcessor(CamelContext camelContext, Processor processor, Collection<Exchange> collection, Expression expression) Deprecated.
Resequencer(CamelContext camelContext, Processor processor, Set<Exchange> collection, Expression expression)
StreamResequencer(CamelContext camelContext, Processor processor, SequenceElementComparator<Exchange> comparator) Creates a new StreamResequencer instance.

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

Methods in org.apache.camel.processor.aggregate that return Exchange

Modifier and Type	Method and Description
Exchange	MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange exchange)
Exchange	MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
Exchange	UseOriginalAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
Exchange	UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
Exchange	AbstractListAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange) This method will aggregate the old and new exchange and return the result.
Exchange	GroupedExchangeAggregationStrategy.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
Exchange	AggregationStrategyBeanAdapter.aggregate(Exchange oldExchange, Exchange newExchange)
Exchange	MemoryAggregationRepository.get(CamelContext camelContext, String key)
Exchange	GroupedExchangeAggregationStrategy.getValue(Exchange exchange)
protected Exchange	AggregateProcessor.onAggregation(Exchange oldExchange, Exchange newExchange)
protected Exchange	AggregateProcessor.onCompletion(String key, Exchange original, Exchange aggregated, boolean fromTimeout)
protected Exchange	UseLatestAggregationStrategy.propagateFailure(Exchange oldExchange, Exchange newExchange)

Methods in org.apache.camel.processor.aggregate with parameters of type Exchange

Modifier and Type	Method and Description
Exchange	MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange exchange)
Exchange	MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
Exchange	UseOriginalAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
Exchange	UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
Exchange	AbstractListAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange) This method will aggregate the old and new exchange and return the result.
Exchange	GroupedExchangeAggregationStrategy.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
Exchange	AggregationStrategyBeanAdapter.aggregate(Exchange oldExchange, Exchange newExchange)
protected Exception	UseOriginalAggregationStrategy.checkException(Exchange oldExchange, Exchange newExchange)
protected void	AggregateProcessor.doAggregationRepositoryAdd(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
protected void	AggregateProcessor.doProcess(Exchange exchange)
abstract V	AbstractListAggregationStrategy.getValue(Exchange exchange) This method is implemented by the sub-class and is called to retrieve an instance of the value that will be aggregated and forwarded to the receiving end point.
Exchange	GroupedExchangeAggregationStrategy.getValue(Exchange exchange)
Object	AggregationStrategyMethodInfo.invoke(Object pojo, Exchange oldExchange, Exchange newExchange)
protected String	AggregateProcessor.isCompleted(String key, Exchange exchange) Tests whether the given exchange is complete or not
protected Exchange	AggregateProcessor.onAggregation(Exchange oldExchange, Exchange newExchange)
void	AbstractListAggregationStrategy.onCompletion(Exchange exchange)
void	GroupedExchangeAggregationStrategy.onCompletion(Exchange exchange)
void	CompletionAwareAggregationStrategy.onCompletion(Exchange exchange) The aggregated Exchange has completed Important: This method must not throw any exceptions.
protected Exchange	AggregateProcessor.onCompletion(String key, Exchange original, Exchange aggregated, boolean fromTimeout)
void	OptimisticLockingAwareAggregationStrategy.onOptimisticLockFailure(Exchange oldExchange, Exchange newExchange)
protected void	AggregateProcessor.onOptimisticLockingFailure(Exchange oldExchange, Exchange newExchange)
void	AggregateProcessor.process(Exchange exchange)
boolean	AggregateProcessor.process(Exchange exchange, AsyncCallback callback)
protected void	UseLatestAggregationStrategy.propagateException(Exchange oldExchange, Exchange newExchange)
protected Exchange	UseLatestAggregationStrategy.propagateFailure(Exchange oldExchange, Exchange newExchange)
void	MemoryAggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange)
void	TimeoutAwareAggregationStrategy.timeout(Exchange oldExchange, int index, int total, long timeout) A timeout occurred.

Constructors in org.apache.camel.processor.aggregate with parameters of type Exchange

Constructor and Description
ClosedCorrelationKeyException(String correlationKey, Exchange exchange)
ClosedCorrelationKeyException(String correlationKey, Exchange exchange, Throwable cause)
UseOriginalAggregationStrategy(Exchange original, boolean propagateException)

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

Methods in org.apache.camel.processor.binding with parameters of type Exchange

Modifier and Type	Method and Description
void	RestBindingProcessor.process(Exchange exchange)
boolean	RestBindingProcessor.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.processor.binding with parameters of type Exchange

Constructor and Description
BindingException(String message, Exchange exchange)

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

Methods in org.apache.camel.processor.exceptionpolicy with parameters of type Exchange

Modifier and Type	Method and Description
OnExceptionDefinition	ExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicies, Exchange exchange, Throwable exception) Resolves the OnExceptionDefinition that should handle the thrown exception.
OnExceptionDefinition	DefaultExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicies, Exchange exchange, Throwable exception)
protected boolean	DefaultExceptionPolicyStrategy.matchesWhen(OnExceptionDefinition definition, Exchange exchange) Strategy method for matching the exception type with the current exchange.

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

Methods in org.apache.camel.processor.idempotent that return Exchange

Modifier and Type	Method and Description
Exchange	NoMessageIdException.getExchange() The exchange which caused this failure

Methods in org.apache.camel.processor.idempotent with parameters of type Exchange

Modifier and Type	Method and Description
void	IdempotentOnCompletion.onComplete(Exchange exchange)
protected void	IdempotentOnCompletion.onCompletedMessage(Exchange exchange, String messageId) A strategy method to allow derived classes to overload the behavior of processing a completed message
protected void	IdempotentConsumer.onDuplicateMessage(Exchange exchange, String messageId) A strategy method to allow derived classes to overload the behaviour of processing a duplicate message
protected void	IdempotentOnCompletion.onFailedMessage(Exchange exchange, String messageId) A strategy method to allow derived classes to overload the behavior of processing a failed message
void	IdempotentOnCompletion.onFailure(Exchange exchange)
void	IdempotentConsumer.process(Exchange exchange)
boolean	IdempotentConsumer.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.processor.idempotent with parameters of type Exchange

Constructor and Description
NoMessageIdException(Exchange exchange, Expression expression)

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

Methods in org.apache.camel.processor.interceptor that return Exchange

Modifier and Type	Method and Description
Exchange	DefaultTraceEventMessage.getTracedExchange()
Exchange	TraceEventMessage.getTracedExchange() Gets the traced Exchange.

Methods in org.apache.camel.processor.interceptor with parameters of type Exchange

Modifier and Type	Method and Description
boolean	BacklogDebugger.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken)
boolean	BacklogDebugger.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition)
long	DelayInterceptor.calculateDelay(Exchange exchange) Deprecated.
protected String	DefaultTraceFormatter.extractBreadCrumb(TraceInterceptor interceptor, ProcessorDefinition<?> currentNode, Exchange exchange) Creates the breadcrumb based on whether this was a trace of an exchange coming out of or into a processing step.
String	TraceInterceptor.format(Exchange exchange)
Object	DefaultTraceFormatter.format(TraceInterceptor interceptor, ProcessorDefinition<?> node, Exchange exchange)
Object	TraceFormatter.format(TraceInterceptor interceptor, ProcessorDefinition<?> node, Exchange exchange) Formats a log message at given point of interception.
protected Object	DefaultTraceFormatter.getBreadCrumbID(Exchange exchange)
protected String	DefaultTraceFormatter.getNodeMessage(RouteNode entry, Exchange exchange)
protected void	HandleFaultInterceptor.handleFault(Exchange exchange) Handles the fault message by converting it to an Exception
protected void	TraceInterceptor.logException(Exchange exchange, Throwable throwable)
protected void	TraceInterceptor.logExchange(Exchange exchange)
boolean	TraceInterceptor.process(Exchange exchange, AsyncCallback callback)
boolean	HandleFaultInterceptor.process(Exchange exchange, AsyncCallback callback)
boolean	StreamCachingInterceptor.process(Exchange exchange, AsyncCallback callback) Deprecated.
protected boolean	TraceInterceptor.shouldLogException(Exchange exchange) Returns true if the given exchange should be logged when an exception was thrown
protected boolean	TraceInterceptor.shouldLogExchange(Exchange exchange) Returns true if the given exchange should be logged in the trace list
boolean	BacklogTracer.shouldTrace(ProcessorDefinition<?> definition, Exchange exchange) Whether or not to trace the given processor definition.
protected void	TraceInterceptor.traceExchange(Exchange exchange)
void	DefaultTraceEventHandler.traceExchange(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
void	TraceEventHandler.traceExchange(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange) Event called when an Exchange is about to be processed This event is only called if trace out has been disabled (which it is by default).
protected Object	TraceInterceptor.traceExchangeIn(Exchange exchange)
Object	DefaultTraceEventHandler.traceExchangeIn(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
Object	TraceEventHandler.traceExchangeIn(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange) Event called when an Exchange is about to be processed (in) This event is only called if trace out has been enabled.
protected void	TraceInterceptor.traceExchangeOut(Exchange exchange, Object traceState)
void	DefaultTraceEventHandler.traceExchangeOut(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState)
void	TraceEventHandler.traceExchangeOut(ProcessorDefinition<?> node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState) Event called when an Exchange has been processed (out) This event is only called if trace out has been enabled.
protected void	TraceInterceptor.traceIntercept(InterceptDefinition intercept, TracedRouteNodes traced, Exchange exchange)

Constructors in org.apache.camel.processor.interceptor with parameters of type Exchange

Constructor and Description
DefaultTraceEventMessage(Date timestamp, ProcessorDefinition<?> toNode, Exchange exchange) Creates a DefaultTraceEventMessage based on the given node it was traced while processing the current Exchange

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

Methods in org.apache.camel.processor.loadbalancer that return Exchange

Modifier and Type	Method and Description
protected Exchange	TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange) Strategy method to copy the exchange before sending to another endpoint.
protected Exchange	FailOverLoadBalancer.prepareExchangeForFailover(Exchange exchange) Prepares the exchange for failover

Methods in org.apache.camel.processor.loadbalancer with parameters of type Exchange

Modifier and Type	Method and Description
protected Processor	WeightedRoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected abstract Processor	QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	WeightedRandomLoadBalancer.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.
protected boolean	CircuitBreakerLoadBalancer.hasFailed(Exchange exchange)
protected Exchange	FailOverLoadBalancer.prepareExchangeForFailover(Exchange exchange) Prepares the exchange for failover
void	LoadBalancerSupport.process(Exchange exchange)
abstract void	SimpleLoadBalancerSupport.process(Exchange exchange)
boolean	CircuitBreakerLoadBalancer.process(Exchange exchange, AsyncCallback callback)
boolean	QueueLoadBalancer.process(Exchange exchange, AsyncCallback callback)
boolean	FailOverLoadBalancer.process(Exchange exchange, AsyncCallback callback)
boolean	SimpleLoadBalancerSupport.process(Exchange exchange, AsyncCallback callback)
boolean	TopicLoadBalancer.process(Exchange exchange, AsyncCallback callback)
protected boolean	FailOverLoadBalancer.shouldFailOver(Exchange exchange) Should the given failed Exchange failover?

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

Methods in org.apache.camel.processor.resequencer with parameters of type Exchange

Modifier and Type	Method and Description
int	DefaultExchangeComparator.compare(Exchange o1, Exchange o2)
boolean	DefaultExchangeComparator.isValid(Exchange exchange)
boolean	DefaultExchangeComparator.predecessor(Exchange o1, Exchange o2)
boolean	DefaultExchangeComparator.successor(Exchange o1, Exchange o2)

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

Methods in org.apache.camel.processor.validation with parameters of type Exchange

Modifier and Type	Method and Description
protected static String	PredicateValidationException.buildMessage(Predicate predicate, Exchange exchange)
protected void	ValidatingProcessor.doProcess(Exchange exchange)
protected Source	ValidatingProcessor.getSource(Exchange exchange, Object content) Converts the inbound body or header to a Source, if it is not already a Source.
void	DefaultValidationErrorHandler.handleErrors(Exchange exchange, Object schema)
void	ValidatorErrorHandler.handleErrors(Exchange exchange, Schema schema, Result result) Process any errors which may have occurred during validation
void	DefaultValidationErrorHandler.handleErrors(Exchange exchange, Schema schema, Result result)
protected boolean	ValidatingProcessor.isInputStreamNeeded(Exchange exchange) Checks whether we need an InputStream to access the message body or header.
void	PredicateValidatingProcessor.process(Exchange exchange)
void	ValidatingProcessor.process(Exchange exchange)
boolean	ValidatingProcessor.process(Exchange exchange, AsyncCallback callback)

Constructors in org.apache.camel.processor.validation with parameters of type Exchange

Constructor and Description
NoXmlBodyValidationException(Exchange exchange)
NoXmlBodyValidationException(Exchange exchange, Throwable cause)
NoXmlHeaderValidationException(Exchange exchange, String header)
NoXmlHeaderValidationException(Exchange exchange, String header, Throwable cause)
PredicateValidationException(Exchange exchange, Predicate predicate)
SchemaValidationException(Exchange exchange, Object schema, List<SAXParseException> fatalErrors, List<SAXParseException> errors, List<SAXParseException> warnings)

Uses of Exchange in org.apache.camel.spi

Methods in org.apache.camel.spi that return Exchange

Modifier and Type	Method and Description
Exchange	AggregationRepository.add(CamelContext camelContext, String key, Exchange exchange) Add the given Exchange under the correlation key.
Exchange	OptimisticLockingAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange) Add the given Exchange under the correlation key.
Exchange	AggregationRepository.get(CamelContext camelContext, String key) Gets the given exchange with the correlation key This method is always invoked for any incoming exchange in the aggregator.
Exchange	RecoverableAggregationRepository.recover(CamelContext camelContext, String exchangeId) Recovers the exchange with the given exchange id

Methods in org.apache.camel.spi that return types with arguments of type Exchange

Modifier and Type	Method and Description
List<Exchange>	BrowsableEndpoint.getExchanges() Return the exchanges available on this endpoint

Methods in org.apache.camel.spi with parameters of type Exchange

Modifier and Type	Method and Description
Exchange	AggregationRepository.add(CamelContext camelContext, String key, Exchange exchange) Add the given Exchange under the correlation key.
Exchange	OptimisticLockingAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange) Add the given Exchange under the correlation key.
void	InflightRepository.add(Exchange exchange) Adds the exchange to the inflight registry to the total counter
boolean	ExchangeIdempotentRepository.add(Exchange exchange, E key) Adds the key to the repository.
void	InflightRepository.add(Exchange exchange, String routeId) Adds the exchange to the inflight registry associated to the given route
void	Breakpoint.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken) Callback invoked when the breakpoint was hit and the Exchange has been processed (after).
boolean	Debugger.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition, long timeTaken) Callback invoked when an Exchange has been processed which allows implementators to notify breakpoints.
void	UnitOfWork.afterProcess(Processor processor, Exchange exchange, AsyncCallback callback, boolean doneSync) Strategy for optional work to be executed after the processing
void	UnitOfWork.afterRoute(Exchange exchange, Route route) Invoked when this unit of work is done being routed by the given route.
boolean	HeaderFilterStrategy.applyFilterToCamelHeaders(String headerName, Object headerValue, Exchange exchange) Applies filtering logic to Camel Message header that is going to be copied to target message such as CXF and JMS message.
boolean	HeaderFilterStrategy.applyFilterToExternalHeaders(String headerName, Object headerValue, Exchange exchange) Applies filtering logic to an external message header such as CXF and JMS message that is going to be copied to Camel message header.
void	Breakpoint.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) Callback invoked when the breakpoint was hit and the Exchange is about to be processed (before).
boolean	Debugger.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) Callback invoked when an Exchange is about to be processed which allows implementators to notify breakpoints.
AsyncCallback	UnitOfWork.beforeProcess(Processor processor, Exchange exchange, AsyncCallback callback) Strategy for optional work to be execute before processing For example the MDCUnitOfWork leverages this to ensure MDC is handled correctly during routing exchanges using the asynchronous routing engine.
void	UnitOfWork.beforeRoute(Exchange exchange, Route route) Invoked when this unit of work is about to be routed by the given route.
void	UnitOfWork.beginSubUnitOfWork(Exchange exchange) Begins a SubUnitOfWork, where sub (child) unit of works participate in a parent unit of work.
StreamCache	StreamCachingStrategy.cache(Exchange exchange) Caches the body aas a StreamCache.
boolean	ExchangeIdempotentRepository.confirm(Exchange exchange, E key) Confirms the key, after the exchange has been processed successfully.
boolean	ExchangeIdempotentRepository.contains(Exchange exchange, E key) Returns true if this repository contains the specified element.
UnitOfWork	UnitOfWork.createChildUnitOfWork(Exchange childExchange) Create a child unit of work, which is associated to this unit of work as its parent.
EventObject	EventFactory.createExchangeCompletedEvent(Exchange exchange) Creates an EventObject when an Exchange has been completed successfully
EventObject	EventFactory.createExchangeCreatedEvent(Exchange exchange) Creates an EventObject when an Exchange has been created
EventObject	EventFactory.createExchangeFailedEvent(Exchange exchange) Creates an EventObject when an Exchange has failed
EventObject	EventFactory.createExchangeFailureHandledEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel) Creates an EventObject when an Exchange has failed but was handled by the Camel error handlers such as an dead letter channel.
EventObject	EventFactory.createExchangeRedeliveryEvent(Exchange exchange, int attempt) Creates an EventObject when an Exchange is about to be redelivered
EventObject	EventFactory.createExchangeSendingEvent(Exchange exchange, Endpoint endpoint) Creates an EventObject when an Exchange is about to be sent to the endpoint (eg before).
EventObject	EventFactory.createExchangeSentEvent(Exchange exchange, Endpoint endpoint, long timeTaken) Creates an EventObject when an Exchange has completely been sent to the endpoint (eg after).
UnitOfWork	UnitOfWorkFactory.createUnitOfWork(Exchange exchange) Creates a new UnitOfWork
void	UnitOfWork.done(Exchange exchange) Invoked when this unit of work has been completed, whether it has failed or completed
void	UnitOfWork.endSubUnitOfWork(Exchange exchange) Ends a SubUnitOfWork.
String	ExchangeFormatter.format(Exchange exchange) Generates a string representation of the exchange
void	ExceptionHandler.handleException(String message, Exchange exchange, Throwable exception) Handles the given exception
void	UnitOfWork.handoverSynchronization(Exchange target) /** Handover all the registered synchronizations to the target Exchange.
void	DataFormat.marshal(Exchange exchange, Object graph, OutputStream stream) Marshals the object to the given Stream.
boolean	Condition.matchEvent(Exchange exchange, EventObject event) Does the condition match
boolean	Condition.matchProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) Does the condition match
void	SynchronizationRouteAware.onAfterRoute(Route route, Exchange exchange) Invoked after the Exchange has been routed by the given route.
void	SynchronizationRouteAware.onBeforeRoute(Route route, Exchange exchange) Invoked before the Exchange is being routed by the given route.
void	Synchronization.onComplete(Exchange exchange) Called when the processing of the message exchange is complete
void	SubUnitOfWorkCallback.onDone(Exchange exchange) The exchange is done.
boolean	Debugger.onEvent(Exchange exchange, EventObject event) Callback invoked when an Exchange is being processed which allows implementators to notify breakpoints.
void	Breakpoint.onEvent(Exchange exchange, EventObject event, ProcessorDefinition<?> definition) Callback invoked when the breakpoint was hit and any of the Exchange events occurred.
void	RoutePolicy.onExchangeBegin(Route route, Exchange exchange) Callback invoked when an Exchange is started being routed on the given Route
void	RoutePolicy.onExchangeDone(Route route, Exchange exchange) Callback invoked when an Exchange is done being routed, where it started from the given Route Notice this callback is invoked when the Exchange is done and the Route is the route where the Exchange was started.
void	SubUnitOfWorkCallback.onExhausted(Exchange exchange) The exchange is exhausted, by a redeliverable error handler.
void	Synchronization.onFailure(Exchange exchange) Called when the processing of the message exchange has failed for some reason.
void	AggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange) Removes the exchange with the given correlation key, which should happen when an Exchange is completed Important: This method is not invoked if only one exchange was completed, and therefore the exchange does not need to be added to a repository, as its completed immediately.
void	OptimisticLockingAggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange) Removes the given Exchange when both the supplied key and Exchange are present in the repository.
void	InflightRepository.remove(Exchange exchange) Removes the exchange from the inflight registry to the total counter
boolean	ExchangeIdempotentRepository.remove(Exchange exchange, E key) Removes the key from the repository.
void	InflightRepository.remove(Exchange exchange, String routeId) Removes the exchange from the inflight registry removing association to the given route
Object	DataFormat.unmarshal(Exchange exchange, InputStream stream) Unmarshals the given stream into an object.

Uses of Exchange in org.apache.camel.support

Methods in org.apache.camel.support with parameters of type Exchange

Modifier and Type	Method and Description
protected abstract String	ExpressionSupport.assertionFailureMessage(Exchange exchange)
protected String	ExpressionAdapter.assertionFailureMessage(Exchange exchange)
void	ExpressionSupport.assertMatches(String text, Exchange exchange)
protected Object	XMLTokenExpressionIterator.doEvaluate(Exchange exchange, boolean closeStream) Strategy to evaluate the exchange
protected Object	TokenPairExpressionIterator.doEvaluate(Exchange exchange, boolean closeStream) Strategy to evaluate the exchange
protected Object	TokenXMLExpressionIterator.doEvaluate(Exchange exchange, boolean closeStream) Strategy to evaluate the exchange
Object	ExpressionSupport.evaluate(Exchange exchange)
Object	XMLTokenExpressionIterator.evaluate(Exchange exchange)
Object	TokenPairExpressionIterator.evaluate(Exchange exchange)
Object	TokenXMLExpressionIterator.evaluate(Exchange exchange)
<T> T	ExpressionAdapter.evaluate(Exchange exchange, Class<T> type)
<T> T	TypeConverterSupport.mandatoryConvertTo(Class<T> type, Exchange exchange, Object value)
boolean	ExpressionSupport.matches(Exchange exchange)
boolean	XMLTokenExpressionIterator.matches(Exchange exchange)
boolean	TokenPairExpressionIterator.matches(Exchange exchange)
boolean	TokenXMLExpressionIterator.matches(Exchange exchange)
void	SynchronizationAdapter.onAfterRoute(Route route, Exchange exchange)
void	SynchronizationAdapter.onBeforeRoute(Route route, Exchange exchange)
void	SynchronizationAdapter.onComplete(Exchange exchange)
void	SynchronizationAdapter.onDone(Exchange exchange)
void	SynchronizationAdapter.onFailure(Exchange exchange)
<T> T	TypeConverterSupport.tryConvertTo(Class<T> type, Exchange exchange, Object value)

Uses of Exchange in org.apache.camel.util

Methods in org.apache.camel.util that return Exchange

Modifier and Type	Method and Description
static Exchange	ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context) Copies the exchange but the copy will be tied to the given context
static Exchange	ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context, boolean handover) Copies the exchange but the copy will be tied to the given context
static Exchange	ExchangeHelper.createCopy(Exchange exchange, boolean preserveExchangeId) Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance.
static Exchange	ExchangeHelper.createCorrelatedCopy(Exchange exchange, boolean handover) Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance.
static Exchange	ExchangeHelper.getExchangeById(Iterable<Exchange> exchanges, String exchangeId) Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found

Methods in org.apache.camel.util with parameters of type Exchange

Modifier and Type	Method and Description
static void	UnitOfWorkHelper.afterRouteSynchronizations(Route route, Exchange exchange, List<Synchronization> synchronizations, org.slf4j.Logger log)
static void	PredicateAssertHelper.assertMatches(Predicate predicate, String text, Exchange exchange)
static void	UnitOfWorkHelper.beforeRouteSynchronizations(Route route, Exchange exchange, List<Synchronization> synchronizations, org.slf4j.Logger log)
int	ExpressionComparator.compare(Exchange e1, Exchange e2)
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
static Exchange	ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context) Copies the exchange but the copy will be tied to the given context
static Exchange	ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context, boolean handover) Copies the exchange but the copy will be tied to the given context
static void	ExchangeHelper.copyResults(Exchange result, Exchange source) Copies the results of a message exchange from the source exchange to the result exchange which will copy the message contents, exchange properties and the exception.
static void	ExchangeHelper.copyResultsPreservePattern(Exchange result, Exchange source) Copies the source exchange to target exchange preserving the ExchangePattern of target.
static Exchange	ExchangeHelper.createCopy(Exchange exchange, boolean preserveExchangeId) Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance.
static Exchange	ExchangeHelper.createCorrelatedCopy(Exchange exchange, boolean handover) Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance.
static String	ExchangeHelper.createExceptionMessage(String message, Exchange exchange, Throwable cause) Deprecated. use org.apache.camel.CamelExchangeException.createExceptionMessage instead
static UnitOfWork	UnitOfWorkHelper.createUoW(Exchange exchange) Deprecated. use CamelContext.getUnitOfWorkFactory() instead.
static Map<String,Object>	ExchangeHelper.createVariableMap(Exchange exchange) Creates a Map of the variables which are made available to a script or template
static String	MessageHelper.doDumpMessageHistoryStacktrace(Exchange exchange, ExchangeFormatter exchangeFormatter, boolean logStackTrace)
static void	UnitOfWorkHelper.doneSynchronizations(Exchange exchange, List<Synchronization> synchronizations, org.slf4j.Logger log)
static void	UnitOfWorkHelper.doneUow(UnitOfWork uow, Exchange exchange) Done and stop the UnitOfWork.
static String	MessageHelper.dumpMessageHistoryStacktrace(Exchange exchange, ExchangeFormatter exchangeFormatter, boolean logStackTrace) Dumps the MessageHistory from the Exchange in a human readable format.
<T> T	PredicateToExpressionAdapter.evaluate(Exchange exchange, Class<T> type)
static Object	ExchangeHelper.extractResultBody(Exchange exchange, ExchangePattern pattern) Extracts the body from the given exchange.
static <T> T	ExchangeHelper.getBinding(Exchange exchange, Class<T> type) Extracts the Exchange.BINDING of the given type or null if not present
static String	IOHelper.getCharsetName(Exchange exchange)
static String	IOHelper.getCharsetName(Exchange exchange, boolean useDefault) Gets the charset name if set as header or property CHARSET_NAME.
static String	ExchangeHelper.getContentEncoding(Exchange exchange) Returns the MIME content encoding on the input message or null if one is not defined
static String	ExchangeHelper.getContentType(Exchange exchange) Returns the MIME content type on the input message or null if one is not defined
static <T> T	ExchangeHelper.getMandatoryHeader(Exchange exchange, String headerName, Class<T> type) Gets the mandatory inbound header of the correct type
static Object	ExchangeHelper.getMandatoryInBody(Exchange exchange) Deprecated. use Message.getMandatoryBody()
static <T> T	ExchangeHelper.getMandatoryInBody(Exchange exchange, Class<T> type) Deprecated. use Message.getMandatoryBody(Class)
static Object	ExchangeHelper.getMandatoryOutBody(Exchange exchange) Deprecated. use Message.getMandatoryBody()
static <T> T	ExchangeHelper.getMandatoryOutBody(Exchange exchange, Class<T> type) Deprecated. use Message.getMandatoryBody(Class)
static <T> T	ExchangeHelper.getMandatoryProperty(Exchange exchange, String propertyName, Class<T> type) Gets the mandatory property of the exchange of the correct type
static Message	ExchangeHelper.getResultMessage(Exchange exchange) Returns the message where to write results in an exchange-pattern-sensitive way.
static Scanner	ObjectHelper.getScanner(Exchange exchange, Object value) Creates a Scanner for scanning the given value.
static boolean	ExchangeHelper.hasExceptionBeenHandledByErrorHandler(Exchange exchange) Tests whether the exchange has already been handled by the error handler
static boolean	ExchangeHelper.hasFaultMessage(Exchange exchange) Tests whether the exchange has a fault message set and that its not null.
static boolean	ExchangeHelper.isFailureHandled(Exchange exchange) Checks whether the exchange has been failure handed
static boolean	GZIPHelper.isGzip(String header, Exchange exchange)
static boolean	ExchangeHelper.isInterrupted(Exchange exchange) Checks whether the exchange UnitOfWork has been interrupted during processing
static boolean	ExchangeHelper.isOutCapable(Exchange exchange) Returns true if the given exchange pattern (if defined) can support OUT messages
static boolean	ExchangeHelper.isRedelivered(Exchange exchange) Checks whether the exchange UnitOfWork is redelivered
static boolean	ExchangeHelper.isRedeliveryExhausted(Exchange exchange) Checks whether the exchange is redelivery exhausted
static boolean	ExchangeHelper.isUnitOfWorkExhausted(Exchange exchange) Checks whether the exchange UnitOfWork is exhausted
static String	ExchangeHelper.logIds(Exchange exchange) Gets both the messageId and exchangeId to be used for logging purposes.
static Object	ExchangeHelper.lookupBean(Exchange exchange, String name) Performs a lookup in the registry of the bean name
static <T> T	ExchangeHelper.lookupBean(Exchange exchange, String name, Class<T> type) Performs a lookup in the registry of the bean name and type
static Object	ExchangeHelper.lookupMandatoryBean(Exchange exchange, String name) Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found
static <T> T	ExchangeHelper.lookupMandatoryBean(Exchange exchange, String name, Class<T> type) Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found
boolean	ExpressionToPredicateAdapter.matches(Exchange exchange)
static <T> T	ExchangeHelper.newInstance(Exchange exchange, Class<T> type) Creates a new instance of the given type from the injector
static void	EventHelper.notifyExchangeCreated(CamelContext context, Exchange exchange)
static void	EventHelper.notifyExchangeDone(CamelContext context, Exchange exchange)
static void	EventHelper.notifyExchangeFailed(CamelContext context, Exchange exchange)
static void	EventHelper.notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler, boolean deadLetterChannel)
static void	EventHelper.notifyExchangeRedelivery(CamelContext context, Exchange exchange, int attempt)
static void	EventHelper.notifyExchangeSending(CamelContext context, Exchange exchange, Endpoint endpoint)
static void	EventHelper.notifyExchangeSent(CamelContext context, Exchange exchange, Endpoint endpoint, long timeTaken)
static void	ExchangeHelper.populateVariableMap(Exchange exchange, Map<String,Object> map) Populates the Map with the variables which are made available to a script or template
static void	ExchangeHelper.prepareAggregation(Exchange oldExchange, Exchange newExchange) Prepares the exchanges for aggregation.
static void	ExchangeHelper.prepareOutToIn(Exchange exchange) Strategy to prepare results before next iterator or when we are complete, which is done by copying OUT to IN, so there is only an IN as input for the next iteration.
static void	AsyncProcessorHelper.process(AsyncProcessor processor, Exchange exchange) Calls the async version of the processor's process method and waits for it to complete before returning.
static boolean	AsyncProcessorHelper.process(AsyncProcessor processor, Exchange exchange, AsyncCallback callback) Deprecated. should no longer be needed, instead invoke the process method on the AsyncProcessor directly, instead of using this method.
static void	ExchangeHelper.replaceMessage(Exchange exchange, Message newMessage, boolean outOnly) Replaces the existing message with the new message
static Endpoint	ExchangeHelper.resolveEndpoint(Exchange exchange, Object value) Attempts to resolve the endpoint for the given value
static void	ExchangeHelper.setFailureHandled(Exchange exchange) Sets the exchange to be failure handled.
static CamelExecutionException	ObjectHelper.wrapCamelExecutionException(Exchange exchange, Throwable e) Wraps the caused exception in a CamelExecutionException if its not already such an exception.

Method parameters in org.apache.camel.util with type arguments of type Exchange

Modifier and Type	Method and Description
static Exchange	ExchangeHelper.getExchangeById(Iterable<Exchange> exchanges, String exchangeId) Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found

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

Methods in org.apache.camel.util.component with parameters of type Exchange

Modifier and Type	Method and Description
protected ApiMethod	AbstractApiProducer.findMethod(Exchange exchange, Map<String,Object> properties)
Map<String,Object>	ApiMethodPropertiesHelper.getExchangeProperties(Exchange exchange, Map<String,Object> properties) Gets exchange header properties that start with propertyPrefix.
void	ResultInterceptor.interceptResult(Object result, Exchange resultExchange) Do additional result exchange processing, for example, adding custom headers.
void	AbstractApiProducer.interceptResult(Object methodResult, Exchange resultExchange)
void	AbstractApiConsumer.interceptResult(Object result, Exchange resultExchange)
boolean	AbstractApiProducer.process(Exchange exchange, AsyncCallback callback)

Uses of Exchange in org.apache.camel.util.toolbox

Methods in org.apache.camel.util.toolbox that return Exchange

Modifier and Type	Method and Description
Exchange	FlexibleAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)

Methods in org.apache.camel.util.toolbox with parameters of type Exchange

Modifier and Type	Method and Description
Exchange	FlexibleAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
void	FlexibleAggregationStrategy.onCompletion(Exchange exchange)
void	FlexibleAggregationStrategy.CompletionAwareMixin.onCompletion(Exchange exchange)
void	FlexibleAggregationStrategy.timeout(Exchange oldExchange, int index, int total, long timeout)
void	FlexibleAggregationStrategy.TimeoutAwareMixin.timeout(Exchange exchange, int index, int total, long timeout)