Uses of Interface
org.apache.camel.Expression

Packages that use Expression

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.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.bean	Camel Bean language.
org.apache.camel.language.constant	Camel Constant language.
org.apache.camel.language.header	Camel Header language.
org.apache.camel.language.property	Camel Property language.
org.apache.camel.language.simple	Camel Simple language.
org.apache.camel.language.tokenizer
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

Methods in org.apache.camel that return Expression

Expression

ExpressionEvaluationException.getExpression()

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

ExpressionEvaluationException(Expression expression, Exchange exchange, Throwable cause)

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 A builder of expressions or predicates based on values.

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

static Expression	ExpressionBuilder.append(Expression left, Expression right) Appends the String evaluations of the two expressions together
protected Expression	ValueBuilder.asExpression(Object value)
static Expression	ExpressionBuilder.beanExpression(Class<?> beanType, String methodName)
static Expression	ExpressionBuilder.beanExpression(String expression)
static Expression	ExpressionBuilder.beanExpression(String beanRef, String methodName)
static Expression	ExpressionBuilder.bodyExpression() Returns the expression for the exchanges inbound message body
static <T> Expression	ExpressionBuilder.bodyExpression(Class<T> type) Returns the expression for the exchanges inbound message body converted to the given type
static Expression	ExpressionBuilder.bodyTypeExpression() Returns the expression for the exchanges inbound message body type
static Expression	ExpressionBuilder.camelContextExpression() Returns an expression for the CamelContext
static Expression	ExpressionBuilder.camelContextPropertiesExpression() Returns an expression for the properties of the camel context
static Expression	ExpressionBuilder.camelContextPropertyExpression(String propertyName) Returns an expression for the property value of the camel context with the given name
static Expression	ExpressionBuilder.concatExpression(Collection<Expression> expressions) Returns an expression which returns the string concatenation value of the various expressions
static Expression	ExpressionBuilder.concatExpression(Collection<Expression> expressions, String expression) Returns an expression which returns the string concatenation value of the various expressions
static Expression	ExpressionBuilder.constantExpression(Object value) Returns an expression for the constant value
static Expression	ExpressionBuilder.convertToExpression(Expression expression, Class type) Returns an expression which converts the given expression to the given type
static Expression	ExpressionBuilder.convertToExpression(Expression expression, Expression type) Returns an expression which converts the given expression to the given type the type expression is evaluted to
static Expression	FileExpressionBuilder.dateExpression(String command, String pattern)
static Expression	ExpressionBuilder.dateExpression(String command, String pattern)
static Expression	ExpressionBuilder.exchangeExceptionExpression() Returns an expression for an exception set on the exchange
static Expression	ExpressionBuilder.exchangeExceptionExpression(Class<Exception> type) Returns an expression for an exception set on the exchange Is used to get the caused exception that typically have been wrapped in some sort of Camel wrapper exception
static Expression	ExpressionBuilder.exchangeExceptionMessageExpression() Returns an expression for an exception message set on the exchange
static Expression	ExpressionBuilder.exchangeExpression() Returns the expression for the exchange
static Expression	ExpressionBuilder.faultBodyExpression() Returns the expression for the fault messages body
static <T> Expression	ExpressionBuilder.faultBodyExpression(Class<T> type) Returns the expression for the exchanges fault message body converted to the given type
static Expression	FileExpressionBuilder.fileAbsoluteExpression()
static Expression	FileExpressionBuilder.fileAbsolutePathExpression()
static Expression	FileExpressionBuilder.fileExtensionExpression()
static Expression	FileExpressionBuilder.fileLastModifiedExpression()
static Expression	FileExpressionBuilder.fileNameExpression()
static Expression	FileExpressionBuilder.fileNameNoExtensionExpression()
static Expression	FileExpressionBuilder.fileOnlyNameExpression()
static Expression	FileExpressionBuilder.fileOnlyNameNoExtensionExpression()
static Expression	FileExpressionBuilder.fileParentExpression()
static Expression	FileExpressionBuilder.filePathExpression()
static Expression	FileExpressionBuilder.fileSizeExpression()
Expression	ValueBuilder.getExpression()
static Expression	ExpressionBuilder.headerExpression(String headerName) Returns an expression for the header value with the given name Will fallback and look in properties if not found in headers.
static Expression	ExpressionBuilder.headersExpression() Returns an expression for the inbound message headers
static Expression	ExpressionBuilder.inMessageExpression() Returns the expression for the IN message
static <T> Expression	ExpressionBuilder.mandatoryBodyExpression(Class<T> type) Returns the expression for the exchanges inbound message body converted to the given type.
static <T> Expression	ExpressionBuilder.mandatoryBodyExpression(Class<T> type, boolean nullBodyAllowed) Returns the expression for the exchanges inbound message body converted to the given type
static Expression	ExpressionBuilder.messageIdExpression() Returns an Expression for the inbound message id
static Expression	ExpressionBuilder.outBodyExpression() Returns the expression for the out messages body
static <T> Expression	ExpressionBuilder.outBodyExpression(Class<T> type) Returns the expression for the exchanges outbound message body converted to the given type
static Expression	ExpressionBuilder.outHeaderExpression(String headerName) Returns an expression for the out header value with the given name Will fallback and look in properties if not found in headers.
static Expression	ExpressionBuilder.outHeadersExpression() Returns an expression for the outbound message headers
static Expression	ExpressionBuilder.outMessageExpression() Returns the expression for the OUT message
static Expression	ExpressionBuilder.prepend(Expression left, Expression right) Prepends the String evaluations of the two expressions together
static Expression	ExpressionBuilder.propertiesExpression() Returns an expression for the properties of exchange
static Expression	ExpressionBuilder.propertyExpression(String propertyName) Returns an expression for the property value of exchange with the given name
static Expression	ExpressionBuilder.regexReplaceAll(Expression expression, String regex, Expression replacementExpression) Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static Expression	ExpressionBuilder.regexReplaceAll(Expression 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 Expression	ExpressionBuilder.regexTokenizeExpression(Expression expression, String regexTokenizer) Returns a tokenize expression which will tokenize the string with the given regex
static Expression	ExpressionBuilder.registryExpression() Returns an expression for the Registry
static Expression	FileExpressionBuilder.simpleExpression(String expression)
static Expression	ExpressionBuilder.simpleExpression(String expression)
static Expression	ExpressionBuilder.sortExpression(Expression expression, Comparator comparator) Returns a sort expression which will sort the expression with the given comparator.
static Expression	ExpressionBuilder.systemPropertyExpression(String propertyName) Returns an expression for a system property value with the given name
static Expression	ExpressionBuilder.systemPropertyExpression(String propertyName, String defaultValue) Returns an expression for a system property value with the given name
static Expression	ExpressionBuilder.toExpression(String uri) Returns an expression processing the exchange to the given endpoint uri
static Expression	ExpressionBuilder.tokenizeExpression(Expression expression, String token) Returns a tokenize expression which will tokenize the string with the given token
static Expression	ExpressionBuilder.typeConverterExpression() Returns an expression for the type converter

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

static Expression	ExpressionBuilder.append(Expression left, Expression right) Appends the String evaluations of the two expressions together
static Predicate	PredicateBuilder.contains(Expression left, Expression right)
static Expression	ExpressionBuilder.convertToExpression(Expression expression, Class type) Returns an expression which converts the given expression to the given type
static Expression	ExpressionBuilder.convertToExpression(Expression expression, Expression type) Returns an expression which converts the given expression to the given type the type expression is evaluted to
static Predicate	PredicateBuilder.endsWith(Expression left, Expression right)
T	ExpressionClause.expression(Expression expression) Specify an Expression instance
DefaultErrorHandlerBuilder	DefaultErrorHandlerBuilder.handled(Expression handled) Sets whether the exchange should be marked as handled or not.
static Predicate	PredicateBuilder.isEqualTo(Expression left, Expression right)
static Predicate	PredicateBuilder.isGreaterThan(Expression left, Expression right)
static Predicate	PredicateBuilder.isGreaterThanOrEqualTo(Expression left, Expression right)
static Predicate	PredicateBuilder.isInstanceOf(Expression expression, Class<?> type)
static Predicate	PredicateBuilder.isLessThan(Expression left, Expression right)
static Predicate	PredicateBuilder.isLessThanOrEqualTo(Expression left, Expression right)
static Predicate	PredicateBuilder.isNotEqualTo(Expression left, Expression right)
static Predicate	PredicateBuilder.isNotNull(Expression expression)
static Predicate	PredicateBuilder.isNull(Expression expression)
Predicate	ValueBuilder.matches(Expression expression)
static Expression	ExpressionBuilder.prepend(Expression left, Expression right) Prepends the String evaluations of the two expressions together
static Predicate	PredicateBuilder.regex(Expression expression, Pattern pattern) Returns a predicate which is true if the expression matches the given regular expression
static Predicate	PredicateBuilder.regex(Expression expression, String regex) Returns a predicate which is true if the expression matches the given regular expression
static Expression	ExpressionBuilder.regexReplaceAll(Expression expression, String regex, Expression replacementExpression) 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
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 Expression	ExpressionBuilder.regexReplaceAll(Expression 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, 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	ValueBuilder.regexReplaceAll(String regex, Expression replacement) Replaces all occurrences of the regular expression with the given replacement
static Expression	ExpressionBuilder.regexTokenizeExpression(Expression 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
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 Expression	ExpressionBuilder.sortExpression(Expression expression, Comparator comparator) Returns a sort expression which will sort the expression with the given comparator.
static Predicate	PredicateBuilder.startsWith(Expression left, Expression right)
static Expression	ExpressionBuilder.tokenizeExpression(Expression expression, String token) Returns a tokenize expression which will tokenize the string with the given token
static Predicate	PredicateBuilder.toPredicate(Expression expression) Converts the given expression into an Predicate

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

static Expression	ExpressionBuilder.concatExpression(Collection<Expression> expressions) Returns an expression which returns the string concatenation value of the various expressions
static Expression	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 left, Expression right)

ValueBuilder(Expression expression)

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

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

class

XPathBuilder 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	BeanAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)
Expression	AnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)
protected Expression	MethodInfo.createParametersExpression()
Expression	ParameterMappingStrategy.getDefaultParameterTypeExpression(Class<?> parameterType) Gets an expression used for evaluation with the current Exchange and its result is used as parameter value for the given type
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

