Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

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.dataset A DataSet Endpoint for testing of endpoints using defined DataSets 
org.apache.camel.component.direct The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint. 
org.apache.camel.component.file The File Component for working with file systems. 
org.apache.camel.component.jmx The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. 
org.apache.camel.component.list The List Component which is a simple in memory component which maintains a List of all message exchanges which can be useful for debugging, tooling or visualistion. 
org.apache.camel.component.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.timer The Timer Component extends the POJO component to provide a simple timer 
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 Camel language support such as Bean and Simple language. 
org.apache.camel.language.bean Camel Bean language. 
org.apache.camel.language.constant Camel Constant language. 
org.apache.camel.language.header Camel Header language. 
org.apache.camel.language.simple Camel Simple language. 
org.apache.camel.language.xpath Camel XPath language support. 
org.apache.camel.management Camel JMX export services. 
org.apache.camel.model The JAXB POJOs for the XML Configuration of the routing rules. 
org.apache.camel.model.config The Resequencer Configuration classes 
org.apache.camel.model.dataformat The JAXB POJOs for the Data Formats used to marshal and unmarshal objects to and from streams inside components 
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
 

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

Methods in org.apache.camel with type parameters of type Exchange
<E extends Exchange>
ProducerTemplate<E>
CamelContext.createProducerTemplate()
          Creates a new ProducerTemplate.
 

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 RuntimeExchangeException.getExchange()
          Returns the exchange which caused the exception
 Exchange Message.getExchange()
          Returns the exchange this message is related to
 Exchange ExpectedBodyTypeException.getExchange()
           
 Exchange CamelExchangeException.getExchange()
          Returns the exchange which caused the exception
 Exchange Exchange.newInstance()
          Deprecated. Starting with Camel 2.0.0 you should use copy() to get a new instance of an exchange or simply create a new exchange object
 Exchange ProducerTemplate.request(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.
 

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)
          Deprecated. Starting with Camel 2.0.0 you should use copy() to get a new instance of an exchange or simply create a new exchange object
 E Endpoint.createExchange(Exchange exchange)
          Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages
protected static String CamelExchangeException.createMessage(String message, Exchange exchange)
           
 T ExchangeProperty.get(Exchange exchange)
          Deprecated.  
 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)
          Deprecated.  
 T ExchangeProperty.set(Exchange exchange, T value)
          Deprecated.  
 

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)
           
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)
           
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.builder
 

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

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

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

Classes in org.apache.camel.builder.xml with type parameters of type Exchange
 class XPathBuilder<E extends Exchange>
          Creates an XPath expression builder which creates a nodeset result by default.
 

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
protected  void XsltBuilder.configureTransformer(Transformer transformer, Exchange exchange)
          Configures the transformer with exchange specific parameters
protected  Source XsltBuilder.getSource(Exchange exchange)
          Converts the inbound body to a Source
 void XsltBuilder.process(Exchange exchange)
           
 void MessageVariableResolver.setExchange(Exchange exchange)
           
 

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

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

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

Methods in org.apache.camel.component.bean with parameters of type Exchange
protected  MethodInfo BeanInfo.chooseMethod(Object pojo, Exchange exchange)
          Lets try choose one of the available methods to invoke if we can match the message body to the body parameter
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)
           
MethodNotFoundException(Exchange exchange, Object pojo, String methodName)
           
 

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 that return types with arguments of type Exchange
 Consumer<Exchange> DataSetEndpoint.createConsumer(Processor processor)
           
protected  Endpoint<Exchange> DataSetComponent.createEndpoint(String uri, String remaining, Map parameters)
           
 PollingConsumer<Exchange> DataSetEndpoint.createPollingConsumer()
           
 

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
 

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

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 FileExchange
          A Exchange for File
 

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

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

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

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

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

Methods in org.apache.camel.component.list that return types with arguments of type Exchange
 Consumer<Exchange> ListEndpoint.createConsumer(Processor processor)
           
protected  List<Exchange> ListEndpoint.createExchangeList()
           
 Producer<Exchange> ListEndpoint.createProducer()
           
 List<Exchange> ListEndpoint.getExchanges()
           
 

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

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

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

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
 Consumer<Exchange> MockEndpoint.createConsumer(Processor processor)
           
protected  Endpoint<Exchange> MockComponent.createEndpoint(String uri, String remaining, Map parameters)
           
 Producer<Exchange> MockEndpoint.createProducer()
           
 List<Exchange> MockEndpoint.getExchanges()
           
 List<Exchange> MockEndpoint.getReceivedExchanges()
           
 ValueBuilder<Exchange> AssertionClause.header(String name)
          Returns a predicate and value builder for headers on an exchange
protected  Predicate<Exchange> AssertionClause.PredicateValueBuilder.onNewPredicate(Predicate<Exchange> predicate)
           
 ValueBuilder<Exchange> AssertionClause.property(String name)
          Returns a predicate and value builder for property on an exchange
 

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)
           
 

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

Constructor parameters in org.apache.camel.component.mock with type arguments of type Exchange
AssertionClause.PredicateValueBuilder(Expression<Exchange> expression)
           
 

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

Methods in org.apache.camel.component.seda that return Exchange
 Exchange ListPollingConsumer.receive()
          Deprecated.  
 Exchange ListPollingConsumer.receive(long timeout)
          Deprecated.  
 Exchange ListPollingConsumer.receiveNoWait()
          Deprecated.  
 

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()
           
 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)
           
 

Constructor parameters in org.apache.camel.component.seda with type arguments of type Exchange
CollectionProducer(Endpoint endpoint, Collection<Exchange> queue)
           
ListPollingConsumer(Endpoint endpoint, List<Exchange> exchanges)
          Deprecated.  
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)
           
 

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

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

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 String IOConverter.getCharsetName(Exchange 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)
           
 

Method parameters in org.apache.camel.converter with type arguments of type Exchange
 Processor CamelConverter.toProcessor(Expression<Exchange> expresion)
           
 Processor CamelConverter.toProcessor(Predicate<Exchange> predicate)
           
 

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

