Uses of Interface
org.apache.camel.Expression

Packages that use Expression

Package	Description
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.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.directvm	The Direct VM Component which synchronously invokes the consumer when a producer sends an exchange to the endpoint.
org.apache.camel.component.file	The File Component for working with file systems.
org.apache.camel.component.file.strategy	Strategies for the File Component.
org.apache.camel.component.language	The Language Component to send messages to language endpoints executing the script.
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.impl.cloud	Base classes and implementation for Camel Cloud
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 Exchange Property language.
org.apache.camel.language.ref	Camel Ref language.
org.apache.camel.language.simple	Camel Simple language.
org.apache.camel.language.simple.ast	AST for the Camel Simple language.
org.apache.camel.language.tokenizer	Camel Tokenizer 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.cloud	The JAXB POJOs for the remote service call DSL
org.apache.camel.model.language	The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration.
org.apache.camel.model.loadbalancer	The JAXB POJOs for the Load Balancer EIP pattern 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.saga	Camel Saga EIP
org.apache.camel.spi	Service Provider Interfaces used by the Camel runtime which are plugin strategies.
org.apache.camel.support	Base classes that help to implement the camel API and are expected to be extended by the user
org.apache.camel.util	Utility classes used by the core of Camel.
org.apache.camel.util.toolbox	Toolbox classes to create commonly used Aggregation Strategies in a fluent manner.

Uses of Expression in org.apache.camel

Methods in org.apache.camel that return Expression

Modifier and Type	Method and Description
Expression	ExpressionEvaluationException.getExpression()
Expression	BinaryPredicate.getLeft() Gets the left hand side expression
Expression	BinaryPredicate.getRight() Gets the right hand side expression

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

Constructor and Description
ExpressionEvaluationException(Expression expression, Exchange exchange, Throwable cause)
ExpressionEvaluationException(Expression expression, String message, Exchange exchange, Throwable cause)

Uses of Expression in org.apache.camel.builder

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

Modifier and Type	Class and Description
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	SimpleBuilder Creates an Simple language builder.
class	ValueBuilder A builder of expressions or predicates based on values.

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