Fields in org.apache.camel.component.file declared as Expression

protected Expression	GenericFileEndpoint.fileName
protected Expression	GenericFileEndpoint.move
protected Expression	GenericFileEndpoint.moveFailed
protected Expression	GenericFileEndpoint.preMove
protected Expression	GenericFileEndpoint.tempFileName

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

Expression	GenericFileEndpoint.getFileName()
Expression	GenericFileEndpoint.getMove()
Expression	GenericFileEndpoint.getMoveFailed()
Expression	GenericFileEndpoint.getPreMove()
Expression	GenericFileEndpoint.getTempFileName()

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

void	GenericFileEndpoint.setFileName(Expression fileName)
void	GenericFileEndpoint.setMove(Expression move)
void	GenericFileEndpoint.setMoveFailed(Expression moveFailed)
void	GenericFileEndpoint.setPreMove(Expression preMove)
void	GenericFileEndpoint.setTempFileName(Expression tempFileName)

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

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

Expression

GenericFileExpressionRenamer.getExpression()

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

void	GenericFileExpressionRenamer.setExpression(Expression expression)

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

GenericFileExpressionRenamer(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 expression) Asserts that the messages have ascending values of the given expression
void	MockEndpoint.assertMessagesDescending(Expression expression) Asserts that the messages have descending values of the given expression
protected void	MockEndpoint.assertMessagesSorted(Expression expression, boolean ascending)
void	MockEndpoint.assertNoDuplicates(Expression expression)
void	MockEndpoint.expectsAscending(Expression 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 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 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 expression)

