Uses of Interface
org.apache.camel.Expression

Packages that use Expression
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.builder.xml Support for XPath based Expressions and Predicates as well as an XSLT processor 
org.apache.camel.component.bean The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO 
org.apache.camel.component.mock The Mock Component which is used for testing of routing and mediation rules. 
org.apache.camel.impl Default implementation classes for Camel Core 
org.apache.camel.language   
org.apache.camel.language.simple   
org.apache.camel.model Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. 
org.apache.camel.model.language Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. 
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.spi Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. 
org.apache.camel.util Utility classes used by the core of Camel and useful for Camel component developers 
 

Uses of Expression in org.apache.camel.builder
 

Classes in org.apache.camel.builder that implement Expression
 class ValueBuilder<E extends Exchange>
          A builder of expressions or predicates based on values.
 

Methods in org.apache.camel.builder that return Expression
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.append(Expression<E> left, Expression<E> right)
          Appends the String evaluations of the two expressions together
protected  Expression<E> ValueBuilder.asExpression(Object value)
           
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.bodyExpression()
          Returns the expression for the exchanges inbound message body
static
<E extends Exchange,T>
Expression<E>
ExpressionBuilder.bodyExpression(Class<T> type)
          Returns the expression for the exchanges inbound message body converted to the given type
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.constantExpression(Object value)
          Returns an expression for the contant value
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.convertTo(Expression expression, Class type)
          Returns an expression which converts the given expression to the given type
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.exchangeExpression()
          Returns the expression for the exchange
 Expression DeadLetterChannelBuilder.getDefaultDeadLetterEndpointExpression()
           
 Expression<E> ValueBuilder.getExpression()
           
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.headerExpression(String headerName)
          Returns an expression for the header value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.inMessageExpression()
          Returns the expression for the IN message
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.outBodyExpression()
          Returns the expression for the out messages body
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.outHeaderExpression(String headerName)
          Returns an expression for the out header value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.propertyExpression(String propertyName)
          Returns an expression for the property value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, Expression<E> replacementExpression)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, String replacement)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexTokenize(Expression<E> expression, String regexTokenizer)
          Returns a tokenize expression which will tokenize the string with the given regex
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemProperty(String name)
          Returns an expression for the given system property
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemProperty(String name, String defaultValue)
          Returns an expression for the given system property
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemPropertyExpression(String propertyName)
          Returns an expression for a system property value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.systemPropertyExpression(String propertyName, String defaultValue)
          Returns an expression for a system property value with the given name
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.tokenizeExpression(Expression<E> expression, String token)
          Returns a tokenize expression which will tokenize the string with the given token
 