Methods in org.apache.camel.converter.jaxp with parameters of type Exchange
 XMLEventReader StaxConverter.createXMLEventReader(InputStream in, Exchange exchange)
           
 XMLEventWriter StaxConverter.createXMLEventWriter(OutputStream out, Exchange exchange)
           
 XMLStreamReader StaxConverter.createXMLStreamReader(InputStream in, Exchange exchange)
           
 XMLStreamWriter StaxConverter.createXMLStreamWriter(OutputStream outputStream, 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(StreamSource source, Exchange exchange)
           
 

Uses of Exchange in org.apache.camel.impl
 

Classes in org.apache.camel.impl with type parameters of type Exchange
 class BinaryPredicateSupport<E extends Exchange>
          Deprecated. is a duplicate of the same class in the builder package. Will be removed in Camel 2.0
 class DefaultComponent<E extends Exchange>
          Default component to use for base for components implementations.
 class DefaultComponentResolver<E extends Exchange>
          The default implementation of ComponentResolver which tries to find components by using the URI scheme prefix and searching for a file of the URI scheme name in the META-INF/services/org/apache/camel/component/ directory on the classpath.
 class DefaultConsumer<E extends Exchange>
          A default consumer useful for implementation inheritance.
 class DefaultEndpoint<E extends Exchange>
          A default endpoint useful for implementation inheritance
 class DefaultPollingEndpoint<E extends Exchange>
          A base class for an endpoint which the default consumer mode is to use a PollingConsumer
 class DefaultProducer<E extends Exchange>
          A default implementation of @{link Producer} for implementation inheritence
 class DefaultProducerTemplate<E extends Exchange>
          A client helper object (named like Spring's TransactionTemplate & JmsTemplate et al) for working with Camel and sending Message instances in an Exchange to an Endpoint.
 class DefaultScheduledPollConsumer<E extends Exchange>
          A default implementation of an event driven Consumer which uses the PollingConsumer
 class EventDrivenConsumerRoute<E extends Exchange>
          A Route which starts with an Event Driven Consumer
 class EventDrivenPollingConsumer<E extends Exchange>
          A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
 class ExpressionSupport<E extends Exchange>
          A useful base class for Predicate and Expression implementations
 class PollingConsumerSupport<E extends Exchange>
          A useful base class for implementations of PollingConsumer
 class PredicateSupport<E extends Exchange>
          A useful base class for Predicate implementations
 class ProducerCache<E extends Exchange>
          Cache containing created Producer.
 class ScheduledPollConsumer<E extends Exchange>
          A useful base class for any consumer which is polling based
 class ScheduledPollEndpoint<E extends Exchange>
          A base class for Endpoint which creates a ScheduledPollConsumer
 

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

Methods in org.apache.camel.impl with type parameters of type Exchange
<E extends Exchange>
ProducerTemplate<E>
DefaultCamelContext.createProducerTemplate()
           
 

Methods in org.apache.camel.impl that return Exchange
 Exchange DefaultExchange.copy()
           
 Exchange MessageSupport.getExchange()
           
 Exchange DefaultExchange.newInstance()
           
 Exchange ProcessorPollingConsumer.receive()
           
 Exchange ProcessorPollingConsumer.receive(long timeout)
           
 Exchange ProcessorPollingConsumer.receiveNoWait()
           
 

Methods in org.apache.camel.impl that return types with arguments of type Exchange
 PollingConsumer<Exchange> ProcessorEndpoint.createPollingConsumer()
           
 Producer<Exchange> ProcessorEndpoint.createProducer()
           
 Endpoint<? extends Exchange> DefaultRouteContext.getEndpoint()
           
 Endpoint<? extends Exchange> DefaultRouteContext.resolveEndpoint(String uri)
           
 Endpoint<? extends Exchange> DefaultRouteContext.resolveEndpoint(String uri, String ref)
           
 

Methods in org.apache.camel.impl with parameters of type Exchange
 E DefaultEndpoint.convertTo(Class<E> type, Exchange exchange)
          Converts the given exchange to the specified exchange type
<T> T
DefaultExchangeConverter.convertTo(Class<T> type, Exchange exchange)
           
 void DefaultExchange.copyFrom(Exchange exchange)
           
 E DefaultEndpoint.createExchange(Exchange exchange)
           
 void DefaultUnitOfWork.done(Exchange exchange)
           
 Object DefaultExchangeFormatter.format(Exchange exchange)
           
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)
           
protected  void ProcessorEndpoint.onExchange(Exchange exchange)
           
 void ProducerTemplateProcessor.process(Exchange exchange)
           
 void EventDrivenPollingConsumer.process(Exchange exchange)
           
 void MessageSupport.setExchange(Exchange exchange)
           
static void ProducerCache.setProcessedSync(Exchange exchange, boolean b)
           
 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
 void DelegateLifecycleStrategy.onEndpointAdd(Endpoint<? extends Exchange> endpoint)
           
 void DefaultLifecycleStrategy.onEndpointAdd(Endpoint<? extends Exchange> endpoint)
           
 

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
PropertyEditorTypeConverter.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
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
 

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

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

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

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

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

Classes in org.apache.camel.language.bean with type parameters of type Exchange
 class BeanExpression<E extends Exchange>
          Evaluates an expression using a bean method invocation
 

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

Methods in org.apache.camel.language.bean that return types with arguments of type Exchange
 Expression<Exchange> BeanLanguage.createExpression(Object bean, String method)
           
 Expression<Exchange> BeanLanguage.createExpression(String expression)
           
 Predicate<Exchange> BeanLanguage.createPredicate(String expression)
           
 

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.language.constant
 

Methods in org.apache.camel.language.constant that return types with arguments of type Exchange
static Expression<Exchange> ConstantLanguage.constant(Object value)
           
 Expression<Exchange> ConstantLanguage.createExpression(String expression)
           
 Predicate<Exchange> ConstantLanguage.createPredicate(String expression)
           
 

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

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

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

Methods in org.apache.camel.language.simple with type parameters of type Exchange
protected abstract
<E extends Exchange>
Expression<Exchange>
AbstractSimpleLanguage.createSimpleExpression(String expression)
          Creates the simple expression based on the extracted content from the ${ } place holders
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.dateExpression(String command, String pattern)
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileAbsolutePathExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileCanoicalPathExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileExtensionExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileNameExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileNameNoExtensionExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileParentExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.filePathExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.fileSizeExpression()
           
static
<E extends Exchange>
Expression<E>
FileExpressionBuilder.simpleExpression(String simple)
           
 

Methods in org.apache.camel.language.simple that return types with arguments of type Exchange
protected  Expression<Exchange> AbstractSimpleLanguage.createComplexExpression(String expression)
           
 Expression<Exchange> AbstractSimpleLanguage.createExpression(String expression)
           
 Predicate<Exchange> AbstractSimpleLanguage.createPredicate(String expression)
           
protected  Expression<Exchange> SimpleLanguage.createSimpleExpression(String expression)
           
protected abstract
<E extends Exchange>
Expression<Exchange>
AbstractSimpleLanguage.createSimpleExpression(String expression)
          Creates the simple expression based on the extracted content from the ${ } place holders
 

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

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

Uses of Exchange in org.apache.camel.management
 

Methods in org.apache.camel.management that return types with arguments of type Exchange
 Endpoint<? extends Exchange> ManagedEndpoint.getEndpoint()
           
 Route<? extends Exchange> ManagedRoute.getRoute()
           
 

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)
           
 

