Uses of Interface
org.apache.camel.Exchange

Packages that use Exchange
org.apache.camel The JAXB POJOs for the XML Configuration of the routing rules. 
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.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.dataset A DataSet Endpoint for testing of endpoints using defined DataSets 
org.apache.camel.component.direct The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint. 
org.apache.camel.component.file The File Component for working with file systems. 
org.apache.camel.component.file.strategy Strategies for the File Component. 
org.apache.camel.component.jmx The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. 
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.vm The VM Component for asynchronous SEDA exchanges on a BlockingQueue within the current JVM; so across CamelContext instances. 
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 JMX export services. 
org.apache.camel.model.language The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration
org.apache.camel.model.loadbalancer The LoadBalancer and the LoadBalancerStrategy JAXB Objects 
org.apache.camel.processor A collection of Processor implementations which are used to implement the Enterprise Integration Patterns 
org.apache.camel.processor.aggregate Helper classes for the Aggregator pattern. 
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.util Utility classes used by the core of Camel and useful for Camel component developers 
 

Uses of Exchange in org.apache.camel
 

Methods in org.apache.camel that return Exchange
 Exchange Exchange.copy()
          Creates a copy of the current message exchange so that it can be forwarded to another destination
 Exchange 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)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
 Exchange Endpoint.createExchange(Exchange exchange)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
 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 RuntimeExchangeException.getExchange()
          Returns the exchange which caused the exception
 Exchange Message.getExchange()
          Returns the exchange this message is related to
 Exchange ExpressionEvaluationException.getExchange()
           
 Exchange ExpectedBodyTypeException.getExchange()
           
 Exchange CamelExchangeException.getExchange()
          Returns the exchange which caused the exception
 Exchange Exchange.newInstance()
          Creates a new exchange instance with empty messages, headers and properties
 Exchange PollingConsumer.receive()
          Waits until a message is available and then returns it.
 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 PollingConsumer.receiveNoWait()
          Attempts to receive a message exchange immediately without waiting and returning null if a message exchange is not available yet.
 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
 Exchange ProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied processor
 Exchange ProducerTemplate.send(Endpoint endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied processor
 Exchange ProducerTemplate.send(Endpoint endpoint, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied processor
 Exchange ProducerTemplate.send(Exchange exchange)
          Sends the exchange to the default endpoint
 Exchange ProducerTemplate.send(Processor processor)
          Sends an exchange to the default endpoint using a supplied processor
 Exchange ProducerTemplate.send(String endpointUri, Exchange exchange)
          Sends the exchange to the given endpoint
 Exchange ProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)
          Sends an exchange to an endpoint using a supplied processor
 Exchange ProducerTemplate.send(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied processor
 Exchange ProducerTemplate.send(String endpointUri, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied processor
 

Methods in org.apache.camel with parameters of type Exchange
<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).

 void Exchange.copyFrom(Exchange source)
          Copies the data into this exchange from the given exchange
 Exchange Producer.createExchange(Exchange exchange)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
 Exchange Endpoint.createExchange(Exchange exchange)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
protected static String CamelExchangeException.createMessage(String message, Exchange exchange)
           
 Object Expression.evaluate(Exchange exchange)
          Returns the value of the expression on the given exchange
<T> T
Expression.evaluate(Exchange exchange, Class<T> type)
          Returns the value of the expression on the given exchange
 T ExchangeProperty.get(Exchange exchange)
           
 boolean Predicate.matches(Exchange exchange)
          Evaluates the predicate on the message exchange and returns true 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 NoSuchPropertyException.reason(Exchange exchange, String propertyName)
           
protected static String NoSuchHeaderException.reason(Exchange exchange, String propertyName)
           
 T ExchangeProperty.remove(Exchange exchange)
           
 Exchange ProducerTemplate.send(Endpoint endpoint, Exchange exchange)
          Sends the exchange to the given endpoint
 Exchange ProducerTemplate.send(Exchange exchange)
          Sends the exchange to the default endpoint
 Exchange ProducerTemplate.send(String endpointUri, Exchange exchange)
          Sends the exchange to the given endpoint
 T ExchangeProperty.set(Exchange exchange, T value)
           
 

Constructors in org.apache.camel with parameters of type Exchange
CamelExchangeException(String message, Exchange exchange)
           
CamelExchangeException(String message, Exchange exchange, Throwable cause)
           
ExchangeTimedOutException(Exchange exchange, long timeout)
           
ExpectedBodyTypeException(Exchange exchange, Class expectedBodyType)
           
ExpressionEvaluationException(Expression expression, Exchange exchange, Throwable cause)
           
InvalidPayloadException(Exchange exchange, Class<?> type)
           
InvalidPayloadException(Exchange exchange, Class<?> type, Message message)
           
InvalidPayloadRuntimeException(Exchange exchange, Class<?> type)
           
InvalidTypeException(Exchange exchange, Object value, Class<?> type)
           
NoSuchHeaderException(Exchange exchange, String headerName, Class<?> type)
           
NoSuchPropertyException(Exchange exchange, String propertyName, Class<?> type)
           
RuntimeExchangeException(Exception e, Exchange exchange)
           
RuntimeExchangeException(String message, Exchange exchange)
           
ValidationException(Exchange exchange, String message)
           
ValidationException(String message, Exchange exchange, Throwable cause)
           
 

Uses of Exchange in org.apache.camel.builder
 

Methods in org.apache.camel.builder with type parameters of type Exchange
static
<E extends Exchange,T>
ValueBuilder
Builder.bodyAs(Class<T> type)
          Returns a predicate and value builder for the inbound message body as a specific type
static
<E extends Exchange,T>
ValueBuilder
Builder.faultBodyAs(Class<T> type)
          Returns a predicate and value builder for the fault message body as a specific type
static
<E extends Exchange,T>
ValueBuilder
Builder.outBodyAs(Class<T> type)
          Returns a predicate and value builder for the outbound message body as a specific type
 

Methods in org.apache.camel.builder with parameters of type Exchange
protected  String BinaryPredicateSupport.assertionFailureMessage(Exchange exchange, Object leftValue, Object rightValue)
           
 void BinaryPredicateSupport.assertMatches(String text, Exchange exchange)
           
 Object ValueBuilder.evaluate(Exchange exchange)
           
<T> T
ValueBuilder.evaluate(Exchange exchange, Class<T> type)
           
 boolean BinaryPredicateSupport.matches(Exchange exchange)
           
protected abstract  boolean BinaryPredicateSupport.matches(Exchange exchange, Object leftValue, Object rightValue)
           
 

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

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

Methods in org.apache.camel.builder.xml with parameters of type Exchange
 void XPathBuilder.assertMatches(String text, Exchange exchange)
           
protected  void XsltBuilder.configureTransformer(Transformer transformer, Exchange exchange)
          Configures the transformer with exchange specific parameters
 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)
          Strategy method to extract the document from the exchange
protected  Source XsltBuilder.getSource(Exchange exchange)
          Converts the inbound body to a Source
 boolean XPathBuilder.matches(Exchange exchange)
           
 void XsltBuilder.process(Exchange exchange)
           
 void MessageVariableResolver.setExchange(Exchange exchange)
           
 

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

Methods in org.apache.camel.component.bean with parameters of type Exchange
protected  MethodInfo BeanInfo.chooseMethod(Object pojo, Exchange exchange)
          Lets try choose one of the available methods to invoke if we can match the message body to the body parameter
protected  MethodInfo BeanInfo.chooseMethodWithCustomAnnotations(Exchange exchange, Collection<MethodInfo> possibles)
           
protected  MethodInfo BeanInfo.chooseMethodWithMatchingBody(Exchange exchange, Collection<MethodInfo> operationList)
           
 MethodInvocation BeanInfo.createInvocation(Method method, Object pojo, Exchange exchange)
           
 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)
           
 

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

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