Modifier and Type	Method and Description
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.attachmentObjectsExpression() Returns an expression for the inbound message attachments
static Expression	ExpressionBuilder.attachmentObjectValuesExpression() Returns an expression for the inbound message attachments
static Expression	ExpressionBuilder.attachmentsExpression() Returns an expression for the inbound message attachments
static Expression	ExpressionBuilder.attachmentValuesExpression() Returns an expression for the inbound message attachments
static Expression	ExpressionBuilder.beanExpression(Class<?> beanType, String methodName)
static Expression	ExpressionBuilder.beanExpression(Object bean, 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 Expression	ExpressionBuilder.bodyExpression(BiFunction<Object,Map<String,Object>,Object> function) Returns a functional expression for the exchanges inbound message body and headers
static <T> Expression	ExpressionBuilder.bodyExpression(Class<T> type) Returns the expression for the exchanges inbound message body converted to the given type
static <T> Expression	ExpressionBuilder.bodyExpression(Class<T> bodyType, BiFunction<T,Map<String,Object>,Object> function) Returns a functional expression for the exchanges inbound message body converted to a desired type and headers
static <T> Expression	ExpressionBuilder.bodyExpression(Class<T> bodyType, Function<T,Object> function) Returns a functional expression for the exchanges inbound message body converted to a desired type
static Expression	ExpressionBuilder.bodyExpression(Function<Object,Object> function) Returns a functional expression for the exchanges inbound message body
static Expression	ExpressionBuilder.bodyExpression(String name) Returns the expression for the exchanges inbound message body converted to the given type
static Expression	ExpressionBuilder.bodyOgnlExpression(String ognl) Returns the expression for the exchanges inbound message body invoking methods defined in a simple OGNL notation
static Expression	ExpressionBuilder.bodyOgnlExpression(String name, String ognl) Returns the expression for the exchanges inbound message body converted to the given type and invoking methods on the converted body defined in a simple OGNL notation
static Expression	ExpressionBuilder.bodyTypeExpression() Returns the expression for the exchanges inbound message body type
static Expression	ExpressionBuilder.cacheExpression(Expression expression) Returns an expression that caches the evaluation of another expression and returns the cached value, to avoid re-evaluating the expression.
static Expression	ExpressionBuilder.camelContextExpression() Returns an expression for the CamelContext
static Expression	ExpressionBuilder.camelContextNameExpression() Returns an expression for the CamelContext name
static Expression	ExpressionBuilder.camelContextOgnlExpression(String ognl) Returns the expression for the exchanges camelContext invoking methods defined in a simple OGNL notation
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.collateExpression(String expression, int group) Returns an iterator to collate (iterate) the given 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 desription) 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 evaluated to
protected Expression	ExpressionClauseSupport.createExpression(CamelContext camelContext)
static Expression	ExpressionBuilder.dateExpression(String command)
static Expression	ExpressionBuilder.dateExpression(String command, String pattern)
static Expression	ExpressionBuilder.dateExpression(String commandWithOffsets, String timezone, 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.exchangeExceptionOgnlExpression(String ognl) Returns the expression for the exchanges exception invoking methods defined in a simple OGNL notation
static Expression	ExpressionBuilder.exchangeExceptionStackTraceExpression() Returns an expression for an exception stacktrace set on the exchange
static Expression	ExpressionBuilder.exchangeExpression() Returns the expression for the exchange
static Expression	ExpressionBuilder.exchangeExpression(Function<Exchange,Object> function) Returns a functional expression for the exchange
static Expression	ExpressionBuilder.exchangeIdExpression() Returns an Expression for the exchange id
static Expression	ExpressionBuilder.exchangeOgnlExpression(String ognl) Returns the expression for the exchange invoking methods defined in a simple OGNL notation
static Expression	ExpressionBuilder.exchangePatternExpression() Returns an expression for the exchange pattern
static Expression	ExpressionBuilder.exchangePropertiesExpression() Returns an expression for the exchange properties of exchange
static Expression	ExpressionBuilder.exchangePropertyExpression(String propertyName) Returns an expression for the property value of exchange with the given name
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	ExpressionBuilder.fileAbsoluteExpression()
static Expression	ExpressionBuilder.fileAbsolutePathExpression()
static Expression	ExpressionBuilder.fileExtensionExpression()
static Expression	ExpressionBuilder.fileExtensionSingleExpression()
static Expression	ExpressionBuilder.fileLastModifiedExpression()
static Expression	ExpressionBuilder.fileNameExpression()
static Expression	ExpressionBuilder.fileNameNoExtensionExpression()
static Expression	ExpressionBuilder.fileNameNoExtensionSingleExpression()
static Expression	ExpressionBuilder.fileOnlyNameExpression()
static Expression	ExpressionBuilder.fileOnlyNameNoExtensionExpression()
static Expression	ExpressionBuilder.fileOnlyNameNoExtensionSingleExpression()
static Expression	ExpressionBuilder.fileParentExpression()
static Expression	ExpressionBuilder.filePathExpression()
static Expression	ExpressionBuilder.fileSizeExpression()
Expression	ValueBuilder.getExpression()
Expression	ExpressionClauseSupport.getExpressionValue()
Expression	ExpressionClause.getExpressionValue()
Expression	BinaryPredicateSupport.getLeft()
Expression	BinaryPredicateSupport.getRight()
static Expression	ExpressionBuilder.groupIteratorExpression(Expression expression, String token, String group, boolean skipFirst)
static Expression	ExpressionBuilder.groupXmlIteratorExpression(Expression expression, String group)
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 <T> Expression	ExpressionBuilder.headerExpression(String headerName, Class<T> type) Returns an expression for the header value with the given name converted to the given type Will fallback and look in properties if not found in headers.
static Expression	ExpressionBuilder.headerExpression(String headerName, String typeName) Returns an expression for the header value with the given name converted to the given type 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.headersOgnlExpression(String ognl) Returns the expression for the exchanges inbound message header invoking methods defined in a simple OGNL notation
static Expression	ExpressionBuilder.inMessageExpression() Returns the expression for the IN message
static Expression	ExpressionBuilder.inMessageExpression(Function<Message,Object> function) Returns a functional expression for the IN message
static Expression	ExpressionBuilder.languageExpression(String language, String expression) Returns an expression for evaluating the expression/predicate using the given language
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.mandatoryBodyExpression(String name) Returns the expression for the exchanges inbound message body converted to the given type
static Expression	ExpressionBuilder.mandatoryBodyOgnlExpression(String name, String ognl) Returns the expression for the exchanges inbound message body converted to the given type and invoking methods on the converted body defined in a simple OGNL notation
static Expression	ExpressionBuilder.messageExpression() Returns the expression for the IN message
static Expression	ExpressionBuilder.messageExpression(Function<Message,Object> function) Returns a functional expression for the IN message
static Expression	ExpressionBuilder.messageHistoryExpression(boolean detailed) Returns the message history (including exchange details or not)
static Expression	ExpressionBuilder.messageIdExpression() Returns an Expression for the inbound message id
static Expression	ExpressionBuilder.nullExpression() Returns the expression for the null value
static Expression	ExpressionBuilder.ognlExpression(Expression exp, String ognl) Returns the expression for invoking a method (support OGNL syntax) on the given expression
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.outMessageExpression(Function<Message,Object> function) Returns a functional expression for the OUT message
static Expression	ExpressionBuilder.parseSimpleOrFallbackToConstantExpression(String str, CamelContext camelContext) Returns Simple expression or fallback to Constant expression if expression str is not Simple expression.
static Expression	ExpressionBuilder.prepend(Expression left, Expression right) Prepends the String evaluations of the two expressions together
static Expression	ExpressionBuilder.propertiesComponentExpression(String key, String locations, String defaultValue)
static Expression	ExpressionBuilder.propertiesExpression() Deprecated. use ExpressionBuilder.exchangeExceptionExpression() instead
static Expression	ExpressionBuilder.propertyExpression(String propertyName) Deprecated. use ExpressionBuilder.exchangePropertyExpression(String) instead
static Expression	ExpressionBuilder.propertyOgnlExpression(String ognl) Returns an expression for the property value of exchange with the given name invoking methods defined in a simple OGNL notation
static Expression	ExpressionBuilder.randomExpression(int max) Returns a random number between 0 and max (exclusive)
static Expression	ExpressionBuilder.randomExpression(int min, int max) Returns a random number between min and max (exclusive)
static Expression	ExpressionBuilder.randomExpression(String min, String max) Returns a random number between min and max (exclusive)
static Expression	ExpressionBuilder.refExpression(String ref) Returns an expression for lookup a bean in the Registry
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	ExpressionBuilder.routeIdExpression() Returns an Expression for the route id
static Expression	ExpressionBuilder.simpleExpression(String expression)
static Expression	ExpressionBuilder.skipExpression(String expression, int number) Returns an iterator to skip (iterate) the given expression
static Expression	ExpressionBuilder.skipFirstExpression(Expression expression) Returns an expression that skips the first element
static Expression	ExpressionBuilder.skipIteratorExpression(Expression expression, int skip)
static Expression	ExpressionBuilder.sortExpression(Expression expression, Comparator comparator) Returns a sort expression which will sort the expression with the given comparator.
static Expression	ExpressionBuilder.systemEnvironmentExpression(String propertyName) Returns an expression for a system environment value with the given name
static Expression	ExpressionBuilder.systemEnvironmentExpression(String propertyName, String defaultValue) Returns an expression for a system environment value with the given name
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.threadNameExpression() Returns the expression for the current thread 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.tokenizePairExpression(String startToken, String endToken, boolean includeTokens) Returns an TokenPairExpressionIterator expression
static Expression	ExpressionBuilder.tokenizeXMLAwareExpression(String path, char mode)
static Expression	ExpressionBuilder.tokenizeXMLAwareExpression(String path, char mode, int group)
static Expression	ExpressionBuilder.tokenizeXMLExpression(String tagName, String inheritNamespaceTagName) Returns an TokenXMLExpressionIterator expression
static Expression	ExpressionBuilder.typeConverterExpression() Returns an expression for the type converter
static Expression	ExpressionBuilder.typeExpression(String name) Returns an expression for a type value

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

Modifier and Type	Method and Description
static Expression	ExpressionBuilder.append(Expression left, Expression right) Appends the String evaluations of the two expressions together
static Expression	ExpressionBuilder.cacheExpression(Expression expression) Returns an expression that caches the evaluation of another expression and returns the cached value, to avoid re-evaluating the expression.
protected void	ExpressionClauseSupport.configureExpression(CamelContext camelContext, Expression expression)
static Predicate	PredicateBuilder.contains(Expression left, Expression right)
static Predicate	PredicateBuilder.containsIgnoreCase(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 evaluated to
static Predicate	PredicateBuilder.endsWith(Expression left, Expression right)
T	ExpressionClauseSupport.expression(Expression expression) Specify an Expression instance
T	ExpressionClause.expression(Expression expression) Specify an Expression instance
static Expression	ExpressionBuilder.groupIteratorExpression(Expression expression, String token, String group, boolean skipFirst)
static Expression	ExpressionBuilder.groupXmlIteratorExpression(Expression expression, String group)
static Predicate	PredicateBuilder.isEqualTo(Expression left, Expression right)
static Predicate	PredicateBuilder.isEqualToIgnoreCase(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.ognlExpression(Expression exp, String ognl) Returns the expression for invoking a method (support OGNL syntax) on the given expression
protected ValueBuilder	ValueBuilder.onNewValueBuilder(Expression exp)
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 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, 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, String 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
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
DefaultErrorHandlerBuilder	DefaultErrorHandlerBuilder.retryWhile(Expression retryWhile) Sets the retry while expression.
static Processor	ProcessorBuilder.setBody(Expression expression) Creates a processor which sets the body of the message to the value of the expression
void	ExpressionClauseSupport.setExpressionValue(Expression expressionValue)
protected void	ExpressionClause.setExpressionValue(Expression expressionValue)
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 message.
static Processor	ProcessorBuilder.setOutBody(Expression expression) Deprecated. use ProcessorBuilder.setBody(org.apache.camel.Expression)
static Processor	ProcessorBuilder.setOutHeader(String name, Expression expression) Deprecated. use ProcessorBuilder.setHeader(String, org.apache.camel.Expression)
static Processor	ProcessorBuilder.setProperty(String name, Expression expression) Sets the property on the exchange
static Expression	ExpressionBuilder.skipFirstExpression(Expression expression) Returns an expression that skips the first element
static Expression	ExpressionBuilder.skipIteratorExpression(Expression expression, int skip)
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
ValidatorBuilder	ValidatorBuilder.withExpression(Expression expression) Set the Expression to be used for the predicate Validator.

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

Modifier and Type	Method and Description
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 desription) Returns an expression which returns the string concatenation value of the various expressions

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

Constructor and Description
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

Modifier and Type	Class and Description
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

Modifier and Type	Method and Description
Expression	BeanAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)
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.createParameterExpressions()
protected Expression	MethodInfo.createParametersExpression()
Expression	DefaultParameterMappingStrategy.getDefaultParameterTypeExpression(Class<?> parameterType)
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	ParameterInfo.getExpression()
Expression	MethodInfo.getParametersExpression()

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

Modifier and Type	Method and Description
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

Constructor and Description
ParameterInfo(int index, Class<?> type, Annotation[] annotations, Expression expression)

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

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

Modifier and Type	Class and Description
class	DirectVmConsumerExpression The expression to select direct-vm consumers based on ant-like path pattern matching.

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

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

Modifier and Type	Field and Description
protected Expression	GenericFileEndpoint.fileName
protected Expression	GenericFileEndpoint.idempotentKey
protected Expression	GenericFileEndpoint.move
protected Expression	GenericFileEndpoint.moveExisting
protected Expression	GenericFileEndpoint.moveFailed
protected Expression	GenericFileEndpoint.preMove
protected Expression	GenericFileEndpoint.tempFileName

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

Modifier and Type	Method and Description
Expression	GenericFileEndpoint.getFileName()
Expression	GenericFileEndpoint.getIdempotentKey()
Expression	GenericFileEndpoint.getMove()
Expression	GenericFileEndpoint.getMoveExisting()
Expression	GenericFileEndpoint.getMoveFailed()
Expression	GenericFileEndpoint.getPreMove()
Expression	GenericFileEndpoint.getTempFileName()

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

Modifier and Type	Method and Description
void	GenericFileEndpoint.setFileName(Expression fileName) Use Expression such as File Language to dynamically set the filename.
void	GenericFileEndpoint.setIdempotentKey(Expression idempotentKey) To use a custom idempotent key.
void	GenericFileEndpoint.setMove(Expression move) Expression (such as Simple Language) used to dynamically set the filename when moving it after processing.
void	GenericFileEndpoint.setMoveExisting(Expression moveExisting) Expression (such as File Language) used to compute file name to use when fileExist=Move is configured.
void	GenericFileEndpoint.setMoveFailed(Expression moveFailed) Sets the move failure expression based on Simple language.
void	GenericFileEndpoint.setPreMove(Expression preMove) Expression (such as File Language) used to dynamically set the filename when moving it before processing.
void	GenericFileEndpoint.setTempFileName(Expression tempFileName) The same as tempPrefix option but offering a more fine grained control on the naming of the temporary filename as it uses the File Language.

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

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

Modifier and Type	Method and Description
Expression	GenericFileExpressionRenamer.getExpression()

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

Modifier and Type	Method and Description
void	GenericFileExpressionRenamer.setExpression(Expression expression)

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

Constructor and Description
GenericFileExpressionRenamer(Expression expression)

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

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

Modifier and Type	Method and Description
Expression	LanguageEndpoint.getExpression()

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

Modifier and Type	Method and Description
void	LanguageEndpoint.setExpression(Expression expression)

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

Constructor and Description
LanguageEndpoint(String endpointUri, Component component, Language language, Expression expression, String resourceUri)

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

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

Modifier and Type	Class and Description
class	AssertionClause.PredicateValueBuilder Public class needed for fluent builders

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

Modifier and Type	Method and Description
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
ValueBuilder	AssertionClause.expression(Expression expression)
protected ValueBuilder	AssertionClause.PredicateValueBuilder.onNewValueBuilder(Expression exp)
void	MockEndpoint.returnReplyBody(Expression expression) Set the expression which value will be set to the message body
void	MockEndpoint.returnReplyHeader(String headerName, Expression expression) Set the expression which value will be set to the message header

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

Constructor and Description
PredicateValueBuilder(Expression expression)
TimeClause(Expression left, Expression right)

Uses of Expression in org.apache.camel.converter

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

Modifier and Type	Method and Description
static Processor	CamelConverter.toProcessor(Expression expression)

Uses of Expression in org.apache.camel.impl

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

Constructor and Description
DefaultRouteNode(ProcessorDefinition<?> processorDefinition, Expression expression)

Uses of Expression in org.apache.camel.impl.cloud

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

Modifier and Type	Class and Description
class	DefaultServiceCallExpression Support class for custom implementations of ServiceCall EIP components.

Methods in org.apache.camel.impl.cloud that return Expression

Modifier and Type	Method and Description
Expression	DefaultServiceCallProcessor.getExpression()

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

Constructor and Description
DefaultServiceCallProcessor(CamelContext camelContext, String name, String scheme, String uri, ExchangePattern exchangePattern, ServiceLoadBalancer loadBalancer, Expression expression)

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

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

Modifier and Type	Class and Description
class	BeanExpression Evaluates an expression using a bean method invocation

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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
Expression	ExchangePropertyLanguage.createExpression(String expression)
static Expression	ExchangePropertyLanguage.exchangeProperty(String propertyName)
static Expression	ExchangePropertyLanguage.property(String propertyName) Deprecated. use ExchangePropertyLanguage.exchangeProperty(String) instead

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

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

Modifier and Type	Method and Description
Expression	RefLanguage.createExpression(String expression)
static Expression	RefLanguage.ref(Object value)

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

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

Modifier and Type	Method and Description
Expression	SimpleLanguage.createExpression(String expression)
Expression	SimpleLanguage.createExpression(String expression, Class<?> resultType)
protected Expression	SimpleExpressionParser.doParseExpression()
static Expression	SimpleLanguage.expression(String expression) Creates a new Expression.
Expression	SimpleExpressionParser.parseExpression()
static Expression	SimpleBackwardsCompatibleParser.parseExpression(String expression, boolean allowEscape) Deprecated.
static Expression	SimpleLanguage.simple(String expression) Creates a new Expression.
static Expression	SimpleLanguage.simple(String expression, Class<?> resultType) Creates a new Expression (or Predicate if the resultType is a Boolean, or boolean type).

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

Constructor and Description
SimpleExpressionParser(String expression, boolean allowEscape, LRUCache<String,Expression> cacheExpression)
SimplePredicateParser(String expression, boolean allowEscape, LRUCache<String,Expression> cacheExpression)

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

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

Modifier and Type	Method and Description
Expression	DoubleQuoteEnd.createExpression(String expression)
Expression	UnaryExpression.createExpression(String expression)
Expression	SimpleFunctionEnd.createExpression(String expression)
Expression	SimpleFunctionStart.createExpression(String expression)
Expression	LiteralExpression.createExpression(String expression)
Expression	SingleQuoteEnd.createExpression(String expression)
Expression	BinaryExpression.createExpression(String expression)
Expression	SimpleFunctionExpression.createExpression(String expression) Creates a Camel Expression based on this model.
Expression	SimpleNode.createExpression(String expression) Creates a Camel Expression based on this model.
Expression	NullExpression.createExpression(String expression)
Expression	SingleQuoteStart.createExpression(String expression)
Expression	LogicalExpression.createExpression(String expression)
Expression	DoubleQuoteStart.createExpression(String expression)
Expression	CompositeNodes.createExpression(String expression)
Expression	SimpleFunctionExpression.createExpression(String expression, boolean strict) Creates a Camel Expression based on this model.

Constructor parameters in org.apache.camel.language.simple.ast with type arguments of type Expression

Constructor and Description
SimpleFunctionExpression(SimpleToken token, LRUCache<String,Expression> cacheExpression)
SimpleFunctionStart(SimpleToken token, LRUCache<String,Expression> cacheExpression)

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

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

Modifier and Type	Method and Description
Expression	TokenizeLanguage.createExpression() Creates a tokenize expression.
Expression	XMLTokenizeLanguage.createExpression() Creates a tokenize expression.
Expression	TokenizeLanguage.createExpression(String expression)
Expression	XMLTokenizeLanguage.createExpression(String expression)
static Expression	TokenizeLanguage.tokenize(String token)
static Expression	XMLTokenizeLanguage.tokenize(String path)
static Expression	TokenizeLanguage.tokenize(String token, boolean regex)
static Expression	XMLTokenizeLanguage.tokenize(String path, char mode)
static Expression	TokenizeLanguage.tokenize(String headerName, String token)
static Expression	XMLTokenizeLanguage.tokenize(String headerName, String path)
static Expression	TokenizeLanguage.tokenize(String headerName, String token, boolean regex)
static Expression	XMLTokenizeLanguage.tokenize(String headerName, String path, char mode)
static Expression	TokenizeLanguage.tokenizePair(String startToken, String endToken, boolean includeTokens)
static Expression	TokenizeLanguage.tokenizeXML(String tagName, String inheritNamespaceTagName)

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

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

Modifier and Type	Method and Description
Expression	XPathLanguage.createExpression(String expression)

Uses of Expression in org.apache.camel.model

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

Modifier and Type	Method and Description
protected Expression	WireTapDefinition.createExpression(RouteContext routeContext)
Expression	ExpressionSubElementDefinition.createExpression(RouteContext routeContext)
protected Expression	ToDynamicDefinition.createExpression(RouteContext routeContext)
Expression	ExpressionSubElementDefinition.getExpression()

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

Modifier and Type	Method and Description
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.
AggregateDefinition	AggregateDefinition.completionSize(Expression completionSize) Number of messages aggregated before the aggregation is complete.
AggregateDefinition	AggregateDefinition.completionTimeout(Expression completionTimeout) Time in millis that an aggregated exchange should be inactive before its complete (timeout).
OnExceptionDefinition	OnExceptionDefinition.continued(Expression continued) Sets whether the exchange should be marked as handled or not.
DelayDefinition	ProcessorDefinition.delay(Expression delay) Delayer EIP: Creates a delayer allowing you to delay the delivery of messages to some destination.
DynamicRouterDefinition<Type>	ProcessorDefinition.dynamicRouter(Expression expression) Dynamic Router EIP: Creates a dynamic router allowing you to route a message consecutively through a series of processing steps where the sequence of steps is not known at design time and can vary for each message.
CatchDefinition	CatchDefinition.handled(Expression handled) Deprecated. will be removed in Camel 3.0. Instead of using handled(false) you can re-throw the exception from a Processor or use the ProcessorDefinition.throwException(Exception)
OnExceptionDefinition	OnExceptionDefinition.handled(Expression handled) Sets whether the exchange should be marked as handled or not.
TryDefinition	TryDefinition.handled(Expression handled) Deprecated. will be removed in Camel 3.0. Instead of using handled(false) you can re-throw the exception from a Processor or use the ProcessorDefinition.throwException(Exception)
IdempotentConsumerDefinition	ProcessorDefinition.idempotentConsumer(Expression messageIdExpression) Idempotent consumer EIP: Creates an IdempotentConsumer to avoid duplicate messages
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.
WireTapDefinition<Type>	WireTapDefinition.newExchange(Expression expression) Deprecated. will be removed in Camel 3.0 Instead use WireTapDefinition.newExchangeBody(org.apache.camel.Expression)
WireTapDefinition<Type>	WireTapDefinition.newExchangeBody(Expression expression) Sends a new Exchange, instead of tapping an existing, using ExchangePattern.InOnly
WireTapDefinition<Type>	WireTapDefinition.newExchangeHeader(String headerName, Expression expression) Sets a header on the new Exchange, instead of tapping an existing, using ExchangePattern.InOnly.
SagaDefinition	SagaDefinition.option(String option, Expression expression)
Type	ProcessorDefinition.pollEnrich(Expression expression, long timeout, String aggregationStrategyRef, boolean aggregateOnException) The Content Enricher EIP enriches an exchange with additional data obtained from a resourceUri using a PollingConsumer to poll the endpoint.
RecipientListDefinition<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.
RecipientListDefinition<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.
RoutingSlipDefinition<Type>	ProcessorDefinition.routingSlip(Expression expression) Routing Slip EIP: Creates a routing slip allowing you to route a message consecutively through a series of processing steps where the sequence of steps is not known at design time and can vary for each message.
RoutingSlipDefinition<Type>	ProcessorDefinition.routingSlip(Expression expression, String uriDelimiter) Routing Slip EIP: Creates a routing slip allowing you to route a message consecutively through a series of processing steps where the sequence of steps is not known at design time and can vary for each message.
Type	ProcessorDefinition.script(Expression expression) Executes a script (do not change the message body).
Type	ProcessorDefinition.setBody(Expression expression) Message Translator EIP: Adds a processor which sets the body on the IN message
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) Deprecated. use ProcessorDefinition.setHeader(String, org.apache.camel.Expression)
Type	ProcessorDefinition.setHeader(String name, Expression expression) Adds a processor which sets the header on the IN message
Type	ProcessorDefinition.setOutHeader(String name, Expression expression) Deprecated. use ProcessorDefinition.setHeader(String, org.apache.camel.Expression)
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.
<T> Type	ProcessorDefinition.sort(Expression expression, Comparator<T> 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
ThrottleDefinition	ProcessorDefinition.throttle(Expression maximumRequestCount) Throttler EIP: Creates a throttler allowing you to ensure that a specific endpoint does not get overloaded, or that we don't exceed an agreed SLA with some external service.
static ExpressionDefinition	ExpressionNodeHelper.toExpressionDefinition(Expression expression) Determines which ExpressionDefinition describes the given expression best possible.
Type	ProcessorDefinition.transform(Expression expression) Message Translator EIP: Adds a processor which sets the body on the OUT message
ValidateDefinition	ProcessorDefinition.validate(Expression expression) Creates a validation expression which only if it is true then the exchange is forwarded to the destination.
WireTapDefinition<Type>	ProcessorDefinition.wireTap(String uri, boolean copy, Expression body) Deprecated. use the fluent builder from WireTapDefinition, will be removed in Camel 3.0
WireTapDefinition<Type>	ProcessorDefinition.wireTap(String uri, Expression body) Deprecated. use the fluent builder from WireTapDefinition, will be removed in Camel 3.0

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

Constructor and Description
AggregateDefinition(Expression expression)
AggregateDefinition(Expression correlationExpression, AggregationStrategy aggregationStrategy)
DelayDefinition(Expression delay)
DynamicRouterDefinition(Expression expression)
ExpressionNode(Expression expression)
ExpressionSubElementDefinition(Expression expression)
IdempotentConsumerDefinition(Expression messageIdExpression, IdempotentRepository<?> idempotentRepository)
LoopDefinition(Expression expression)
NoOutputExpressionNode(Expression expression)
RecipientListDefinition(Expression expression)
ResequenceDefinition(Expression expression)
RoutingSlipDefinition(Expression expression)
RoutingSlipDefinition(Expression expression, String uriDelimiter)
SagaOptionDefinition(String optionName, Expression expression)
ScriptDefinition(Expression expression)
SetBodyDefinition(Expression expression)
SetFaultBodyDefinition(Expression expression)
SetHeaderDefinition(String headerName, Expression expression)
SetOutHeaderDefinition(String headerName, Expression expression) Deprecated.
SetPropertyDefinition(String propertyName, Expression expression)
SortDefinition(Expression expression)
SortDefinition(Expression expression, Comparator<? super T> comparator)
SplitDefinition(Expression expression)
ThrottleDefinition(Expression maximumRequestsPerPeriod)
TransformDefinition(Expression expression)
ValidateDefinition(Expression expression)

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

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

Modifier and Type	Method and Description
Expression	ServiceCallConfigurationDefinition.getExpression()
Expression	ServiceCallDefinition.getExpression()
Expression	ServiceCallExpressionConfiguration.getExpression()
Expression	ServiceCallExpressionConfiguration.newInstance(CamelContext camelContext)

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

Modifier and Type	Method and Description
ServiceCallConfigurationDefinition	ServiceCallConfigurationDefinition.expression(Expression expression) Sets a custom Expression to use.
ServiceCallDefinition	ServiceCallDefinition.expression(Expression expression) Sets a custom Expression to use.
ServiceCallExpressionConfiguration	ServiceCallExpressionConfiguration.expression(Expression expression)
void	ServiceCallConfigurationDefinition.setExpression(Expression expression) Set a custom Expression to use.
void	ServiceCallDefinition.setExpression(Expression expression) Set a custom Expression to use.
void	ServiceCallExpressionConfiguration.setExpression(Expression expression)

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

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

Modifier and Type	Class and Description
class	ConstantExpression To use a constant value in Camel expressions or predicates.
class	ELExpression Deprecated.
class	ExchangePropertyExpression To use a Camel Exchange property in expressions or predicates.
class	ExpressionDefinition A useful base class for an expression
class	GroovyExpression To use Groovy scripts in Camel expressions or predicates.
class	HeaderExpression To use a Camel Message header in expressions or predicates.
class	JavaScriptExpression To use JavaScript in Camel expressions or predicates.
class	JsonPathExpression To use JsonPath in Camel expressions or predicates.
class	JXPathExpression Deprecated.
class	LanguageExpression To use the specified language in Camel expressions or predicates.
class	MethodCallExpression To use a Java bean (aka method call) in Camel expressions or predicates.
class	MvelExpression To use MVEL scripts in Camel expressions or 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 To use OGNL scripts in Camel expressions or predicates.
class	PhpExpression Deprecated.
class	PythonExpression Deprecated.
class	RefExpression Reference to an existing Camel expression or predicate, which is looked up from the Camel registry.
class	RubyExpression Deprecated.
class	SimpleExpression To use Camels built-in Simple language in Camel expressions or predicates.
class	SpELExpression To use Spring Expression Language (SpEL) in Camel expressions or predicates.
class	SqlExpression Deprecated.
class	TerserExpression To use HL7 terser scripts in Camel expressions or predicates.
class	TokenizerExpression To use Camel message body or header with a tokenizer in Camel expressions or predicates.
class	XMLTokenizerExpression To use Camel message body or header with a XML tokenizer in Camel expressions or predicates.
class	XPathExpression To use XPath (XML) in Camel expressions or predicates.
class	XQueryExpression To use XQuery (XML) in Camel expressions or predicates.

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

Modifier and Type	Method and Description
Expression	SimpleExpression.createExpression(CamelContext camelContext)
Expression	XPathExpression.createExpression(CamelContext camelContext)
Expression	JsonPathExpression.createExpression(CamelContext camelContext)
Expression	MethodCallExpression.createExpression(CamelContext camelContext)
Expression	XQueryExpression.createExpression(CamelContext camelContext)
Expression	TokenizerExpression.createExpression(CamelContext camelContext)
Expression	ExpressionDefinition.createExpression(CamelContext camelContext)
Expression	ExpressionDefinition.createExpression(RouteContext routeContext)
Expression	ExpressionDefinition.getExpressionValue()

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

Modifier and Type	Method and Description
protected void	XMLTokenizerExpression.configureExpression(CamelContext camelContext, Expression expression)
protected void	JXPathExpression.configureExpression(CamelContext camelContext, Expression expression) Deprecated.
protected void	NamespaceAwareExpression.configureExpression(CamelContext camelContext, Expression expression)
protected void	XPathExpression.configureExpression(CamelContext camelContext, Expression expression)
protected void	JsonPathExpression.configureExpression(CamelContext camelContext, Expression expression)
protected void	XQueryExpression.configureExpression(CamelContext camelContext, Expression expression)
protected void	ExpressionDefinition.configureExpression(CamelContext camelContext, Expression expression)
protected void	ExpressionDefinition.setExpressionValue(Expression expressionValue)

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

Constructor and Description
ExpressionDefinition(Expression expression)
SimpleExpression(Expression expression)
XPathExpression(Expression expression)

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

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

Modifier and Type	Method and Description
void	StickyLoadBalancerDefinition.setCorrelationExpression(Expression expression)

Uses of Expression in org.apache.camel.processor

Fields in org.apache.camel.processor declared as Expression

Modifier and Type	Field and Description
protected Expression	RoutingSlip.expression
protected Expression	SendDynamicProcessor.expression

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

Modifier and Type	Method and Description
Expression	Delayer.getDelay()
Expression	LogProcessor.getExpression()
Expression	SortProcessor.getExpression()
Expression	LoopProcessor.getExpression()
Expression	StreamResequencer.getExpression()
Expression	TransformProcessor.getExpression()
Expression	RecipientList.getExpression()
Expression	RoutingSlip.getExpression()
Expression	BatchProcessor.getExpression() Deprecated.
Expression	SetHeaderProcessor.getExpression()
Expression	SetBodyProcessor.getExpression()
Expression	Enricher.getExpression()
Expression	PollEnricher.getExpression()
Expression	SendDynamicProcessor.getExpression()
Expression	ScriptProcessor.getExpression()
Expression	Splitter.getExpression()
Expression	SetPropertyProcessor.getExpression()
Expression	Throttler.getMaximumRequestsPerPeriodExpression()
Expression	WireTapProcessor.getNewExchangeExpression()

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

Modifier and Type	Method and Description
protected RoutingSlip.RoutingSlipIterator	RoutingSlip.createRoutingSlipIterator(Exchange exchange, Expression expression) Creates the route slip iterator to be used.
protected RoutingSlip.RoutingSlipIterator	DynamicRouter.createRoutingSlipIterator(Exchange exchange, Expression expression)
protected static Set<Exchange>	Resequencer.createSet(Expression expression, boolean allowDuplicates, boolean reverse)
void	Delayer.setDelay(Expression delay)
void	Throttler.setMaximumRequestsPerPeriodExpression(Expression maxRequestsPerPeriodExpression) Sets the maximum number of requests per time period expression
void	WireTapProcessor.setNewExchangeExpression(Expression newExchangeExpression)

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

Constructor and Description
BatchProcessor(CamelContext camelContext, Processor processor, Collection<Exchange> collection, Expression expression) Deprecated.
Delayer(CamelContext camelContext, Processor processor, Expression delay, ScheduledExecutorService executorService, boolean shutdownExecutorService)
DynamicRouter(CamelContext camelContext, Expression expression, String uriDelimiter)
Enricher(Expression expression)
EvaluateExpressionProcessor(Expression expression)
LogProcessor(Expression expression, CamelLogger logger, MaskingFormatter formatter, Set<LogListener> listeners)
LoopProcessor(Processor processor, Expression expression, Predicate predicate, boolean copy)
PollEnricher(Expression expression, long timeout) Creates a new PollEnricher.
RecipientList(CamelContext camelContext, Expression expression)
RecipientList(CamelContext camelContext, Expression expression, String delimiter)
Resequencer(CamelContext camelContext, Processor processor, Expression expression)
Resequencer(CamelContext camelContext, Processor processor, Expression expression, boolean allowDuplicates, boolean reverse)
Resequencer(CamelContext camelContext, Processor processor, Set<Exchange> collection, Expression expression)
RoutingSlip(CamelContext camelContext, Expression expression, String uriDelimiter)
ScriptProcessor(Expression expression)
SendDynamicProcessor(Expression expression)
SendDynamicProcessor(String uri, Expression expression)
SetBodyProcessor(Expression expression)
SetHeaderProcessor(Expression headerName, Expression expression)
SetPropertyProcessor(Expression propertyName, Expression expression)
SortProcessor(Expression expression, Comparator<? super T> comparator)
Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy)
Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean useSubUnitOfWork) Deprecated.
Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean useSubUnitOfWork, boolean parallelAggregate)
Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean useSubUnitOfWork, boolean parallelAggregate, boolean stopOnAggregateException)
StreamResequencer(CamelContext camelContext, Processor processor, SequenceElementComparator<Exchange> comparator, Expression expression) Creates a new StreamResequencer instance.
Throttler(CamelContext camelContext, Processor processor, Expression maxRequestsPerPeriodExpression, long timePeriodMillis, ExecutorService asyncExecutor, boolean shutdownAsyncExecutor, boolean rejectExecution)
TransformProcessor(Expression expression)

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

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

