Uses of Interface
org.apache.camel.Exchange

Packages that use Exchange
org.apache.camel The core Camel API 
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.builder.xml Support for XPath based Expressions and Predicates as well as an XSLT processor 
org.apache.camel.component.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.mock The Mock Component which is used for testing of routing and mediation rules. 
org.apache.camel.component.pojo The POJO Component provides a simple Reflection based transport. 
org.apache.camel.component.processor A component to make it easy to turn a Processor into a fully fledged Endpoint 
org.apache.camel.component.queue The Queue Component provides asynchronous (in-VM) dispatch of messages to consumer to implement SEDA based message routing using Java's Queue interface. 
org.apache.camel.impl Default implementation classes for Camel Core 
org.apache.camel.processor A collection of Processor implementations which are used to implement the Enterprise Integration Patterns 
org.apache.camel.processor.idempotent An implementation of the Idempotent Consumer pattern. 
org.apache.camel.processor.loadbalancer Various load balancer processors 
org.apache.camel.spi Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. 
org.apache.camel.util Utility classes used by the core of Camel and useful for Camel component developers 
 

Uses of Exchange in org.apache.camel
 

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

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

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

Constructors in org.apache.camel with parameters of type Exchange
ExpectedBodyTypeException(Exchange exchange, Class expectedBodyType)
           
 

Uses of Exchange in org.apache.camel.builder
 

Classes in org.apache.camel.builder with type parameters of type Exchange
 interface ErrorHandlerBuilder<E extends Exchange>
           
 class NoErrorHandlerBuilder<E extends Exchange>
          A builder to disable the use of an error handler so that any exceptions are thrown.
 interface PredicateFactory<E extends Exchange>
          A Factory of Predicate objects typically implemented by a builder such as @{XPathBuilder}
 class RecipientListBuilder<E extends Exchange>
          Creates a dynamic Recipient List pattern.
 class ToBuilder<E extends Exchange>
           
 class ValueBuilder<E extends Exchange>
          A builder of expressions or predicates based on values.
 

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

Method parameters in org.apache.camel.builder with type arguments of type Exchange
 ResequencerBuilder FromBuilder.resequencer(Expression<Exchange> expression)
          A builder for the Resequencer pattern where an expression is evaluated to be able to compare the message exchanges to reorder them.
 ResequencerBuilder FromBuilder.resequencer(List<Expression<Exchange>> expressions)
          A builder for the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them.
 

Constructor parameters in org.apache.camel.builder with type arguments of type Exchange
ResequencerBuilder(FromBuilder builder, List<Expression<Exchange>> expressions)
           
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Classes in org.apache.camel.component.pojo that implement Exchange
 class PojoExchange
           
 

Methods in org.apache.camel.component.pojo that return Exchange
 Exchange PojoExchange.newInstance()
           
 

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

Methods in org.apache.camel.component.processor that return Exchange
 Exchange ProcessorEndpoint.createExchange()
           
 

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

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

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

Classes in org.apache.camel.component.queue with type parameters of type Exchange
 class QueueComponent<E extends Exchange>
          Represents the component that manages QueueEndpoint.
 class QueueEndpoint<E extends Exchange>
          Represents a queue endpoint that uses a BlockingQueue object to process inbound exchanges.
 class QueueEndpointConsumer<E extends 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>
          A useful base class for Predicate implementations
 class DefaultComponent<E extends Exchange>
           
 class DefaultComponentResolver<E extends Exchange>
          The default implementation of ComponentResolver which tries to find components by using the URI scheme prefix and searching for a file of the URI scheme name in the META-INF/services/org/apache/camel/component/ directory on the classpath.
 class DefaultConsumer<E extends Exchange>
           
 class DefaultEndpoint<E extends Exchange>
          A default endpoint useful for implementation inheritance
 class DefaultPollingConsumer<E extends Exchange>
          A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
 class DefaultProducer<E extends Exchange>
          A default implementation of @{link Producer} for implementation inheritence
 class EventDrivenConsumerRoute<E extends Exchange>
          A Route which starts with an Event Driven Consumer
 class PollingConsumerRoute<E extends Exchange>
          A Route which starts with a Polling Consumer
 class PollingConsumerSupport<E extends Exchange>
          A useful base class for implementations of PollingConsumer
 class PredicateSupport<E extends Exchange>
          A useful base class for Predicate implementations
 class ScheduledPollConsumer<E extends Exchange>
          A useful base class for any consumer which is polling based
 class ScheduledPollEndpoint<E extends Exchange>
          A base class for Endpoint which creates a ScheduledPollConsumer
 

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

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

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 DefaultPollingConsumer.process(Exchange exchange)
           
 void MessageSupport.setExchange(Exchange exchange)
           
 E DefaultEndpoint.toExchangeType(Exchange exchange)
           
 

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<Producer>
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
          A helper method to convert a list of endpoints into a list of processors
 

Methods in org.apache.camel.processor that return Exchange
protected  Exchange Pipeline.copyExchangeStrategy(Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange MulticastProcessor.copyExchangeStrategy(Producer producer, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange Pipeline.createNextExchange(Producer producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
 

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

Methods in org.apache.camel.processor with parameters of type Exchange
protected  Exchange Pipeline.copyExchangeStrategy(Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange MulticastProcessor.copyExchangeStrategy(Producer producer, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange Pipeline.createNextExchange(Producer producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
protected  int DeadLetterChannel.incrementRedeliveryCounter(Exchange exchange)
          Increments the redelivery counter and adds the redelivered flag if the message has been redelivered
protected  void LoggingErrorHandler.logError(Exchange exchange, RuntimeException e)
           
protected  Object Logger.logMessage(Exchange exchange)
           
protected  Object LoggingErrorHandler.logMessage(Exchange exchange, RuntimeException e)
           
 void Splitter.process(Exchange exchange)
           
 void SendProcessor.process(Exchange exchange)
           
 void RecipientList.process(Exchange exchange)
           
 void Pipeline.process(Exchange exchange)
           
 void MulticastProcessor.process(Exchange exchange)
           
 void LoggingErrorHandler.process(Exchange exchange)
           
 void Logger.process(Exchange exchange)
           
 void FilterProcessor.process(Exchange exchange)
           
 void DelegateProcessor.process(Exchange exchange)
           
 void DeadLetterChannel.process(Exchange exchange)
           
 void CompositeProcessor.process(Exchange exchange)
           
 void ChoiceProcessor.process(Exchange exchange)
           
protected  void DelegateProcessor.processNext(Exchange exchange)
           
protected  Endpoint<Exchange> RecipientList.resolveEndpoint(Exchange exchange, Object recipient)
           
 

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)
           
protected static Set<Exchange> Resequencer.createSet(List<Expression<Exchange>> expressions)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Exchange
FilterProcessor(Predicate<Exchange> predicate, Processor processor)
           
RecipientList(Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, List<Expression<Exchange>> expressions)
           
Resequencer(Endpoint endpoint, Processor processor, Set<Exchange> set)
           
 

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

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

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

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

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

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

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

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

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

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

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

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

Uses of Exchange in org.apache.camel.util
 

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

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



Copyright © 2007 Apache Software Foundation. All Rights Reserved.