Methods in org.apache.camel.component.browse that return types with arguments of type Exchange
protected  List<Exchange> BrowseEndpoint.createExchangeList()
           
 List<Exchange> BrowseEndpoint.getExchanges()
           
 

Methods in org.apache.camel.component.browse with parameters of type Exchange
protected  void BrowseEndpoint.onExchange(Exchange exchange)
          Invoked on a message exchange being sent by a producer
 

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

Methods in org.apache.camel.component.dataset that return Exchange
 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
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 dataSetEndpoint, Exchange expected, Exchange actual, long index)
          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)
           
 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
protected  void DataSetEndpoint.reportProgress(Exchange actual, int receivedCount)
           
 

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

Methods in org.apache.camel.component.direct with parameters of type Exchange
 void DirectProducer.process(Exchange exchange)
           
 boolean DirectProducer.process(Exchange exchange, AsyncCallback callback)
           
 

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

Classes in org.apache.camel.component.file that implement Exchange
 class GenericFileExchange<T>
           
 

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

Methods in org.apache.camel.component.file with parameters of type Exchange
 boolean GenericFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange)
          Acquires exclusive read lock to the file.
static Object GenericFileConverter.convertTo(Class<?> type, Exchange exchange, Object value, TypeConverterRegistry registry)
           
protected  String GenericFileProducer.createFileName(Exchange exchange)
           
 void GenericFileProducer.process(Exchange exchange)
           
 void GenericFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange)
          Releases the exclusive read lock granted by the acquireExclusiveReadLock method.
 

Constructors in org.apache.camel.component.file with parameters of type Exchange
GenericFileExchange(Exchange parent)
           
 

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

Methods in org.apache.camel.component.file.strategy with parameters of type Exchange
 boolean MarkerFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations, GenericFile<File> file, Exchange exchange)
           
 boolean FileLockExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
           
 boolean GenericFileRenameExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations, GenericFile<T> file, Exchange exchange)
           
 void MarkerFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations, GenericFile<File> fileGenericFile, Exchange exchange)
           
 void FileLockExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations, GenericFile<File> fileGenericFile, Exchange exchange)
           
 void GenericFileRenameExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> opeations, GenericFile<T> file, Exchange exchange)
           
 

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

