Uses of Interface
org.apache.camel.Expression

Packages that use Expression

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.file	The File Component for working with file systems.
org.apache.camel.component.file.strategy	Strategies for the File Component.
org.apache.camel.component.mock	The Mock Component which is used for testing of routing and mediation rules.
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.impl	Default implementation classes for Camel Core
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.model	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.model.language	The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration.
org.apache.camel.processor	A collection of Processor implementations which are used to implement the Enterprise Integration Patterns
org.apache.camel.processor.aggregate	Helper classes for the Aggregator pattern.
org.apache.camel.processor.idempotent	An implementation of the Idempotent Consumer pattern.
org.apache.camel.processor.loadbalancer	Various load balancer processors
org.apache.camel.processor.resequencer	Helper classes for the Resequencer pattern.
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 Expression in org.apache.camel.builder

Classes in org.apache.camel.builder that implement Expression

class	ExpressionClause<T> Represents an expression clause within the DSL which when the expression is complete the clause continues to another part of the DSL
class	ValueBuilder<E extends Exchange> A builder of expressions or predicates based on values.

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

static <E extends Exchange> Expression<E>	ExpressionBuilder.append(Expression<E> left, Expression<E> right) Appends the String evaluations of the two expressions together
protected Expression<E>	ValueBuilder.asExpression(Object value)
static <E extends Exchange> Expression<E>	ExpressionBuilder.beanExpression(String bean)
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> Expression<E>	ExpressionBuilder.constantExpression(Object value) Returns an expression for the constant value
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> Expression<E>	ExpressionBuilder.exchangeExpression() Returns the expression for the exchange
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
Expression	DeadLetterChannelBuilder.getDefaultDeadLetterEndpointExpression()
Expression<E>	ValueBuilder.getExpression()
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> Expression<E>	ExpressionBuilder.messageIdExpression() Returns an Expression for the inbound message id
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> 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> Expression<E>	ExpressionBuilder.systemProperty(String name, String defaultValue) Returns an expression for the given system property
static <E extends Exchange> Expression<E>	ExpressionBuilder.systemPropertyExpression(String propertyName) Returns an expression for a system property value with the given name
static <E extends Exchange> Expression<E>	ExpressionBuilder.systemPropertyExpression(String propertyName, String defaultValue) Returns an expression for a system property value with the given name
static <E extends Exchange> Expression<E>	ExpressionBuilder.tokenizeExpression(Expression<E> expression, String token) Returns a tokenize expression which will tokenize the string with the given token

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

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.append(Expression<E> left, Expression<E> right) Appends the String evaluations of the two expressions together
static <E extends Exchange> Predicate<E>	PredicateBuilder.contains(Expression<E> left, Expression<E> right)
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
T	ExpressionClause.expression(Expression expression) Specify an Expression instance
static <E extends Exchange> Predicate<E>	PredicateBuilder.isEqualTo(Expression<E> left, Expression<E> right)
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.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.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.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.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.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.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, 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
ValueBuilder	BuilderSupport.regexReplaceAll(Expression content, String regex, Expression replacement) Returns an expression value builder that replaces all occurrences of the regular expression with the given replacement
ValueBuilder	BuilderSupport.regexReplaceAll(Expression content, String regex, Expression replacement) Returns an expression value builder that replaces all occurrences of the regular expression with the given replacement
static ValueBuilder	Builder.regexReplaceAll(Expression content, String regex, Expression replacement) Returns an expression that replaces all occurrences of the regular expression with the given replacement
static ValueBuilder	Builder.regexReplaceAll(Expression content, String regex, Expression replacement) Returns an expression that replaces all occurrences of the regular expression with the given replacement
ValueBuilder	BuilderSupport.regexReplaceAll(Expression content, String regex, String replacement) Returns an expression value builder that replaces all occurrences of the regular expression with the given replacement
static ValueBuilder	Builder.regexReplaceAll(Expression content, String regex, String replacement) Returns an expression that replaces all occurrences of the regular expression with the given replacement
ValueBuilder<E>	ValueBuilder.regexReplaceAll(String regex, Expression<E> replacement) Replaces all occurrences of the regular expression with the given replacement
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 Processor	ProcessorBuilder.setBody(Expression expression) Creates a processor which sets the body of the IN message to the value of the expression
void	DeadLetterChannelBuilder.setDefaultDeadLetterEndpointExpression(Expression defaultDeadLetterEndpointExpression) Sets the expression used to decide the dead letter channel endpoint for an exchange if no factory is provided via DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
static Processor	ProcessorBuilder.setFaultBody(Expression expression) Creates a processor which sets the body of the FAULT message to the value of the expression
static Processor	ProcessorBuilder.setFaultHeader(String name, Expression expression) Sets the header on the FAULT message
static Processor	ProcessorBuilder.setHeader(String name, Expression expression) Sets the header on the IN message
static Processor	ProcessorBuilder.setOutBody(Expression expression) Creates a processor which sets the body of the OUT message to the value of the expression
static Processor	ProcessorBuilder.setOutHeader(String name, Expression expression) Sets the header on the OUT message
static Processor	ProcessorBuilder.setProperty(String name, Expression expression) Sets the property on the exchange
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