Method parameters in org.apache.camel.management with type arguments of type Exchange
protected  String CamelNamingStrategy.getEndpointId(Endpoint<? extends Exchange> ep)
           
 void InstrumentationLifecycleStrategy.onEndpointAdd(Endpoint<? extends Exchange> endpoint)
           
 

Constructor parameters in org.apache.camel.management with type arguments of type Exchange
ManagedEndpoint(Endpoint<? extends Exchange> endpoint)
           
 

Uses of Exchange in org.apache.camel.model
 

Methods in org.apache.camel.model that return types with arguments of type Exchange
 Endpoint<? extends Exchange> FromType.resolveEndpoint(RouteContext context)
           
 

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

Constructor parameters in org.apache.camel.model with type arguments of type Exchange
FromType(Endpoint<? extends Exchange> endpoint)
           
 

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

Methods in org.apache.camel.model.config that return types with arguments of type Exchange
 ExpressionResultComparator<Exchange> StreamResequencerConfig.getComparator()
           
 

Method parameters in org.apache.camel.model.config with type arguments of type Exchange
 void StreamResequencerConfig.setComparator(ExpressionResultComparator<Exchange> comparator)
           
 

Constructor parameters in org.apache.camel.model.config with type arguments of type Exchange
StreamResequencerConfig(int capacity, long timeout, ExpressionResultComparator<Exchange> comparator)
          Creates a new BatchResequencerConfig instance using the given values for capacity and timeout.
 

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

Methods in org.apache.camel.model.dataformat with parameters of type Exchange
 void DataFormatType.marshal(Exchange exchange, Object graph, OutputStream stream)
           
 Object DataFormatType.unmarshal(Exchange exchange, InputStream stream)
           
 

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

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

Methods in org.apache.camel.model.language with parameters of type Exchange
 void ExpressionType.assertMatches(String text, Exchange exchange)
           
 Object ExpressionType.evaluate(Exchange exchange)
           
 boolean ExpressionType.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 LoadBalancerType.process(Exchange exchange)
           
 boolean LoadBalancerType.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>
Logger
DeadLetterChannel.createDefaultLogger()
           