Methods in org.apache.camel.component.jmx that return Exchange
 Exchange JMXEndpoint.createExchange(Notification notification)
           
 Exchange JMXMessage.getExchange()
           
 

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

Methods in org.apache.camel.component.log with parameters of type Exchange
 Object LogFormatter.format(Exchange exchange)
           
 

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

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

Methods in org.apache.camel.component.mock that return types with arguments of type Exchange
 List<Exchange> MockEndpoint.getExchanges()
           
 List<Exchange> MockEndpoint.getReceivedExchanges()
           
 

Methods in org.apache.camel.component.mock with parameters of type Exchange
protected  void AssertionClause.applyAssertionOn(MockEndpoint endpoint, int index, Exchange exchange)
          Performs any assertions on the given exchange
protected  void MockEndpoint.onExchange(Exchange exchange)
           
protected  void MockEndpoint.performAssertions(Exchange exchange)
           
 

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

Methods in org.apache.camel.component.seda that return types with arguments of type Exchange
 BlockingQueue<Exchange> SedaComponent.createQueue(String uri, Map parameters)
           
 List<Exchange> SedaEndpoint.getExchanges()
          Returns the current pending exchanges
 BlockingQueue<Exchange> SedaEndpoint.getQueue()
           
 

Methods in org.apache.camel.component.seda with parameters of type Exchange
 void CollectionProducer.process(Exchange exchange)
           
 boolean CollectionProducer.process(Exchange exchange, AsyncCallback callback)
           
 

Method parameters in org.apache.camel.component.seda with type arguments of type Exchange
 void SedaEndpoint.setQueue(BlockingQueue<Exchange> queue)
           
 

Constructor parameters in org.apache.camel.component.seda with type arguments of type Exchange
CollectionProducer(Endpoint endpoint, Collection<Exchange> queue)
           
SedaEndpoint(String endpointUri, BlockingQueue<Exchange> queue)
           
SedaEndpoint(String endpointUri, BlockingQueue<Exchange> queue, int concurrentConsumers)
           
SedaEndpoint(String endpointUri, Component component, BlockingQueue<Exchange> queue)
           
SedaEndpoint(String endpointUri, Component component, BlockingQueue<Exchange> queue, int concurrentConsumers)
           
SedaProducer(SedaEndpoint endpoint, BlockingQueue<Exchange> queue)
           
 

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

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

Uses of Exchange in org.apache.camel.converter
 

Methods in org.apache.camel.converter with parameters of type Exchange
static ByteBuffer NIOConverter.toByteBuffer(String value, Exchange exchange)
           
static InputStream IOConverter.toInputStream(BufferedReader buffer, Exchange exchange)
           
static InputStream IOConverter.toInputStream(String text, Exchange exchange)
           
static String IOConverter.toString(byte[] data, Exchange exchange)
           
static String NIOConverter.toString(ByteBuffer buffer, Exchange exchange)
           
 

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

Methods in org.apache.camel.converter.jaxp with parameters of type Exchange
 StreamSource XmlConverter.toStreamSource(byte[] in, Exchange exchange)
           
 StreamSource XmlConverter.toStreamSource(ByteBuffer in, Exchange exchange)
           
 

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

Methods in org.apache.camel.converter.stream with parameters of type Exchange
 StreamCache StreamCacheConverter.convertToStreamCache(InputStream stream, Exchange exchange)
           
 StreamCache StreamCacheConverter.convertToStreamCache(Reader reader, Exchange exchange)
           
 StreamCache StreamCacheConverter.convertToStreamCache(SAXSource source, Exchange exchange)
           
 StreamCache StreamCacheConverter.convertToStreamCache(StreamSource source, Exchange exchange)
           
 

Uses of Exchange in org.apache.camel.impl
 

Classes in org.apache.camel.impl that implement Exchange
 class DefaultExchange
          A default implementation of Exchange
 class GroupedExchange
          A grouped exchange that groups together other exchanges, as a holder object.
 

Methods in org.apache.camel.impl that return Exchange
 Exchange DefaultEndpoint.convertTo(Class<Exchange> type, Exchange exchange)
          Converts the given exchange to the specified exchange type
 Exchange DefaultExchange.copy()
           
 Exchange DefaultProducer.createExchange()
           
 Exchange DefaultEndpoint.createExchange()
           
 Exchange DefaultProducer.createExchange(Exchange exchange)
           
 Exchange DefaultEndpoint.createExchange(Exchange exchange)
           
 Exchange DefaultProducer.createExchange(ExchangePattern pattern)
           
 Exchange DefaultEndpoint.createExchange(ExchangePattern pattern)
           
 Exchange GroupedExchange.get(int index)
           
 Exchange MessageSupport.getExchange()
           
 Exchange DefaultExchange.newInstance()
           
 Exchange ProcessorPollingConsumer.receive()
           
 Exchange EventDrivenPollingConsumer.receive()
           
 Exchange ProcessorPollingConsumer.receive(long timeout)
           
 Exchange EventDrivenPollingConsumer.receive(long timeout)
           
 Exchange ProcessorPollingConsumer.receiveNoWait()
           
 Exchange EventDrivenPollingConsumer.receiveNoWait()
           
 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 ProducerCache.send(Endpoint endpoint, Processor processor, AsyncCallback callback)
          Sends an exchange to an endpoint using a supplied Processor to populate the exchange.
 Exchange DefaultProducerTemplate.send(Endpoint endpoint, Processor processor, AsyncCallback callback)
           
 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)
           
 Exchange DefaultProducerTemplate.send(String endpointUri, Processor processor, AsyncCallback callback)
           