Uses of Expression in org.apache.camel.converter

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

Processor

CamelConverter.toProcessor(Expression expresion)

Uses of Expression in org.apache.camel.impl

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

class	ExpressionAdapter A helper class for developers wishing to implement an Expression using Java code with a minimum amount of code to write so that the developer only needs to implement one of the ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) or ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) methods.
class	ExpressionSupport A useful base class for Predicate and Expression implementations

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

DefaultRouteNode(ProcessorDefinition<?> processorDefinition, Expression expression)

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

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

class

BeanExpression 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	BeanLanguage.createExpression(Object bean, String method)
Expression	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	ConstantLanguage.constant(Object value)
Expression	ConstantLanguage.createExpression(String expression)

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

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

Expression	HeaderLanguage.createExpression(String expression)
static Expression	HeaderLanguage.header(String headerName)

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

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

Expression	PropertyLanguage.createExpression(String expression)
static Expression	PropertyLanguage.property(String propertyName)

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

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

protected Expression	SimpleLanguageSupport.createComplexConcatExpression(String expression)
protected Expression	SimpleLanguageSupport.createConstantExpression(String expression)
protected Expression	SimpleLanguageSupport.createConstantExpression(String expression, int start, int end)
Expression	SimpleLanguageSupport.createExpression(String expression)
protected abstract Expression	SimpleLanguageSupport.createSimpleExpression(String expression, boolean strict) Creates the simple expression based on the extracted content from the ${ } place holders
protected Expression	SimpleLanguage.createSimpleExpression(String expression, boolean strict)
protected Expression	FileLanguage.createSimpleExpression(String expression, boolean strict)
protected Expression	SimpleLanguageSupport.createSimpleOrConstantExpression(String text)
static Expression	FileLanguage.file(String expression)
static Expression	SimpleLanguage.simple(String expression)

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

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