Method parameters in org.apache.camel.builder with type arguments of type Expression

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

Constructors in org.apache.camel.builder with parameters of type Expression

BinaryPredicateSupport(Expression<E> left, Expression<E> right)

BinaryPredicateSupport(Expression<E> left, Expression<E> right)

ValueBuilder(Expression<E> expression)

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

Classes in org.apache.camel.builder.xml that implement Expression

class

XPathBuilder<E extends Exchange> Creates an XPath expression builder which creates a nodeset result by default.

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

Methods in org.apache.camel.component.bean that return Expression

Expression	XPathAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class expressionReturnType)
Expression	DefaultAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class expressionReturnType)
Expression	AnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class expressionReturnType)
protected Expression	MethodInfo.createParametersExpression()
protected Expression	BeanInfo.createParameterUnmarshalExpression(Class clazz, Method method, Class parameterType, Annotation[] parameterAnnotation) Creates an expression for the given parameter type if the parameter can be mapped automatically or null if the parameter cannot be mapped due to unsufficient annotations or not fitting with the default type conventions.
protected Expression	BeanInfo.createParameterUnmarshalExpressionForAnnotation(Class clazz, Method method, Class parameterType, Annotation annotation)
Expression	ParameterMappingStrategy.getDefaultParameterTypeExpression(Class parameterType)
Expression	DefaultParameterMappingStrategy.getDefaultParameterTypeExpression(Class parameterType)
Expression	ParameterInfo.getExpression()
Expression	MethodInfo.getParametersExpression()

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

void	DefaultParameterMappingStrategy.addParameterMapping(Class parameterType, Expression expression) Adds a default parameter type mapping to an expression
void	ParameterInfo.setExpression(Expression expression)

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

ParameterInfo(int index, Class type, Annotation[] annotations, Expression expression)

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

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

Expression	FileEndpoint.getExpression()
Expression	FileEndpoint.getPreMoveExpression()

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

void	FileEndpoint.setExpression(Expression expression)
void	FileEndpoint.setPreMoveExpression(Expression expression)

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

Methods in org.apache.camel.component.file.strategy that return Expression

Expression

FileExpressionRenamer.getExpression()

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

void	FileExpressionRenamer.setExpression(Expression expression)

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

Classes in org.apache.camel.component.mock that implement Expression

class

AssertionClause.PredicateValueBuilder Public class needed for fluent builders

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

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

Constructors in org.apache.camel.component.mock with parameters of type Expression

AssertionClause.PredicateValueBuilder(Expression<Exchange> expression)

Uses of Expression in org.apache.camel.converter

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

Processor

CamelConverter.toProcessor(Expression<Exchange> expresion)