protected  Exchange ProducerCache.sendExchange(Endpoint endpoint, Producer producer, Processor processor, Exchange exchange)
           
 

Methods in org.apache.camel.impl that return types with arguments of type Exchange
 List<Exchange> GroupedExchange.getExchanges()
           
 Class<Exchange> DefaultEndpoint.getExchangeType()
          Returns the type of the exchange which is generated by this component
 

Methods in org.apache.camel.impl with parameters of type Exchange
 void GroupedExchange.addExchange(Exchange exchange)
           
protected abstract  String ExpressionSupport.assertionFailureMessage(Exchange exchange)
           
protected  String ExpressionAdapter.assertionFailureMessage(Exchange exchange)
           
 void ExpressionSupport.assertMatches(String text, Exchange exchange)
           
 Exchange DefaultEndpoint.convertTo(Class<Exchange> type, Exchange exchange)
          Converts the given exchange to the specified exchange type
<T> T
DefaultExchangeConverter.convertTo(Class<T> type, Exchange exchange)
           
 void DefaultExchange.copyFrom(Exchange exchange)
           
 Exchange DefaultProducer.createExchange(Exchange exchange)
           
 Exchange DefaultEndpoint.createExchange(Exchange exchange)
           
 void DefaultUnitOfWork.done(Exchange exchange)
           
 Object ExpressionAdapter.evaluate(Exchange exchange)
           
<T> T
ExpressionSupport.evaluate(Exchange exchange, Class<T> type)
           
protected  Object DefaultProducerTemplate.extractResultBody(Exchange result)
          Extracts the body from the given result.
protected  Object DefaultProducerTemplate.extractResultBody(Exchange result, ExchangePattern pattern)
          Extracts the body from the given result.
 Object DefaultExchangeFormatter.format(Exchange exchange)
           
protected  boolean DefaultProducerTemplate.hasFaultMessage(Exchange result)
           
static boolean ProducerCache.isProcessedSync(Exchange exchange)
           
 void ZipDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
           
 void StringDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
           
 void SerializationDataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
           
 boolean ExpressionSupport.matches(Exchange exchange)
           
protected  void ProcessorEndpoint.onExchange(Exchange exchange)
           
 void ProducerTemplateProcessor.process(Exchange exchange)
           
 void EventDrivenPollingConsumer.process(Exchange exchange)
           
 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, Producer producer, Processor processor, Exchange exchange)
           
protected  boolean ProducerCache.sendExchange(Endpoint endpoint, Producer producer, Processor processor, Exchange exchange, AsyncCallback callback)
           
 void MessageSupport.setExchange(Exchange exchange)
           
static void ProducerCache.setProcessedSync(Exchange exchange, boolean sync)
           
 Object ZipDataFormat.unmarshal(Exchange exchange, InputStream stream)
           
 Object StringDataFormat.unmarshal(Exchange exchange, InputStream stream)
           
 Object SerializationDataFormat.unmarshal(Exchange exchange, InputStream stream)
           
 

Method parameters in org.apache.camel.impl with type arguments of type Exchange
 Exchange DefaultEndpoint.convertTo(Class<Exchange> type, Exchange exchange)
          Converts the given exchange to the specified exchange type
 void GroupedExchange.setExchanges(List<Exchange> exchanges)
           
 

Constructors in org.apache.camel.impl with parameters of type Exchange
DefaultExchange(Exchange parent)
           
GroupedExchange(Exchange parent)
           
 

Constructor parameters in org.apache.camel.impl with type arguments of type Exchange
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
<T> T
ToStringTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
StaticMethodTypeConverter.convertTo(Class<T> type, 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)
           
<T> T
InstanceMethodTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
InstanceMethodFallbackTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
EnumTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
DefaultTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
AsyncProcessorTypeConverter.convertTo(Class<T> toType, Exchange exchange, Object value)
           
<T> T
ArrayTypeConverter.convertTo(Class<T> type, Exchange exchange, Object value)
           
<T> T
DefaultTypeConverter.doConvertTo(Class<T> type, Exchange exchange, Object value)
           
 

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

Methods in org.apache.camel.language.bean that return Exchange
 Exchange RuntimeBeanExpressionException.getExchange()
           
 