static
<E extends Exchange>
Collection<Processor>
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
          A helper method to convert a list of endpoints into a list of processors
 

Methods in org.apache.camel.processor that return Exchange
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the previous 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<Exchange> expression)
           
protected static Set<Exchange> Resequencer.createSet(List<Expression> expressions)
           
 Expression<Exchange> LoopProcessor.getExpression()
           
 Predicate<Exchange> FilterProcessor.getPredicate()
           
protected  Endpoint<Exchange> RoutingSlip.resolveEndpoint(Exchange exchange, Object recipient)
           
protected  Endpoint<Exchange> RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
 

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  void 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  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  ExceptionType ErrorHandlerSupport.getExceptionPolicy(Exchange exchange, Throwable exception)
          Attempts to find the best suited ExceptionType 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
static boolean DeadLetterChannel.isFailureHandled(Exchange exchange)
           
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 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 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 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 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<Exchange> RoutingSlip.resolveEndpoint(Exchange exchange, Object recipient)
           
protected  Endpoint<Exchange> RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
protected static void DeadLetterChannel.restoreExceptionOnExchange(Exchange exchange, Predicate handledPredicate)
           
 void StreamResequencer.sendElement(Exchange o)
          Sends the exchange to the next processor.
 void RecipientList.sendToRecipientList(Exchange exchange, Object receipientList)
          Sends the given exchange to the recipient list
static void DeadLetterChannel.setFailureHandled(Exchange exchange)
           
protected  void Splitter.updateNewExchange(Exchange exchange, int i, 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)
           
protected static Set<Exchange> Resequencer.createSet(Expression<Exchange> expression)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Exchange
BatchProcessor(Processor processor, Collection<Exchange> collection)
           
Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)
           
FilterProcessor(Predicate<Exchange> predicate, Processor processor)
           
LoopProcessor(Expression<Exchange> expression, Processor processor)
           
RecipientList(Expression<Exchange> expression)
           
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
 Expression<Exchange> DefaultAggregationCollection.getCorrelationExpression()
           
 Expression<Exchange> AggregationCollection.getCorrelationExpression()
          Gets the correlation expression
protected  Map<Object,Exchange> DefaultAggregationCollection.getMap()
           
 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  Throwable 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
 

Method parameters in org.apache.camel.processor.aggregate with type arguments of type Exchange
 void DefaultAggregationCollection.setCorrelationExpression(Expression<Exchange> correlationExpression)
           
 void AggregationCollection.setCorrelationExpression(Expression<Exchange> correlationExpression)
          Sets the correlation expression to be used
 

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

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

Methods in org.apache.camel.processor.exceptionpolicy with parameters of type Exchange
 ExceptionType ExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,ExceptionType> exceptionPolicices, Exchange exchange, Throwable exception)
          Resolves the ExceptionType that should handle the thrown exception.
 ExceptionType DefaultExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,ExceptionType> exceptionPolicices, Exchange exchange, Throwable exception)
           
protected  boolean DefaultExceptionPolicyStrategy.matchesWhen(ExceptionType 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 that return types with arguments of type Exchange
 Expression<Exchange> IdempotentConsumer.getMessageIdExpression()
           
 

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

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

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

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

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

Methods in org.apache.camel.processor.interceptor that return types with arguments of type Exchange
protected  List<Exchange> Debugger.createExchangeList()
          Deprecated.  
 List<Exchange> DebugInterceptor.getExchanges()
          Deprecated.  
 List<Exchange> Debugger.getExchanges(String id)
          Deprecated. 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)
          Deprecated. Strategy method to store the exchange in a trace log if it is enabled
protected  void DebugInterceptor.checkForBreakpoint(Exchange exchange)
          Deprecated. Stategy method to wait for a breakpoint if one is set
protected  Exchange DebugInterceptor.copyExchange(Exchange previousExchange)
          Deprecated.  
 void DelayInterceptor.delay(Exchange exchange)
           
 Object TraceInterceptor.format(Exchange exchange)
           
 Object ExchangeFormatter.format(Exchange exchange)
          Generates a string representation of the exchange
 Object TraceFormatter.format(TraceInterceptor interceptor, Exchange exchange)
           