Uses of Expression in org.apache.camel.impl

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

class

ExpressionSupport<E extends Exchange> A useful base class for Predicate and Expression implementations

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

BinaryPredicateSupport(Expression<E> left, Expression<E> right)
Deprecated.

BinaryPredicateSupport(Expression<E> left, Expression<E> right)
Deprecated.

Uses of Expression in org.apache.camel.language

Methods in org.apache.camel.language that return Expression

Expression<Exchange>

ExpressionEvaluationException.getExpression()

Constructors in org.apache.camel.language with parameters of type Expression

ExpressionEvaluationException(Expression<Exchange> expression, Exchange exchange, Throwable cause)

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

Classes in org.apache.camel.language.bean that implement Expression

class

BeanExpression<E extends Exchange> Evaluates an expression using a bean method invocation

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

static Expression	BeanLanguage.bean(Class beanType, String method) Creates the expression for invoking the bean type.
static Expression	BeanLanguage.bean(Object bean, String method) Creates the expression for invoking the bean type.
static Expression	BeanLanguage.bean(String expression) Creates the expression based on the string syntax.
Expression<Exchange>	BeanLanguage.createExpression(Object bean, String method)
Expression<Exchange>	BeanLanguage.createExpression(String expression)

Uses of Expression in org.apache.camel.language.constant

Methods in org.apache.camel.language.constant that return Expression

static Expression<Exchange>	ConstantLanguage.constant(Object value)
Expression<Exchange>	ConstantLanguage.createExpression(String expression)

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

Methods in org.apache.camel.language.header that return Expression

Expression<Exchange>	HeaderLanguage.createExpression(String expression)
static Expression<Exchange>	HeaderLanguage.header(String headerName)

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

Methods in org.apache.camel.language.simple that return Expression

protected Expression<Exchange>	AbstractSimpleLanguage.createComplexExpression(String expression)
protected Expression	AbstractSimpleLanguage.createConstantExpression(String expression, int start, int end)
Expression<Exchange>	AbstractSimpleLanguage.createExpression(String expression)
protected Expression<Exchange>	SimpleLanguage.createSimpleExpression(String expression)
protected Expression<FileExchange>	FileLanguage.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
static <E extends Exchange> Expression<E>	FileExpressionBuilder.dateExpression(String command, String pattern)
static Expression	FileLanguage.file(String expression)
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 Expression	SimpleLanguage.simple(String expression)
static <E extends Exchange> Expression<E>	FileExpressionBuilder.simpleExpression(String simple)

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

Methods in org.apache.camel.language.xpath that return Expression

Expression<Exchange>

XPathLanguage.createExpression(String expression)

Uses of Expression in org.apache.camel.model

Methods in org.apache.camel.model that return Expression

Expression	ExpressionSubElementType.createExpression(RouteContext routeContext)
Expression	ExpressionSubElementType.getExpression()

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