Methods in org.apache.camel.language.bean with parameters of type Exchange
protected  String BeanExpression.assertionFailureMessage(Exchange exchange)
           
 void BeanExpression.assertMatches(String text, Exchange exchange)
           
 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
RuntimeBeanExpressionException(Exchange exchange, String bean, String method, Throwable e)
           
 

Uses of Exchange in org.apache.camel.management
 

Methods in org.apache.camel.management with parameters of type Exchange
 void InstrumentationProcessor.process(Exchange exchange)
           
 boolean InstrumentationProcessor.process(Exchange exchange, AsyncCallback callback)
           
protected  void InstrumentationProcessor.recordTime(Exchange exchange, double duration)
           
 

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

Methods in org.apache.camel.model.language with parameters of type Exchange
 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.model.loadbalancer
 

Methods in org.apache.camel.model.loadbalancer with parameters of type Exchange
 void LoadBalancerDefinition.process(Exchange exchange)
           
 boolean LoadBalancerDefinition.process(Exchange exchange, AsyncCallback callback)
           
 

Uses of Exchange in org.apache.camel.processor
 

Methods in org.apache.camel.processor with type parameters of type Exchange
static
<E extends Exchange>
Collection<Processor>
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
          A helper method to convert a list of endpoints into a list of processors
 

Methods in org.apache.camel.processor that return Exchange
protected  Exchange WireTapProcessor.configureExchange(Exchange exchange)
           
protected  Exchange SendProcessor.configureExchange(Exchange exchange)
           