protected  Object TraceFormatter.getBreadCrumbID(Exchange exchange)
           
protected  String TraceFormatter.getExchangeAndNode(TraceInterceptor interceptor, Exchange exchange)
          Returns the exchange id and node, ordered based on whether this was a trace of an exchange coming out of or into a processing step.
protected  void TraceInterceptor.logException(Exchange exchange, Throwable throwable)
           
protected  void TraceInterceptor.logExchange(Exchange exchange)
           
protected  void DebugInterceptor.onException(Exchange exchange, Throwable e)
          Deprecated. 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)
          Deprecated.  
 boolean StreamCachingInterceptor.process(Exchange exchange, AsyncCallback callback)
           
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)
          Deprecated. Returns true if the given exchange should be logged in the trace list
 void Breakpoint.waitForBreakpoint(Exchange exchange)
          Deprecated.  
 

Constructors in org.apache.camel.processor.interceptor with parameters of type Exchange
ExceptionEvent(DebugInterceptor interceptor, Exchange exchange, Throwable exception)
          Deprecated.  
 

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

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.
 void TopicLoadBalancer.process(Exchange exchange)
           
 void QueueLoadBalancer.process(Exchange exchange)
           
 boolean TopicLoadBalancer.process(Exchange exchange, AsyncCallback callback)
           
 boolean QueueLoadBalancer.process(Exchange exchange, AsyncCallback callback)
           
 

Method parameters in org.apache.camel.processor.loadbalancer with type arguments of type Exchange
 void StickyLoadBalancer.setCorrelationExpression(Expression<Exchange> correlationExpression)
           
 

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

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

Classes in org.apache.camel.processor.resequencer with type parameters of type Exchange
 interface ExpressionResultComparator<E extends Exchange>
          A SequenceElementComparator that compares Exchanges based on the result of an expression evaluation.
 

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

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)
           
 

Method parameters in org.apache.camel.processor.resequencer with type arguments of type Exchange
 void DefaultExchangeComparator.setExpression(Expression<Exchange> expression)
           
 

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
 

Classes in org.apache.camel.spi with type parameters of type Exchange
 interface BrowsableEndpoint<T extends Exchange>
          An optional interface an Endpoint may choose to implement which allows it to expose a way of browsing the exchanges available.
 interface ComponentResolver<E extends Exchange>
          Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like DefaultComponentResolver
 

Methods in org.apache.camel.spi that return types with arguments of type Exchange
 Expression<Exchange> Language.createExpression(String expression)
          Creates an expression based on the given string input
 Predicate<Exchange> Language.createPredicate(String expression)
          Creates a predicate based on the given string input
 Endpoint<? extends Exchange> RouteContext.getEndpoint()
          Gets the endpoint
 List<Exchange> BrowsableEndpoint.getExchanges()
          Return the exchanges available on this endpoint
 Endpoint<? extends Exchange> RouteContext.resolveEndpoint(String uri)
          Resolves an endpoint from the URI
 Endpoint<? extends Exchange> RouteContext.resolveEndpoint(String uri, String ref)
          Resolves an endpoint from either a URI or a named reference
 

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
 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.
 

Method parameters in org.apache.camel.spi with type arguments of type Exchange
 void LifecycleStrategy.onEndpointAdd(Endpoint<? extends Exchange> endpoint)
          Notification on adding an Endpoint.
 

Uses of Exchange in org.apache.camel.util
 

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

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

Methods in org.apache.camel.util with parameters of type Exchange
 int ExpressionListComparator.compare(Exchange e1, Exchange e2)
           
static
<T> T
ExchangeHelper.convertToMandatoryType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type or throws an exception
static
<T> T
ExchangeHelper.convertToType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type returning null if it could not be converted
static 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 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 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.
 

Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    
Apache CAMEL