AggregatorType	ProcessorType.aggregator(Expression correlationExpression) Creates an Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.
AggregatorType	ProcessorType.aggregator(Expression correlationExpression, AggregationStrategy aggregationStrategy) Creates an Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.
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
ExceptionType	ExceptionType.handled(Expression handled)
IdempotentConsumerType	ProcessorType.idempotentConsumer(Expression messageIdExpression, MessageIdRepository messageIdRepository) Creates an IdempotentConsumer to avoid duplicate messages
LoopType	ProcessorType.loop(Expression<?> expression)
Type	ProcessorType.recipientList(Expression recipients) Creates a dynamic Recipient List pattern.
ResequencerType	ProcessorType.resequencer(Expression... expressions) Creates the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them.
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.
Type	ProcessorType.setBody(Expression expression) Adds a processor which sets the body on the IN message
void	ExpressionSubElementType.setExpression(Expression expression)
void	LoopType.setExpression(Expression<?> expr)
Type	ProcessorType.setFaultBody(Expression expression) Adds a processor which sets the body on the FAULT message
Type	ProcessorType.setFaultHeader(String name, Expression expression) Adds a processor which sets the header on the FAULT message
Type	ProcessorType.setHeader(String name, Expression expression) Adds a processor which sets the header on the IN message
Type	ProcessorType.setOutBody(Expression expression) Deprecated. Please use ProcessorType.transform(Expression) instead. Will be removed in Camel 2.0.
Type	ProcessorType.setOutHeader(String name, Expression expression) Adds a processor which sets the header on the OUT message
Type	ProcessorType.setProperty(String name, Expression expression) Adds a processor which sets the exchange property
SplitterType	ProcessorType.splitter(Expression recipients) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
SplitterType	ProcessorType.splitter(Expression partsExpression, AggregationStrategy aggregationStrategy) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
SplitterType	ProcessorType.splitter(Expression partsExpression, AggregationStrategy aggregationStrategy, boolean parallelProcessing) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
SplitterType	ProcessorType.splitter(Expression partsExpression, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ThreadPoolExecutor threadPoolExecutor) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
SplitterType	ProcessorType.splitter(Expression recipients, boolean parallelProcessing) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
SplitterType	ProcessorType.splitter(Expression recipients, boolean parallelProcessing, ThreadPoolExecutor threadPoolExecutor) Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
LoadBalanceType	LoadBalanceType.sticky(Expression<Exchange> correlationExpression)
Type	ProcessorType.transform(Expression expression) Adds a processor which sets the body on the OUT message

Method parameters in org.apache.camel.model with type arguments of type Expression

ResequencerType

ProcessorType.resequencer(List<Expression> expressions) Creates the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them.

Constructors in org.apache.camel.model with parameters of type Expression

AggregatorType(Expression correlationExpression)

AggregatorType(Expression correlationExpression, AggregationStrategy aggregationStrategy)

DelayerType(Expression processAtExpression)

DelayerType(Expression processAtExpression, long delay)

ExpressionNode(Expression expression)

ExpressionSubElementType(Expression expression)

IdempotentConsumerType(Expression messageIdExpression, MessageIdRepository messageIdRepository)

LoopType(Expression expression)

RecipientListType(Expression expression)

SetBodyType(Expression expression)

SetHeaderType(String headerName, Expression expression)

SetOutHeaderType(String headerName, Expression expression)

SetPropertyType(String propertyName, Expression expression)

SplitterType(Expression expression)

TransformType(Expression expression)

Constructor parameters in org.apache.camel.model with type arguments of type Expression

ResequencerType(List<Expression> expressions)

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

Classes in org.apache.camel.model.language that implement Expression

class	BeanShellExpression Deprecated. use LanguageExpression will be removed in Camel 2.0
class	ConstantExpression For expressions and predicates using a constant
class	ELExpression For EL expressions and predicates
class	ExpressionType A useful base class for an expression
class	GroovyExpression For Groovy expressions and predicates
class	HeaderExpression An expression which extracts the named header
class	JavaScriptExpression For JavaScript expressions and predicates
class	JXPathExpression For JXPath expressions and predicates
class	LanguageExpression Represents a parameterised language expression which can support any language at runtime using the language attribute.
class	MethodCallExpression For expressions and predicates using the bean language
class	NamespaceAwareExpression A useful base class for any expression which may be namespace or XML content aware such as XPathExpression or XQueryExpression
class	OgnlExpression For OGNL expressions and predicates
class	PhpExpression For PHP expressions and predicates
class	PythonExpression For Python expressions and predicates
class	RubyExpression For Ruby expressions and predicates
class	SimpleExpression For expressions and predicates using the	class	SqlExpression For SQL expressions and predicates
class	XPathExpression For XPath expressions and predicates
class	XQueryExpression For XQuery expressions and predicates

Methods in org.apache.camel.model.language that return Expression

Expression	MethodCallExpression.createExpression(RouteContext routeContext)
Expression	ExpressionType.createExpression(RouteContext routeContext)
Expression	ExpressionType.getExpressionValue()

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