Modifier and Type	Method and Description
Expression	AggregateProcessor.getCompletionSizeExpression()
Expression	AggregateProcessor.getCompletionTimeoutExpression()
Expression	AggregateProcessor.getCorrelationExpression()

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

Modifier and Type	Method and Description
void	AggregateProcessor.setCompletionSizeExpression(Expression completionSizeExpression)
void	AggregateProcessor.setCompletionTimeoutExpression(Expression completionTimeoutExpression)
void	AggregateProcessor.setCorrelationExpression(Expression correlationExpression)

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

Constructor and Description
AggregateProcessor(CamelContext camelContext, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy, ExecutorService executorService, boolean shutdownExecutorService)

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

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

Modifier and Type	Method and Description
Expression	NoMessageIdException.getExpression() The expression which was used
Expression	IdempotentConsumer.getMessageIdExpression()

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

Constructor and Description
IdempotentConsumer(Expression messageIdExpression, IdempotentRepository<String> idempotentRepository, boolean eager, boolean completionEager, boolean skipDuplicate, boolean removeOnFailure, 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

Modifier and Type	Method and Description
Expression	StickyLoadBalancer.getCorrelationExpression()

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

Constructor and Description
StickyLoadBalancer(Expression correlationExpression)

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

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

Modifier and Type	Method and Description
void	ExpressionResultComparator.setExpression(Expression expression) Set the expression sed for comparing Exchanges.
void	DefaultExchangeComparator.setExpression(Expression expression)

Uses of Expression in org.apache.camel.saga

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

Modifier and Type	Method and Description
Map<String,Expression>	CamelSagaStep.getOptions()

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

Constructor and Description
CamelSagaStep(Optional<Endpoint> compensation, Optional<Endpoint> completion, Map<String,Expression> options, Optional<Long> timeoutInMilliseconds)

Uses of Expression in org.apache.camel.spi

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

Modifier and Type	Method and Description
Expression	Language.createExpression(String expression) Creates an expression based on the given string input

Uses of Expression in org.apache.camel.support

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

Modifier and Type	Class and Description
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 ExpressionSupport.evaluate(org.apache.camel.Exchange) methods.
class	ExpressionSupport A useful base class for Predicate and Expression implementations
class	ServiceCallExpressionSupport
class	TokenPairExpressionIterator Expression to walk a Message body using an Iterator, which grabs the content between a start and end token.
class	TokenXMLExpressionIterator Expression to walk a Message XML body using an Iterator, which grabs the content between a XML start and end token, where the end token corresponds implicitly to either the end tag or the self-closing start tag.
class	TokenXMLPairExpressionIterator Deprecated. use TokenXMLExpressionIterator instead.
class	XMLTokenExpressionIterator An XMLTokenizeLanguage based iterator.

Uses of Expression in org.apache.camel.util

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

Modifier and Type	Class and Description
class	PredicateToExpressionAdapter To adapt Predicate as an Expression

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

Modifier and Type	Method and Description
static Expression	PredicateToExpressionAdapter.toExpression(Predicate predicate) Converts the given predicate into an Expression

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

Modifier and Type	Method and Description
static Predicate	ExpressionToPredicateAdapter.toPredicate(Expression expression) Converts the given expression into an Predicate

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

Constructor and Description
ExpressionComparator(Expression expression)
ExpressionToPredicateAdapter(Expression expression)

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

Constructor and Description
ExpressionListComparator(List<Expression> expressions)

Uses of Expression in org.apache.camel.util.toolbox

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

Modifier and Type	Method and Description
FlexibleAggregationStrategy<E>	FlexibleAggregationStrategy.pick(Expression expression) Set an expression to extract the element to be aggregated from the incoming Exchange.