protected  Exchange Pipeline.createNextExchange(Processor producer, 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.
 

Methods in org.apache.camel.processor that return types with arguments of type Exchange
protected static Set<Exchange> Resequencer.createSet(Comparator<? super Exchange> comparator)
           
protected static Set<Exchange> Resequencer.createSet(Expression expression)
           
protected static Set<Exchange> Resequencer.createSet(List<Expression> expressions)
           
protected  Collection<Exchange> BatchProcessor.getCollection()
           
 

Methods in org.apache.camel.processor with parameters of type Exchange
protected  void DeadLetterChannel.asyncProcess(Exchange exchange, AsyncCallback callback, org.apache.camel.processor.DeadLetterChannel.RedeliveryData data)
           
protected  Exchange WireTapProcessor.configureExchange(Exchange exchange)
           
protected  Exchange SendProcessor.configureExchange(Exchange exchange)
           
protected  String ThroughputLogger.createLogMessage(Exchange exchange, int receivedCount)
           
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the previous exchange.
protected  Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> Splitter.createProcessorExchangePairs(Exchange exchange)
           
protected  Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> MulticastProcessor.createProcessorExchangePairs(Exchange exchange)
           
protected  Exchange Enricher.createResourceExchange(Exchange source, ExchangePattern pattern)
          Creates a new DefaultExchange instance from the given exchange.
protected  boolean ErrorHandlerSupport.customProcessorForException(Exchange exchange, Throwable exception)
          Attempts to invoke the handler for this particular exception if one is available
protected  long Delayer.defaultProcessTime(Exchange exchange)
          A Strategy Method to allow derived implementations to decide the current system time or some other default exchange property
protected  void Throttler.delay(Exchange exchange)
           
protected abstract  void DelayProcessorSupport.delay(Exchange exchange)
           
protected  void Delayer.delay(Exchange exchange)
          Waits for an optional time period before continuing to process the exchange
protected  void MulticastProcessor.doAggregate(AtomicExchange result, Exchange exchange)
          Aggregate the Exchange with the current result
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  void TryProcessor.handleException(Exchange exchange, Throwable e)
           
protected  int DeadLetterChannel.incrementRedeliveryCounter(Exchange exchange, Throwable e)
          Increments the redelivery counter and adds the redelivered flag if the message has been redelivered
protected  void LoggingErrorHandler.logError(Exchange exchange, Throwable e)
           
protected  Object ThroughputLogger.logMessage(Exchange exchange)
           
protected  Object Logger.logMessage(Exchange exchange)
           
protected  Object LoggingErrorHandler.logMessage(Exchange exchange, Throwable e)
           
 void DelegateProcessor.proceed(Exchange exchange)
          Proceed with the underlying delegated processor
 void WireTapProcessor.process(Exchange exchange)
           
 void UnmarshalProcessor.process(Exchange exchange)
           
 void TryProcessor.process(Exchange exchange)
           
 void TransformProcessor.process(Exchange exchange)
           
 void ThrowFaultProcessor.process(Exchange exchange)
          Set the fault message in the exchange
 void ThroughputLogger.process(Exchange exchange)
           
 void ThreadProcessor.process(Exchange exchange)
           
 void StreamResequencer.process(Exchange exchange)
           
 void SortProcessor.process(Exchange exchange)
           
 void SendProcessor.process(Exchange exchange)
           
 void RoutingSlip.process(Exchange exchange)
           
 void RecipientList.process(Exchange exchange)
           
 void ProceedProcessor.process(Exchange exchange)
           
 void Pipeline.process(Exchange exchange)
           
 void MulticastProcessor.process(Exchange exchange)
           
 void MarshalProcessor.process(Exchange exchange)
           
 void LoopProcessor.process(Exchange exchange)
           
 void LoggingErrorHandler.process(Exchange exchange)
           
 void Logger.process(Exchange exchange)
           
 void Interceptor.process(Exchange exchange)
           
 void HandleFaultProcessor.process(Exchange exchange)
           
 void FilterProcessor.process(Exchange exchange)
           
 void ExchangePatternProcessor.process(Exchange exchange)
           
 void Enricher.process(Exchange exchange)
          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.
 void DelegateProcessor.process(Exchange exchange)
           
 void DelegateAsyncProcessor.process(Exchange exchange)
           
 void DelayProcessorSupport.process(Exchange exchange)
           
 void DeadLetterChannel.process(Exchange exchange)
           
 void ConvertBodyProcessor.process(Exchange exchange)
           
 void CompositeProcessor.process(Exchange exchange)
           
 void ChoiceProcessor.process(Exchange exchange)
           
 void BatchProcessor.process(Exchange exchange)
          Enqueues an exchange for later batch processing.
 boolean WireTapProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean UnitOfWorkProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean ThreadProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean SendProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean Pipeline.process(Exchange original, AsyncCallback callback)
           
 boolean HandleFaultProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean ExchangePatternProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean DelegateAsyncProcessor.process(Exchange exchange, AsyncCallback callback)
           
 boolean DeadLetterChannel.process(Exchange exchange, AsyncCallback callback)
           
protected  boolean DeadLetterChannel.process(Exchange exchange, AsyncCallback callback, org.apache.camel.processor.DeadLetterChannel.RedeliveryData data)
          Processes the exchange using decorated with this dead letter channel.
 void Logger.process(Exchange exchange, Throwable exception)
           
protected  void BatchProcessor.processExchange(Exchange exchange)
          Strategy Method to process an exchange in the batch.
protected  void TryProcessor.processFinally(Exchange exchange)
           
protected  void DelegateProcessor.processNext(Exchange exchange)
           
protected  Endpoint RoutingSlip.resolveEndpoint(Exchange exchange, Object recipient)
           
protected  Endpoint RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
protected static void DeadLetterChannel.restoreExceptionOnExchange(Exchange exchange, Predicate handledPredicate)
           
 void StreamResequencer.sendElement(Exchange exchange)
          Sends the exchange to the next processor.
 void RecipientList.sendToRecipientList(Exchange exchange, Object receipientList)
          Sends the given exchange to the recipient list
 boolean RedeliveryPolicy.shouldRedeliver(Exchange exchange, int redeliveryCounter, Predicate retryUntil)
          Returns true if the policy decides that the message exchange should be redelivered.
protected  void Splitter.updateNewExchange(Exchange exchange, int index, Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> allPairs)
           
protected  void MulticastProcessor.updateNewExchange(Exchange exchange, int i, Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> allPairs)
           
protected  void DelayProcessorSupport.waitUntil(long time, Exchange exchange)
          Wait until the given system time before continuing
 

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

Constructor parameters in org.apache.camel.processor with type arguments of type Exchange
BatchProcessor(Processor processor, Collection<Exchange> collection)
           
Resequencer(Processor processor, Set<Exchange> collection)
           
StreamResequencer(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
 Exchange UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
           
 Exchange AggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
          Aggregates an old and new exchange together to create a single combined exchange
 

Methods in org.apache.camel.processor.aggregate that return types with arguments of type Exchange
protected  Map<Object,Exchange> DefaultAggregationCollection.getAggregated()
           
 Iterator<Exchange> PredicateAggregationCollection.iterator()
           
 Iterator<Exchange> DefaultAggregationCollection.iterator()
           
 Iterator<Exchange> AggregationCollection.iterator()
          Gets the iterator to iterate this collection.
 

Methods in org.apache.camel.processor.aggregate with parameters of type Exchange
 boolean DefaultAggregationCollection.add(Exchange exchange)
           
 boolean AggregationCollection.add(Exchange exchange)
          Adds the given exchange to this collection
 Exchange UseLatestAggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
           
 Exchange AggregationStrategy.aggregate(Exchange oldExchange, Exchange newExchange)
          Aggregates an old and new exchange together to create a single combined exchange
protected  Exception UseLatestAggregationStrategy.checkException(Exchange oldExchange, Exchange newExchange)
           
 void PredicateAggregationCollection.onAggregation(Object correlationKey, Exchange newExchange)
           
 void DefaultAggregationCollection.onAggregation(Object correlationKey, Exchange newExchange)
           
 void AggregationCollection.onAggregation(Object correlationKey, Exchange newExchange)
          A strategy method allowing derived classes such as PredicateAggregationCollection to check to see if the aggregation has completed
 

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

Methods in org.apache.camel.processor.exceptionpolicy with parameters of type Exchange
 OnExceptionDefinition ExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicices, Exchange exchange, Throwable exception)
          Resolves the OnExceptionDefinition that should handle the thrown exception.
 OnExceptionDefinition DefaultExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicices, Exchange exchange, Throwable exception)
           