protected void	XQueryExpression.configureExpression(RouteContext routeContext, Expression expression)
protected void	XPathExpression.configureExpression(RouteContext routeContext, Expression expression)
protected void	NamespaceAwareExpression.configureExpression(RouteContext routeContext, Expression expression)
protected void	ExpressionType.configureExpression(RouteContext routeContext, Expression expression)
protected void	ExpressionType.setExpressionValue(Expression expressionValue)

Constructors in org.apache.camel.model.language with parameters of type Expression

ExpressionType(Expression expression)

Uses of Expression in org.apache.camel.processor

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

Expression<Exchange>

LoopProcessor.getExpression()

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

protected static Set<Exchange>

Resequencer.createSet(Expression<Exchange> expression)

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

protected static Set<Exchange>

Resequencer.createSet(List<Expression> expressions)

Constructors in org.apache.camel.processor with parameters of type Expression

Aggregator(Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy)

Aggregator(Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy, Predicate aggregationCompletedPredicate)

Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)

LoopProcessor(Expression<Exchange> expression, Processor processor)

RecipientList(Expression<Exchange> expression)

Resequencer(Processor processor, Expression expression)

Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy)

Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ThreadPoolExecutor threadPoolExecutor, boolean streaming)

TransformProcessor(Expression expression)

TransformProcessor(Expression expression, Processor childProcessor)

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

Resequencer(Processor processor, List<Expression> expressions)

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

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

Expression<Exchange>	DefaultAggregationCollection.getCorrelationExpression()
Expression<Exchange>	AggregationCollection.getCorrelationExpression() Gets the correlation expression

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

void	DefaultAggregationCollection.setCorrelationExpression(Expression<Exchange> correlationExpression)
void	AggregationCollection.setCorrelationExpression(Expression<Exchange> correlationExpression) Sets the correlation expression to be used

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

DefaultAggregationCollection(Expression<Exchange> correlationExpression, AggregationStrategy aggregationStrategy)

PredicateAggregationCollection(Expression<Exchange> correlationExpression, AggregationStrategy aggregationStrategy, Predicate aggregationCompletedPredicate)

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

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

Expression	NoMessageIdException.getExpression() The expression which was used
Expression<Exchange>	IdempotentConsumer.getMessageIdExpression()

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

IdempotentConsumer(Expression<Exchange> messageIdExpression, MessageIdRepository messageIdRepository, Processor nextProcessor)

NoMessageIdException(Exchange exchange, Expression expression)

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

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

void	StickyLoadBalancer.setCorrelationExpression(Expression<Exchange> correlationExpression)

Constructors in org.apache.camel.processor.loadbalancer with parameters of type Expression

StickyLoadBalancer(Expression<Exchange> correlationExpression)

StickyLoadBalancer(Expression<Exchange> correlationExpression, QueueLoadBalancer loadBalancer)

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

Methods in org.apache.camel.processor.resequencer that return Expression

Expression<Exchange>

DefaultExchangeComparator.getExpression()

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

void	DefaultExchangeComparator.setExpression(Expression<Exchange> expression)

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

void	ExpressionResultComparator.setExpressions(List<Expression> expressions) Sets the list expressions used for comparing Exchanges.
void	DefaultExchangeComparator.setExpressions(List<Expression> expressions)

Uses of Expression in org.apache.camel.spi

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

Expression<Exchange>

Language.createExpression(String expression) Creates an expression based on the given string input

Uses of Expression in org.apache.camel.util

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

static Expression

CamelContextHelper.resolveMandatoryExpression(CamelContext camelContext, String languageName, String expressionText) Resolves the mandatory language name and expression text into a Expression instance throwing an exception if it could not be created

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

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

Constructors in org.apache.camel.util with parameters of type Expression

ExpressionComparator(Expression<E> expression)

Constructor parameters in org.apache.camel.util with type arguments of type Expression

ExpressionListComparator(List<Expression> expressions)