Expression	TokenizeLanguage.createExpression() Creates a tokenize expression.
Expression	TokenizeLanguage.createExpression(String expression)
static Expression	TokenizeLanguage.tokenize(String token)
static Expression	TokenizeLanguage.tokenize(String token, boolean regex)
static Expression	TokenizeLanguage.tokenize(String headerName, String token)
static Expression	TokenizeLanguage.tokenize(String headerName, String token, boolean regex)

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

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

Expression

XPathLanguage.createExpression(String expression)

Uses of Expression in org.apache.camel.model

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

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

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

List<Expression>

ResequenceDefinition.getExpressionList()

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

AggregateDefinition	ProcessorDefinition.aggregate(Expression correlationExpression) Aggregator EIP: Creates an aggregator allowing you to combine a number of messages together into a single message.
AggregateDefinition	ProcessorDefinition.aggregate(Expression correlationExpression, AggregationStrategy aggregationStrategy) Aggregator EIP: Creates an aggregator allowing you to combine a number of messages together into a single message.
DelayDefinition	ProcessorDefinition.delay(Expression delay) Delayer EIP: Creates a delayer allowing you to delay the delivery of messages to some destination.
TryDefinition	TryDefinition.handled(Expression handled) Sets whether the exchange should be marked as handled or not.
OnExceptionDefinition	OnExceptionDefinition.handled(Expression handled) Sets whether the exchange should be marked as handled or not.
CatchDefinition	CatchDefinition.handled(Expression handled) Sets whether the exchange should be marked as handled or not.
IdempotentConsumerDefinition	ProcessorDefinition.idempotentConsumer(Expression messageIdExpression, IdempotentRepository<?> idempotentRepository) Idempotent consumer EIP: Creates an IdempotentConsumer to avoid duplicate messages
LoopDefinition	ProcessorDefinition.loop(Expression expression) Loop EIP: Creates a loop allowing to process the a message a number of times and possibly process them in a different way.
Type	ProcessorDefinition.recipientList(Expression recipients) Recipient List EIP: Creates a dynamic recipient list allowing you to route messages to a number of dynamically specified recipients.
Type	ProcessorDefinition.recipientList(Expression recipients, String delimiter) Recipient List EIP: Creates a dynamic recipient list allowing you to route messages to a number of dynamically specified recipients
ResequenceDefinition	ProcessorDefinition.resequence(Expression expression) Resequencer EIP: Creates a resequencer allowing you to reorganize messages based on some comparator.
ResequenceDefinition	ProcessorDefinition.resequencer(Expression... expressions) Resequencer EIP: Creates a splitter allowing you to reorganise messages based on some comparator.
OnExceptionDefinition	OnExceptionDefinition.retryUntil(Expression until) Sets the retry until expression.
Type	ProcessorDefinition.setBody(Expression expression) Message Translator EIP: Adds a processor which sets the body on the IN message
void	SortDefinition.setExpression(Expression expression)
void	LoopDefinition.setExpression(Expression expr)
void	ExpressionSubElementDefinition.setExpression(Expression expression)
Type	ProcessorDefinition.setFaultBody(Expression expression) Adds a processor which sets the body on the FAULT message
Type	ProcessorDefinition.setFaultHeader(String name, Expression expression) Adds a processor which sets the header on the FAULT message
Type	ProcessorDefinition.setHeader(String name, Expression expression) Adds a processor which sets the header on the IN message
void	WireTapDefinition.setNewExchangeExpression(Expression expression)
Type	ProcessorDefinition.setOutHeader(String name, Expression expression) Adds a processor which sets the header on the OUT message
Type	ProcessorDefinition.setProperty(String name, Expression expression) Adds a processor which sets the exchange property
Type	ProcessorDefinition.sort(Expression expression) Sorts the expression using a default sorting based on toString representation.
Type	ProcessorDefinition.sort(Expression expression, Comparator comparator) Sorts the expression using the given comparator
SplitDefinition	ProcessorDefinition.split(Expression expression) Splitter EIP: Creates a splitter allowing you split a message into a number of pieces and process them individually.
SplitDefinition	ProcessorDefinition.split(Expression expression, AggregationStrategy aggregationStrategy) Splitter EIP: Creates a splitter allowing you split a message into a number of pieces and process them individually.
LoadBalanceDefinition	LoadBalanceDefinition.sticky(Expression correlationExpression) Uses sticky load balancer
Type	ProcessorDefinition.transform(Expression expression) Message Translator EIP: Adds a processor which sets the body on the OUT message
Type	ProcessorDefinition.wireTap(String uri, Expression body) WireTap EIP: Sends a new Exchange to the destination using ExchangePattern.InOnly.

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

ResequenceDefinition

ProcessorDefinition.resequence(List<Expression> expressions) Resequencer EIP: Creates a resequencer allowing you to reorganize messages based on some comparator.

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

AggregateDefinition(Expression correlationExpression)

AggregateDefinition(Expression correlationExpression, AggregationStrategy aggregationStrategy)

DelayDefinition(Expression delay)

ExpressionNode(Expression expression)

ExpressionSubElementDefinition(Expression expression)

IdempotentConsumerDefinition(Expression messageIdExpression, IdempotentRepository<?> idempotentRepository)

LoopDefinition(Expression expression)

RecipientListDefinition(Expression expression)

SetBodyDefinition(Expression expression)

SetHeaderDefinition(String headerName, Expression expression)

SetOutHeaderDefinition(String headerName, Expression expression)

SetPropertyDefinition(String propertyName, Expression expression)

SortDefinition(Expression expression)

SortDefinition(Expression expression, Comparator<Object> comparator)

SplitDefinition(Expression expression)

TransformDefinition(Expression expression)

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

ResequenceDefinition(List<Expression> expressions)

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

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

class	ConstantExpression For expressions and predicates using a constant
class	ELExpression For EL expressions and predicates
class	ExpressionDefinition 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	MvelExpression For MVEL expressions and predicates
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	PropertyExpression An expression which extracts the named exchange property
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	TokenizerExpression For expressions and predicates using a body or header tokenzier
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	TokenizerExpression.createExpression(RouteContext routeContext)
Expression	MethodCallExpression.createExpression(RouteContext routeContext)
Expression	ExpressionDefinition.createExpression(RouteContext routeContext)
Expression	ExpressionDefinition.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	ExpressionDefinition.configureExpression(RouteContext routeContext, Expression expression)
protected void	ExpressionDefinition.setExpressionValue(Expression expressionValue)

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

ExpressionDefinition(Expression expression)

Uses of Expression in org.apache.camel.processor

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

Expression	Delayer.getDelay()
Expression	Splitter.getExpression()
Expression	LoopProcessor.getExpression()
Expression	WireTapProcessor.getNewExchangeExpression()

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

protected static Set<Exchange>	Resequencer.createSet(Expression expression)
void	Delayer.setDelay(Expression delay)
void	WireTapProcessor.setNewExchangeExpression(Expression newExchangeExpression)

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

LoopProcessor(Expression expression, Processor processor)

RecipientList(Expression expression)

RecipientList(Expression expression, String delimiter)

Resequencer(Processor processor, Expression expression)

SetBodyProcessor(Expression expression)

SetBodyProcessor(Expression expression, Processor childProcessor)

SortProcessor(Expression expression, Comparator<Object> comparator)

Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy)

Splitter(Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean streaming, boolean stopOnException)

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	DefaultAggregationCollection.getCorrelationExpression()
Expression	AggregationCollection.getCorrelationExpression() Gets the correlation expression

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

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

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

DefaultAggregationCollection(Expression correlationExpression, AggregationStrategy aggregationStrategy)

PredicateAggregationCollection(Expression 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	IdempotentConsumer.getMessageIdExpression()

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

IdempotentConsumer(Expression messageIdExpression, IdempotentRepository<String> idempotentRepository, boolean eager, Processor processor)

NoMessageIdException(Exchange exchange, Expression expression)

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

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

Expression

StickyLoadBalancer.getCorrelationExpression()

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

StickyLoadBalancer(Expression correlationExpression)

StickyLoadBalancer(Expression correlationExpression, QueueLoadBalancer loadBalancer)

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

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

Expression

DefaultExchangeComparator.getExpression()

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

void	DefaultExchangeComparator.setExpression(Expression 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

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

Uses of Expression in org.apache.camel.util

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

ExpressionComparator(Expression expression)

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

ExpressionListComparator(List<Expression> expressions)