protected  boolean DefaultExceptionPolicyStrategy.matchesWhen(OnExceptionDefinition type, 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
 Exchange NoMessageIdException.getExchange()
          The exchange which caused this failure
 

Methods in org.apache.camel.processor.idempotent with parameters of type Exchange
protected  void IdempotentConsumer.onCompletedMessage(Exchange exchange, String messageId)
          A strategy method to allow derived classes to overload the behaviour 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 IdempotentConsumer.onFailedMessage(Exchange exchange, String messageId)
          A strategy method to allow derived classes to overload the behaviour of processing a failed message
 void IdempotentConsumer.process(Exchange exchange)
           
 

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

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

Classes in org.apache.camel.processor.interceptor that implement Exchange
 class TraceEventExchange
          Represents a trace of an Exchange, intercepted at the given node that occured during routing.
 

Methods in org.apache.camel.processor.interceptor that return Exchange
protected  Exchange DebugInterceptor.copyExchange(Exchange previousExchange)
           
 Exchange ExceptionEvent.getExchange()
           
 Exchange TraceEventExchange.getTracedExchange()
           
 Exchange TraceEventExchange.newInstance()
           
 

Methods in org.apache.camel.processor.interceptor that return types with arguments of type Exchange
protected  List<Exchange> Debugger.createExchangeList()
           
 List<Exchange> DebugInterceptor.getExchanges()
           
 List<Exchange> Debugger.getExchanges(String id)
          Returns the list of exchanges sent to the given node in the DSL
 

Methods in org.apache.camel.processor.interceptor with parameters of type Exchange
protected  void DebugInterceptor.addTraceExchange(Exchange exchange)
          Strategy method to store the exchange in a trace log if it is enabled
protected  void DebugInterceptor.checkForBreakpoint(Exchange exchange)
          Stategy method to wait for a breakpoint if one is set
protected  Exchange DebugInterceptor.copyExchange(Exchange previousExchange)
           
 void DelayInterceptor.delay(Exchange exchange)
           
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.
 Object TraceInterceptor.format(Exchange exchange)
           
 Object TraceFormatter.format(TraceInterceptor interceptor, ProcessorDefinition node, Exchange exchange)
          Formats a log message at given point of interception.
 Object DefaultTraceFormatter.format(TraceInterceptor interceptor, ProcessorDefinition node, Exchange exchange)
           
protected  Object DefaultTraceFormatter.getBreadCrumbID(Exchange exchange)
           
protected  void TraceInterceptor.logException(Exchange exchange, Throwable throwable)
           
protected  void TraceInterceptor.logExchange(Exchange exchange)
           
protected  void DebugInterceptor.onException(Exchange exchange, Throwable e)
          Fired when an exception is thrown when processing the underlying processor
 boolean StreamCachingInterceptor.proceed(Exchange exchange, AsyncCallback callback)
           
 void TraceInterceptor.process(Exchange exchange)
           
 void StreamCachingInterceptor.process(Exchange exchange)
           
 void DebugInterceptor.process(Exchange exchange)
           
 boolean StreamCachingInterceptor.process(Exchange exchange, AsyncCallback callback)
           
 void TraceEventExchange.setTracedExchange(Exchange tracedExchange)
           
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
protected  boolean DebugInterceptor.shouldTraceExchange(Exchange exchange)
          Returns true if the given exchange should be logged in the trace list
protected  void TraceInterceptor.traceExchange(Exchange exchange)
           
 void Breakpoint.waitForBreakpoint(Exchange exchange)
           
 

Constructors in org.apache.camel.processor.interceptor with parameters of type Exchange
DefaultTraceEventMessage(Date timestamp, ProcessorDefinition toNode, Exchange exchange)
          Creates a DefaultTraceEventMessage based on the given node it was traced while processing the current Exchange
ExceptionEvent(DebugInterceptor interceptor, Exchange exchange, Throwable exception)
           
TraceEventExchange(Exchange parent)
           
 

Constructor parameters in org.apache.camel.processor.interceptor with type arguments of type Exchange
DebugInterceptor(ProcessorDefinition node, Processor target, List<Exchange> exchanges, List<ExceptionEvent> exceptions)
           
 

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

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

Methods in org.apache.camel.processor.loadbalancer with parameters of type Exchange
protected  Processor StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected abstract  Processor QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Exchange TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  boolean FailOverLoadBalancer.isCheckedException(Exchange exchange)
           
 void TopicLoadBalancer.process(Exchange exchange)
           
 void QueueLoadBalancer.process(Exchange exchange)
           
 void FailOverLoadBalancer.process(Exchange exchange)
           
 boolean TopicLoadBalancer.process(Exchange exchange, AsyncCallback callback)
           
 boolean QueueLoadBalancer.process(Exchange exchange, AsyncCallback callback)
           
 boolean FailOverLoadBalancer.process(Exchange exchange, AsyncCallback callback)
           
 boolean FailOverLoadBalancer.processExchange(int index, Exchange exchange, AsyncCallback callback)
           
 

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

Methods in org.apache.camel.processor.resequencer with parameters of type Exchange
 int DefaultExchangeComparator.compare(Exchange o1, Exchange o2)
           
 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
 void DefaultValidationErrorHandler.handleErrors(Exchange exchange, Object schema)
           
 void ValidatorErrorHandler.handleErrors(Exchange exchange, Schema schema, DOMResult result)
          Process any errors which may have occurred during validation
 void DefaultValidationErrorHandler.handleErrors(Exchange exchange, Schema schema, DOMResult result)
           
 void ValidatingProcessor.process(Exchange exchange)
           
 

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

Uses of Exchange in org.apache.camel.spi
 

Methods in org.apache.camel.spi that return types with arguments of type Exchange
 List<Exchange> BrowsableEndpoint.getExchanges()
          Return the exchanges available on this endpoint
 

Methods in org.apache.camel.spi with parameters of type Exchange
<T> T
ExchangeConverter.convertTo(Class<T> type, Exchange exchange)
          Converts the given exchange to the new type
 void UnitOfWork.done(Exchange exchange)
          Invoked when this unit of work has been completed, whether it has failed or completed
 Object ExchangeFormatter.format(Exchange exchange)
          Generates a string representation of the exchange
 void DataFormat.marshal(Exchange exchange, Object graph, OutputStream stream)
          Marshals the object to the given Stream.
 void Synchronization.onComplete(Exchange exchange)
          Called when the processing of the message exchange is complete
 void Synchronization.onFailure(Exchange exchange)
          Called when the processing of the message exchange has failed for some reason.
 Object DataFormat.unmarshal(Exchange exchange, InputStream stream)
          Unmarshals the given stream into an object.
 

Uses of Exchange in org.apache.camel.util
 

Methods in org.apache.camel.util that return Exchange
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
static void PredicateAssertHelper.assertMatches(Predicate predicate, String text, Exchange exchange)
           
 int ExpressionListComparator.compare(Exchange e1, Exchange e2)
           
 int ExpressionComparator.compare(Exchange e1, Exchange e2)
           
static
<T> T
ExchangeHelper.convertToMandatoryType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type or throws an exception
static
<T> T
ExchangeHelper.convertToType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type returning null if it could not be converted
static 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 out and fault message contents and the exception
static void ExchangeHelper.copyResultsPreservePattern(Exchange result, Exchange source)
          Copies the source exchange to target exchange preserving the ExchangePattern of target.
static Map ExchangeHelper.createVariableMap(Exchange exchange)
          Creates a Map of the variables which are made available to a script or template
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.getExchangeProperty(Exchange exchange, String propertyName, Class<T> type, T defaultValue)
          Extracts the exchange property of the given name and type; if it is not present then the default value will be used
static
<T> T
ExchangeHelper.getMandatoryHeader(Exchange exchange, String propertyName, Class<T> type)
           
static Object ExchangeHelper.getMandatoryInBody(Exchange exchange)
          Returns the mandatory inbound message body of the correct type or throws an exception if it is not present
static
<T> T
ExchangeHelper.getMandatoryInBody(Exchange exchange, Class<T> type)
          Returns the mandatory inbound message body of the correct type or throws an exception if it is not present
static Object ExchangeHelper.getMandatoryOutBody(Exchange exchange)
          Returns the mandatory outbound message body of the correct type or throws an exception if it is not present
static
<T> T
ExchangeHelper.getMandatoryOutBody(Exchange exchange, Class<T> type)
          Returns the mandatory outbound message body of the correct type or throws an exception if it is not present
static
<T> T
ExchangeHelper.getMandatoryProperty(Exchange exchange, String propertyName, Class<T> type)
           
static Message ExchangeHelper.getResultMessage(Exchange exchange)
          Returns the message where to write results in an exchange-pattern-sensitive way.
static boolean ExchangeHelper.isFailureHandled(Exchange exchange)
           
static boolean ExchangeHelper.isInCapable(Exchange exchange)
          Returns true if the given exchange pattern (if defined) can support IN messagea
static boolean ExchangeHelper.isOutCapable(Exchange exchange)
          Returns true if the given exchange pattern (if defined) can support OUT messagea
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
static
<T> T
ExchangeHelper.newInstance(Exchange exchange, Class<T> type)
          Creates a new instance of the given type from the injector
static void ExchangeHelper.populateVariableMap(Exchange exchange, Map map)
          Populates the Map with the variables which are made available to a script or template
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 Endpoint ExchangeHelper.resolveEndpoint(Exchange exchange, Object value)
          Attempts to resolve the endpoint for the given value
static void ExchangeHelper.setFailureHandled(Exchange exchange)
           
 

Method parameters in org.apache.camel.util with type arguments of type Exchange
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
 



Copyright © 2009 Apache Software Foundation. All Rights Reserved.