Methods in org.apache.camel.builder with parameters of type Expression
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.append(Expression<E> left, Expression<E> right)
          Appends the String evaluations of the two expressions together
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.append(Expression<E> left, Expression<E> right)
          Appends the String evaluations of the two expressions together
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.contains(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.contains(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.convertTo(Expression expression, Class type)
          Returns an expression which converts the given expression to the given type
static
<E extends Exchange>
String
ExpressionBuilder.evaluateStringExpression(Expression<E> expression, E exchange)
          Evaluates the expression on the given exchange and returns the String representation
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isInstanceOf(Expression<E> expression, Class type)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThan(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNotEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNotEqualTo(Expression<E> left, Expression<E> right)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNotNull(Expression<E> expression)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.isNull(Expression<E> expression)
           
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.regex(Expression<E> expression, Pattern pattern)
          Returns a predicate which is true if the expression matches the given regular expression
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.regex(Expression<E> expression, String regex)
          Returns a predicate which is true if the expression matches the given regular expression
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, Expression<E> replacementExpression)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, Expression<E> replacementExpression)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexReplaceAll(Expression<E> expression, String regex, String replacement)
          Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result
 ValueBuilder<E> ValueBuilder.regexReplaceAll(String regex, Expression<E> replacement)
          Replaces all occurrencies of the regular expression with the given replacement
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.regexTokenize(Expression<E> expression, String regexTokenizer)
          Returns a tokenize expression which will tokenize the string with the given regex
static Processor ProcessorBuilder.setBody(Expression expression)
          Creates a processor which sets the body of the IN message to the value of the expression
 void DeadLetterChannelBuilder.setDefaultDeadLetterEndpointExpression(Expression defaultDeadLetterEndpointExpression)
          Sets the expression used to decide the dead letter channel endpoint for an exchange if no factory is provided via DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
static Processor ProcessorBuilder.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 IN message to the value of the expression
static Processor ProcessorBuilder.setOutHeader(String name, Expression expression)
          Sets the header on the OUT message
static Processor ProcessorBuilder.setProperty(String name, Expression expression)
          Sets the property on the exchange
static
<E extends Exchange>
Expression<E>
ExpressionBuilder.tokenizeExpression(Expression<E> expression, String token)
          Returns a tokenize expression which will tokenize the string with the given token
static
<E extends Exchange>
Predicate<E>
PredicateBuilder.toPredicate(Expression<E> expression)
          Converts the given expression into an Predicate
 

Constructors in org.apache.camel.builder with parameters of type Expression
ValueBuilder(Expression<E> expression)
           
 

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

Classes in org.apache.camel.builder.xml that implement Expression
 class XPathBuilder<E extends Exchange>
          Creates an XPath expression builder
 

Methods in org.apache.camel.builder.xml that return Expression
 Expression<Exchange> XPathLanguage.createExpression(String expression)
           
 

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

Methods in org.apache.camel.component.bean that return Expression
protected  Expression MethodInfo.createParametersExpression()
           
protected  Expression BeanInfo.createParameterUnmarshalExpression(Class clazz, Method method, Class parameterType, Annotation[] parameterAnnotation)
          Creates an expression for the given parameter type if the parameter can be mapped automatically or null if the parameter cannot be mapped due to unsufficient annotations or not fitting with the default type conventions.
protected  Expression BeanInfo.createParameterUnmarshalExpressionForAnnotation(Class clazz, Method method, Class parameterType, Annotation annotation)
           
 Expression DefaultParameterMappingStrategy.getDefaultParameterTypeExpression(Class parameterType)
           
 Expression ParameterMappingStrategy.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
 

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

Classes in org.apache.camel.component.mock that implement Expression
 class AssertionClause.PredicateValueBuilder
           
 

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

Constructors in org.apache.camel.component.mock with parameters of type Expression
AssertionClause.PredicateValueBuilder(Expression<E> expression)
           
 

Uses of Expression in org.apache.camel.impl
 

Classes in org.apache.camel.impl that implement Expression
 class ExpressionSupport<E extends Exchange>
          A useful base class for Predicate and Expression implementations
 

Constructors in org.apache.camel.impl with parameters of type Expression
BinaryPredicateSupport(Expression<E> left, Expression<E> right)
           
BinaryPredicateSupport(Expression<E> left, Expression<E> right)
           
 

Uses of Expression in org.apache.camel.language
 

Methods in org.apache.camel.language that return Expression
 Expression<Exchange> ExpressionEvaluationException.getExpression()
           
 

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

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

Methods in org.apache.camel.language.simple that return Expression
 Expression<Exchange> SimpleLanguage.createExpression(String expression)
           
 

Uses of Expression in org.apache.camel.model
 

Methods in org.apache.camel.model with parameters of type Expression
 AggregatorType ProcessorType.aggregator(Expression correlationExpression)
          A builder for the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of {@link AggregationStrategy ) (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.
 AggregatorType ProcessorType.aggregator(Expression correlationExpression, AggregationStrategy aggregationStrategy)
          A builder for the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of {@link AggregationStrategy ) (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.
 DelayerType ProcessorType.delayer(Expression<Exchange> processAtExpression)
          A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on
 DelayerType ProcessorType.delayer(Expression<Exchange> processAtExpression, long delay)
          A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on
 IdempotentConsumerType ProcessorType.idempotentConsumer(Expression messageIdExpression, MessageIdRepository messageIdRepository)
          Creates an IdempotentConsumer to avoid duplicate messages
 ProcessorType ProcessorType.recipientList(Expression receipients)
          Creates a dynamic Recipient List pattern.
 ResequencerType ProcessorType.resequencer(Expression... expressions)
          A builder for the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them.
 ResequencerType ProcessorType.resequencer(Expression<Exchange> expression)
          A builder for the Resequencer pattern where an expression is evaluated to be able to compare the message exchanges to reorder them.
 ProcessorType ProcessorType.setBody(Expression expression)
          Adds a processor which sets the body on the IN message
 ProcessorType ProcessorType.setHeader(String name, Expression expression)
          Adds a processor which sets the header on the IN message
 ProcessorType ProcessorType.setOutBody(Expression expression)
          Adds a processor which sets the body on the OUT message
 ProcessorType ProcessorType.setOutHeader(String name, Expression expression)
          Adds a processor which sets the header on the OUT message
 ProcessorType ProcessorType.setProperty(String name, Expression expression)
          Adds a processor which sets the exchange property
 SplitterType ProcessorType.splitter(Expression receipients)
          A builder for the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
 

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

Constructors in org.apache.camel.model with parameters of type Expression
AggregatorType(Expression correlationExpression)
           
AggregatorType(Expression correlationExpression, AggregationStrategy aggregationStrategy)
           
DelayerType(Expression processAtExpression)
           
DelayerType(Expression processAtExpression, long delay)
           
ExpressionNode(Expression expression)
           
IdempotentConsumerType(Expression messageIdExpression, MessageIdRepository messageIdRepository)
           
RecipientListType(Expression expression)
           
SplitterType(Expression expression)
           
 

Constructor parameters in org.apache.camel.model with type arguments of type Expression
ResequencerType(List<Expression> expressions)
           
 

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

Methods in org.apache.camel.model.language that return Expression
 Expression ExpressionType.createExpression(RouteContext routeContext)
           
 

Constructors in org.apache.camel.model.language with parameters of type Expression
ExpressionType(Expression expression)
           
 

Uses of Expression in org.apache.camel.processor
 

Methods in org.apache.camel.processor with parameters of type Expression
protected static Set<Exchange> Resequencer.createSet(Expression<Exchange> expression)
           
 

Method parameters in org.apache.camel.processor with type arguments of type Expression
protected static Set<Exchange> Resequencer.createSet(List<Expression> expressions)
           
 

Constructors in org.apache.camel.processor with parameters of type Expression
Aggregator(Endpoint endpoint, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy)
           
Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)
           
RecipientList(Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, Expression<Exchange> expression)
           
Splitter(Expression expression, Processor destination)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Expression
Resequencer(Endpoint endpoint, Processor processor, List<Expression> expressions)
           
 

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

Constructors in org.apache.camel.processor.aggregate with parameters of type Expression
AggregationCollection(Expression<Exchange> correlationExpression, AggregationStrategy aggregationStrategy)
           
 

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

Methods in org.apache.camel.processor.idempotent that return Expression
 Expression NoMessageIdException.getExpression()
          The expression which was used
 Expression<Exchange> IdempotentConsumer.getMessageIdExpression()
           
 

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

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

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

Uses of Expression in org.apache.camel.spi
 

Methods in org.apache.camel.spi that return Expression
 Expression<Exchange> Language.createExpression(String expression)
           
 

Uses of Expression in org.apache.camel.util
 

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

Constructors in org.apache.camel.util with parameters of type Expression
ExpressionComparator(Expression<E> expression)
           
 

Constructor parameters in org.apache.camel.util with type arguments of type Expression
ExpressionListComparator(List<Expression> expressions)
           
 



Copyright © 2007 Apache Software Foundation. All Rights Reserved.