|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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.converter | A set of helper classes for converting from different types of Java object to be used by the Type Conversion Support |
org.apache.camel.impl | Default implementation classes for Camel Core |
org.apache.camel.language | Camel language support such as Bean and Simple language. |
org.apache.camel.language.bean | Camel Bean language. |
org.apache.camel.language.simple | Camel Simple language. |
org.apache.camel.model | The JAXB POJOs for the XML Configuration of the routing rules. |
org.apache.camel.model.language | The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration. |
org.apache.camel.processor | A collection of Processor implementations which are used to implement the Enterprise Integration Patterns |
org.apache.camel.processor.aggregate | Helper classes for the Aggregator pattern. |
org.apache.camel.processor.idempotent | An implementation of the Idempotent Consumer pattern. |
org.apache.camel.processor.loadbalancer | Various load balancer processors |
org.apache.camel.processor.resequencer | Helper classes for the Resequencer pattern. |
org.apache.camel.spi | Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. |
org.apache.camel.util | Utility classes used by the core of Camel and useful for Camel component developers |
Uses of Expression in org.apache.camel.builder |
---|
Classes in org.apache.camel.builder that implement Expression | |
---|---|
class |
ExpressionClause<T>
Represents an expression clause within the DSL which when the expression is complete the clause continues to another part of the DSL |
class |
ValueBuilder<E extends Exchange>
A builder of expressions or predicates based on values. |
Methods in org.apache.camel.builder that return Expression | ||
---|---|---|
static
|
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
|
ExpressionBuilder.bodyExpression()
Returns the expression for the exchanges inbound message body |
|
static
|
ExpressionBuilder.bodyExpression(Class<T> type)
Returns the expression for the exchanges inbound message body converted to the given type |
|
static
|
ExpressionBuilder.concatExpression(Collection<Expression> expressions)
Returns an expression which returns the string concatenation value of the various expressions |
|
static
|
ExpressionBuilder.concatExpression(Collection<Expression> expressions,
String expression)
Returns an expression which returns the string concatenation value of the various expressions |
|
static
|
ExpressionBuilder.constantExpression(Object value)
Returns an expression for the constant value |
|
static
|
ExpressionBuilder.convertTo(Expression expression,
Class type)
Returns an expression which converts the given expression to the given type |
|
static
|
ExpressionBuilder.exchangeExpression()
Returns the expression for the exchange |
|
static
|
ExpressionBuilder.faultBodyExpression()
Returns the expression for the fault messages body |
|
static
|
ExpressionBuilder.faultBodyExpression(Class<T> type)
Returns the expression for the exchanges fault message body converted to the given type |
|
Expression |
DeadLetterChannelBuilder.getDefaultDeadLetterEndpointExpression()
|
|
Expression<E> |
ValueBuilder.getExpression()
|
|
static
|
ExpressionBuilder.headerExpression(String headerName)
Returns an expression for the header value with the given name |
|
static
|
ExpressionBuilder.headersExpression()
Returns an expression for the inbound message headers |
|
static
|
ExpressionBuilder.inMessageExpression()
Returns the expression for the IN message |
|
static
|
ExpressionBuilder.outBodyExpression()
Returns the expression for the out messages body |
|
static
|
ExpressionBuilder.outBodyExpression(Class<T> type)
Returns the expression for the exchanges outbound message body converted to the given type |
|
static
|
ExpressionBuilder.outHeaderExpression(String headerName)
Returns an expression for the out header value with the given name |
|
static
|
ExpressionBuilder.outHeadersExpression()
Returns an expression for the outbound message headers |
|
static
|
ExpressionBuilder.outMessageExpression()
Returns the expression for the OUT message |
|
static
|
ExpressionBuilder.propertiesExpression()
Returns an expression for the property value with the given name |
|
static
|
ExpressionBuilder.propertyExpression(String propertyName)
Returns an expression for the property value with the given name |
|
static
|
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
|
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
|
ExpressionBuilder.regexTokenize(Expression<E> expression,
String regexTokenizer)
Returns a tokenize expression which will tokenize the string with the given regex |
|
static
|
ExpressionBuilder.systemProperty(String name)
Returns an expression for the given system property |
|
static
|
ExpressionBuilder.systemProperty(String name,
String defaultValue)
Returns an expression for the given system property |
|
static
|
ExpressionBuilder.systemPropertyExpression(String propertyName)
Returns an expression for a system property value with the given name |
|
static
|
ExpressionBuilder.systemPropertyExpression(String propertyName,
String defaultValue)
Returns an expression for a system property value with the given name |
|
static
|
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
|
ExpressionBuilder.append(Expression<E> left,
Expression<E> right)
Appends the String evaluations of the two expressions together |
|
static
|
ExpressionBuilder.append(Expression<E> left,
Expression<E> right)
Appends the String evaluations of the two expressions together |
|
static
|
PredicateBuilder.contains(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.contains(Expression<E> left,
Expression<E> right)
|
|
static
|
ExpressionBuilder.convertTo(Expression expression,
Class type)
Returns an expression which converts the given expression to the given type |
|
static
|
ExpressionBuilder.evaluateStringExpression(Expression<E> expression,
E exchange)
Evaluates the expression on the given exchange and returns the String representation |
|
T |
ExpressionClause.expression(Expression expression)
Specify an Expression instance |
|
static
|
PredicateBuilder.isEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isInstanceOf(Expression<E> expression,
Class type)
|
|
static
|
PredicateBuilder.isLessThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isLessThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isNotEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isNotEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isNotNull(Expression<E> expression)
|
|
static
|
PredicateBuilder.isNull(Expression<E> expression)
|
|
static
|
PredicateBuilder.regex(Expression<E> expression,
Pattern pattern)
Returns a predicate which is true if the expression matches the given regular expression |
|
static
|
PredicateBuilder.regex(Expression<E> expression,
String regex)
Returns a predicate which is true if the expression matches the given regular expression |
|
static
|
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
|
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
|
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
|
ExpressionBuilder.regexTokenize(Expression<E> expression,
String regexTokenizer)
Returns a tokenize expression which will tokenize the string with the given regex |
|
static Processor |
ProcessorBuilder.setBody(Expression expression)
Creates a processor which sets the body of the IN message to the value of the expression |
|
void |
DeadLetterChannelBuilder.setDefaultDeadLetterEndpointExpression(Expression defaultDeadLetterEndpointExpression)
Sets the expression used to decide the dead letter channel endpoint for an exchange if no factory is provided via DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory) |
|
static Processor |
ProcessorBuilder.setFaultBody(Expression expression)
Creates a processor which sets the body of the FAULT message to the value of the expression |
|
static Processor |
ProcessorBuilder.setFaultHeader(String name,
Expression expression)
Sets the header on the FAULT message |
|
static Processor |
ProcessorBuilder.setHeader(String name,
Expression expression)
Sets the header on the IN message |
|
static Processor |
ProcessorBuilder.setOutBody(Expression expression)
Creates a processor which sets the body of the OUT message to the value of the expression |
|
static Processor |
ProcessorBuilder.setOutHeader(String name,
Expression expression)
Sets the header on the OUT message |
|
static Processor |
ProcessorBuilder.setProperty(String name,
Expression expression)
Sets the property on the exchange |
|
static
|
ExpressionBuilder.tokenizeExpression(Expression<E> expression,
String token)
Returns a tokenize expression which will tokenize the string with the given token |
|
static
|
PredicateBuilder.toPredicate(Expression<E> expression)
Converts the given expression into an Predicate |
Method parameters in org.apache.camel.builder with type arguments of type Expression | ||
---|---|---|
static
|
ExpressionBuilder.concatExpression(Collection<Expression> expressions)
Returns an expression which returns the string concatenation value of the various expressions |
|
static
|
ExpressionBuilder.concatExpression(Collection<Expression> expressions,
String expression)
Returns an expression which returns the string concatenation value of the various expressions |
Constructors in org.apache.camel.builder with parameters of type Expression | |
---|---|
ValueBuilder(Expression<E> expression)
|
Uses of Expression in org.apache.camel.builder.xml |
---|
Classes in org.apache.camel.builder.xml that implement Expression | |
---|---|
class |
XPathBuilder<E extends Exchange>
Creates an XPath expression builder which creates a nodeset result by default. |
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 | |
---|---|
Expression |
XPathAnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class expressionReturnType)
|
Expression |
DefaultAnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class expressionReturnType)
|
Expression |
AnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class expressionReturnType)
|
protected Expression |
MethodInfo.createParametersExpression()
|
protected Expression |
BeanInfo.createParameterUnmarshalExpression(Class clazz,
Method method,
Class parameterType,
Annotation[] parameterAnnotation)
Creates an expression for the given parameter type if the parameter can be mapped automatically or null if the parameter cannot be mapped due to unsufficient annotations or not fitting with the default type conventions. |
protected Expression |
BeanInfo.createParameterUnmarshalExpressionForAnnotation(Class clazz,
Method method,
Class parameterType,
Annotation annotation)
|
Expression |
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 |
void |
ParameterInfo.setExpression(Expression expression)
|
Constructors in org.apache.camel.component.bean with parameters of type Expression | |
---|---|
ParameterInfo(int index,
Class type,
Annotation[] annotations,
Expression expression)
|
Uses of Expression in org.apache.camel.component.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<Exchange> expression)
|
Uses of Expression in org.apache.camel.converter |
---|
Methods in org.apache.camel.converter with parameters of type Expression | |
---|---|
Processor |
CamelConverter.toProcessor(Expression<Exchange> expresion)
|
Uses of Expression in org.apache.camel.impl |
---|
Classes in org.apache.camel.impl that implement Expression | |
---|---|
class |
ExpressionSupport<E extends Exchange>
A useful base class for Predicate and Expression implementations |
Constructors in org.apache.camel.impl with parameters of type Expression | |
---|---|
BinaryPredicateSupport(Expression<E> left,
Expression<E> right)
|
|
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.bean |
---|
Classes in org.apache.camel.language.bean that implement Expression | |
---|---|
class |
BeanExpression<E extends Exchange>
Evaluates an expression using a bean method invocation |
Methods in org.apache.camel.language.bean that return Expression | |
---|---|
Expression<Exchange> |
BeanLanguage.createExpression(String expression)
|
Uses of Expression in org.apache.camel.language.simple |
---|
Methods in org.apache.camel.language.simple that return Expression | |
---|---|
protected Expression<Exchange> |
SimpleLanguage.createComplexExpression(String expression)
|
protected Expression |
SimpleLanguage.createConstantExpression(String expression,
int start,
int end)
|
Expression<Exchange> |
SimpleLanguage.createExpression(String expression)
|
protected Expression<Exchange> |
SimpleLanguage.createSimpleExpression(String expression)
|
static Expression |
SimpleLanguage.simple(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)
Creates an Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges. |
AggregatorType |
ProcessorType.aggregator(Expression correlationExpression,
AggregationStrategy aggregationStrategy)
Creates an Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges. |
DelayerType |
ProcessorType.delayer(Expression<Exchange> processAtExpression)
Creates the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on |
DelayerType |
ProcessorType.delayer(Expression<Exchange> processAtExpression,
long delay)
Creates the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on |
IdempotentConsumerType |
ProcessorType.idempotentConsumer(Expression messageIdExpression,
MessageIdRepository messageIdRepository)
Creates an IdempotentConsumer to avoid duplicate messages |
Type |
ProcessorType.recipientList(Expression receipients)
Creates a dynamic Recipient List pattern. |
ResequencerType |
ProcessorType.resequencer(Expression... expressions)
Creates the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them. |
ResequencerType |
ProcessorType.resequencer(Expression<Exchange> expression)
Creates the Resequencer pattern where an expression is evaluated to be able to compare the message exchanges to reorder them. |
Type |
ProcessorType.setBody(Expression expression)
Adds a processor which sets the body on the IN message |
Type |
ProcessorType.setFaultBody(Expression expression)
Adds a processor which sets the body on the FAULT message |
Type |
ProcessorType.setFaultHeader(String name,
Expression expression)
Adds a processor which sets the header on the FAULT message |
Type |
ProcessorType.setHeader(String name,
Expression expression)
Adds a processor which sets the header on the IN message |
Type |
ProcessorType.setOutBody(Expression expression)
Deprecated. Please use ProcessorType.transform(Expression) instead |
Type |
ProcessorType.setOutHeader(String name,
Expression expression)
Adds a processor which sets the header on the OUT message |
Type |
ProcessorType.setProperty(String name,
Expression expression)
Adds a processor which sets the exchange property |
SplitterType |
ProcessorType.splitter(Expression receipients)
Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint. |
SplitterType |
ProcessorType.splitter(Expression partsExpression,
AggregationStrategy aggregationStrategy)
Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint. |
SplitterType |
ProcessorType.splitter(Expression partsExpression,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing)
Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint. |
SplitterType |
ProcessorType.splitter(Expression receipients,
boolean parallelProcessing)
Creates the Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint. |
LoadBalanceType |
LoadBalanceType.sticky(Expression<Exchange> correlationExpression)
|
Type |
ProcessorType.transform(Expression expression)
Adds a processor which sets the body on the OUT message |
Method parameters in org.apache.camel.model with type arguments of type Expression | |
---|---|
ResequencerType |
ProcessorType.resequencer(List<Expression> expressions)
Creates the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them. |
Constructors in org.apache.camel.model with parameters of type Expression | |
---|---|
AggregatorType(Expression correlationExpression)
|
|
AggregatorType(Expression correlationExpression,
AggregationStrategy aggregationStrategy)
|
|
DelayerType(Expression processAtExpression)
|
|
DelayerType(Expression processAtExpression,
long delay)
|
|
ExpressionNode(Expression expression)
|
|
IdempotentConsumerType(Expression messageIdExpression,
MessageIdRepository messageIdRepository)
|
|
RecipientListType(Expression expression)
|
|
SetHeaderType(String headerName,
Expression expression)
|
|
SplitterType(Expression expression)
|
|
TransformType(Expression expression)
|
Constructor parameters in org.apache.camel.model with type arguments of type Expression | |
---|---|
ResequencerType(List<Expression> expressions)
|
Uses of Expression in org.apache.camel.model.language |
---|
Classes in org.apache.camel.model.language that implement Expression | |||
---|---|---|---|
class |
ELExpression
For EL expresions and predicates |
||
class |
ExpressionType
A useful base class for an expression |
||
class |
GroovyExpression
For Groovy expresions and predicates |
||
class |
HeaderExpression
An expression which extracts the named header |
||
class |
JavaScriptExpression
For JavaScript expresions and predicates |
||
class |
JXPathExpression
For JXPath expresions and predicates |
||
class |
LanguageExpression
Represents a parameterised language expression which can support any language at runtime using the language attribute. |
||
class |
MethodCallExpression
For expresions and predicates using the |
class |
NamespaceAwareExpression
A useful base class for any expression which may be namespace or XML content aware such as XPathExpression or XQueryExpression |
class |
OgnlExpression
For OGNL expresions and predicates |
||
class |
PhpExpression
For PHP expresions and predicates |
||
class |
PythonExpression
For Python expresions and predicates |
||
class |
RubyExpression
For Ruby expresions and predicates |
||
class |
SimpleExpression
For expresions and predicates using the |
class |
SqlExpression
For SQL expresions and predicates |
class |
XPathExpression
For XPath expresions and predicates |
||
class |
XQueryExpression
For XQuery expresions and predicates |
Methods in org.apache.camel.model.language that return Expression | |
---|---|
Expression |
ExpressionType.createExpression(RouteContext routeContext)
|
Expression |
MethodCallExpression.createExpression(RouteContext routeContext)
|
Expression |
ExpressionType.getExpressionValue()
|
Methods in org.apache.camel.model.language with parameters of type Expression | |
---|---|
protected void |
ExpressionType.configureExpression(RouteContext routeContext,
Expression expression)
|
protected void |
XPathExpression.configureExpression(RouteContext routeContext,
Expression expression)
|
protected void |
NamespaceAwareExpression.configureExpression(RouteContext routeContext,
Expression expression)
|
protected void |
XQueryExpression.configureExpression(RouteContext routeContext,
Expression expression)
|
protected void |
ExpressionType.setExpressionValue(Expression expressionValue)
|
Constructors in org.apache.camel.model.language with parameters of type Expression | |
---|---|
ExpressionType(Expression expression)
|
Uses of Expression in org.apache.camel.processor |
---|
Methods in org.apache.camel.processor 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)
|
|
Aggregator(Endpoint endpoint,
Processor processor,
Expression correlationExpression,
AggregationStrategy aggregationStrategy,
Predicate aggregationCompletedPredicate)
|
|
Delayer(Processor processor,
Expression<Exchange> timeExpression,
long delay)
|
|
RecipientList(Expression<Exchange> expression)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
Expression<Exchange> expression)
|
|
SetHeaderProcessor(String name,
Expression expression)
|
|
SetHeaderProcessor(String name,
Expression expression,
Processor childProcessor)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing,
ThreadPoolExecutor threadPoolExecutor)
|
|
TransformProcessor(Expression expression)
|
|
TransformProcessor(Expression expression,
Processor childProcessor)
|
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)
|
|
PredicateAggregationCollection(Expression<Exchange> correlationExpression,
AggregationStrategy aggregationStrategy,
Predicate aggregationCompletedPredicate)
|
Uses of Expression in org.apache.camel.processor.idempotent |
---|
Methods in org.apache.camel.processor.idempotent that return Expression | |
---|---|
Expression |
NoMessageIdException.getExpression()
The expression which was used |
Expression<Exchange> |
IdempotentConsumer.getMessageIdExpression()
|
Constructors in org.apache.camel.processor.idempotent with parameters of type Expression | |
---|---|
IdempotentConsumer(Expression<Exchange> messageIdExpression,
MessageIdRepository messageIdRepository,
Processor nextProcessor)
|
|
NoMessageIdException(Exchange exchange,
Expression expression)
|
Uses of Expression in org.apache.camel.processor.loadbalancer |
---|
Methods in org.apache.camel.processor.loadbalancer with parameters of type Expression | |
---|---|
void |
StickyLoadBalancer.setCorrelationExpression(Expression<Exchange> correlationExpression)
|
Constructors in org.apache.camel.processor.loadbalancer with parameters of type Expression | |
---|---|
StickyLoadBalancer(Expression<Exchange> correlationExpression)
|
|
StickyLoadBalancer(Expression<Exchange> correlationExpression,
QueueLoadBalancer loadBalancer)
|
Uses of Expression in org.apache.camel.processor.resequencer |
---|
Methods in org.apache.camel.processor.resequencer that return Expression | |
---|---|
Expression<Exchange> |
DefaultExchangeComparator.getExpression()
|
Methods in org.apache.camel.processor.resequencer with parameters of type Expression | |
---|---|
void |
DefaultExchangeComparator.setExpression(Expression<Exchange> expression)
|
Method parameters in org.apache.camel.processor.resequencer with type arguments of type Expression | |
---|---|
void |
ExpressionResultComparator.setExpressions(List<Expression> expressions)
Sets the list expressions used for comparing Exchange s. |
void |
DefaultExchangeComparator.setExpressions(List<Expression> expressions)
|
Uses of Expression in org.apache.camel.spi |
---|
Methods in org.apache.camel.spi that return Expression | |
---|---|
Expression<Exchange> |
Language.createExpression(String expression)
|
Uses of Expression in org.apache.camel.util |
---|
Methods in org.apache.camel.util that return Expression | |
---|---|
static Expression |
CamelContextHelper.resolveMandatoryExpression(CamelContext camelContext,
String languageName,
String expressionText)
Resolves the mandatory language name and expression text into a Expression instance
throwing an exception if it could not be created |
Methods in org.apache.camel.util with parameters of type Expression | ||
---|---|---|
static
|
ExpressionHelper.evaluateAsString(Expression<E> expression,
E exchange)
Evaluates the given expression on the exchange as a String value |
|
static
|
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |