|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Expression | |
---|---|
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.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.language.bean | Camel Bean language. |
org.apache.camel.language.constant | Camel Constant language. |
org.apache.camel.language.header | Camel Header language. |
org.apache.camel.language.property | Camel Property language. |
org.apache.camel.language.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.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.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. |
Uses of Expression in org.apache.camel |
---|
Methods in org.apache.camel that return Expression | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 | ||
---|---|---|
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.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
|
ExpressionBuilder.bodyExpression(Class<T> type)
Returns the expression for the exchanges inbound message body converted to the given type |
|
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.bodyTypeExpression()
Returns the expression for the exchanges inbound message body type |
|
static Expression |
ExpressionBuilder.camelContextExpression()
Returns an expression for the CamelContext |
|
static Expression |
ExpressionBuilder.camelContextNameExpression()
Returns an expression for the CamelContext name |
|
static Expression |
ExpressionBuilder.camelContextPropertiesExpression()
Returns an expression for the properties of the camel context |
|
static Expression |
ExpressionBuilder.camelContextPropertyExpression(String propertyName)
Returns an expression for the property value of the camel context with the given name |
|
static Expression |
ExpressionBuilder.concatExpression(Collection<Expression> expressions)
Returns an expression which returns the string concatenation value of the various expressions |
|
static Expression |
ExpressionBuilder.concatExpression(Collection<Expression> expressions,
String expression)
Returns an expression which returns the string concatenation value of the various expressions |
|
static Expression |
ExpressionBuilder.constantExpression(Object value)
Returns an expression for the constant value |
|
static Expression |
ExpressionBuilder.convertToExpression(Expression expression,
Class<?> type)
Returns an expression which converts the given expression to the given type |
|
static Expression |
ExpressionBuilder.convertToExpression(Expression expression,
Expression type)
Returns an expression which converts the given expression to the given type the type expression is evaluated to |
|
protected Expression |
ExpressionClauseSupport.createExpression(CamelContext camelContext)
|
|
static Expression |
ExpressionBuilder.dateExpression(String command,
String pattern)
|
|
static Expression |
ExpressionBuilder.exchangeExceptionExpression()
Returns an expression for an exception set on the exchange |
|
static Expression |
ExpressionBuilder.exchangeExceptionExpression(Class<Exception> type)
Returns an expression for an exception set on the exchange Is used to get the caused exception that typically have been wrapped in some sort of Camel wrapper exception |
|
static Expression |
ExpressionBuilder.exchangeExceptionMessageExpression()
Returns an expression for an exception message set on the exchange |
|
static Expression |
ExpressionBuilder.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.exchangeIdExpression()
Returns an Expression for the exchange id |
|
static Expression |
ExpressionBuilder.exchangePatternExpression()
Returns an expression for the exchange pattern |
|
static Expression |
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 |
|
static Expression |
ExpressionBuilder.fileAbsoluteExpression()
|
|
static Expression |
ExpressionBuilder.fileAbsolutePathExpression()
|
|
static Expression |
ExpressionBuilder.fileExtensionExpression()
|
|
static Expression |
ExpressionBuilder.fileLastModifiedExpression()
|
|
static Expression |
ExpressionBuilder.fileNameExpression()
|
|
static Expression |
ExpressionBuilder.fileNameNoExtensionExpression()
|
|
static Expression |
ExpressionBuilder.fileOnlyNameExpression()
|
|
static Expression |
ExpressionBuilder.fileOnlyNameNoExtensionExpression()
|
|
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,
int 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
|
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 name)
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
|
ExpressionBuilder.mandatoryBodyExpression(Class<T> type)
Returns the expression for the exchanges inbound message body converted to the given type. |
|
static
|
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.messageIdExpression()
Returns an Expression for the inbound message id |
|
static Expression |
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 Expression |
ExpressionBuilder.outHeaderExpression(String headerName)
Returns an expression for the out header value with the given name Will fallback and look in properties if not found in headers. |
|
static Expression |
ExpressionBuilder.outHeadersExpression()
Returns an expression for the outbound message headers |
|
static Expression |
ExpressionBuilder.outMessageExpression()
Returns the expression for the OUT message |
|
static Expression |
ExpressionBuilder.prepend(Expression left,
Expression right)
Prepends the String evaluations of the two expressions together |
|
static Expression |
ExpressionBuilder.propertiesComponentExpression(String key,
String locations)
|
|
static Expression |
ExpressionBuilder.propertiesExpression()
Returns an expression for the properties of exchange |
|
static Expression |
ExpressionBuilder.propertyExpression(String propertyName)
Returns an expression for the property value of exchange with the given name |
|
static Expression |
ExpressionBuilder.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.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.simpleExpression(String expression)
|
|
static Expression |
ExpressionBuilder.sortExpression(Expression expression,
Comparator comparator)
Returns a sort expression which will sort the expression with the given comparator. |
|
static Expression |
ExpressionBuilder.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.tokenizeXMLExpression(String tagName,
String inheritNamespaceTagName)
Returns an TokenXMLExpressionIterator expression |
|
static Expression |
ExpressionBuilder.typeConverterExpression()
Returns an expression for the type converter |
Methods in org.apache.camel.builder with parameters of type Expression | |
---|---|
static Expression |
ExpressionBuilder.append(Expression left,
Expression right)
Appends the String evaluations of the two expressions together |
protected void |
ExpressionClauseSupport.configureExpression(CamelContext camelContext,
Expression expression)
|
static Predicate |
PredicateBuilder.contains(Expression left,
Expression right)
|
static Expression |
ExpressionBuilder.convertToExpression(Expression expression,
Class<?> type)
Returns an expression which converts the given expression to the given type |
static Expression |
ExpressionBuilder.convertToExpression(Expression expression,
Expression type)
Returns an expression which converts the given expression to the given type the type expression is 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,
int group)
|
static Predicate |
PredicateBuilder.isEqualTo(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isGreaterThan(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isGreaterThanOrEqualTo(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isInstanceOf(Expression expression,
Class<?> type)
|
static Predicate |
PredicateBuilder.isLessThan(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isLessThanOrEqualTo(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isNotEqualTo(Expression left,
Expression right)
|
static Predicate |
PredicateBuilder.isNotNull(Expression expression)
|
static Predicate |
PredicateBuilder.isNull(Expression expression)
|
Predicate |
ValueBuilder.matches(Expression expression)
|
static Expression |
ExpressionBuilder.prepend(Expression left,
Expression right)
Prepends the String evaluations of the two expressions together |
static Predicate |
PredicateBuilder.regex(Expression expression,
Pattern pattern)
Returns a predicate which is true if the expression matches the given regular expression |
static Predicate |
PredicateBuilder.regex(Expression expression,
String regex)
Returns a predicate which is true if the expression matches the given regular expression |
static Expression |
ExpressionBuilder.regexReplaceAll(Expression expression,
String regex,
Expression replacementExpression)
Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result |
ValueBuilder |
BuilderSupport.regexReplaceAll(Expression content,
String regex,
Expression replacement)
Returns an expression value builder that replaces all occurrences of the regular expression with the given replacement |
static ValueBuilder |
Builder.regexReplaceAll(Expression content,
String regex,
Expression replacement)
Returns an expression that replaces all occurrences of the regular expression with the given replacement |
static Expression |
ExpressionBuilder.regexReplaceAll(Expression expression,
String regex,
String replacement)
Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result |
ValueBuilder |
BuilderSupport.regexReplaceAll(Expression content,
String regex,
String replacement)
Returns an expression value builder that replaces all occurrences of the regular expression with the given replacement |
static ValueBuilder |
Builder.regexReplaceAll(Expression content,
String regex,
String replacement)
Returns an expression that replaces all occurrences of the regular expression with the given replacement |
ValueBuilder |
ValueBuilder.regexReplaceAll(String regex,
Expression replacement)
Replaces all occurrences of the regular expression with the given replacement |
static Expression |
ExpressionBuilder.regexTokenizeExpression(Expression expression,
String regexTokenizer)
Returns a tokenize expression which will tokenize the string with the given regex |
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 IN 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 IN message |
static Processor |
ProcessorBuilder.setOutBody(Expression expression)
Creates a processor which sets the body of the OUT message to the value of the expression |
static Processor |
ProcessorBuilder.setOutHeader(String name,
Expression expression)
Sets the header on the OUT message |
static Processor |
ProcessorBuilder.setProperty(String name,
Expression expression)
Sets the property on the exchange |
static Expression |
ExpressionBuilder.sortExpression(Expression expression,
Comparator comparator)
Returns a sort expression which will sort the expression with the given comparator. |
static Predicate |
PredicateBuilder.startsWith(Expression left,
Expression right)
|
static Expression |
ExpressionBuilder.tokenizeExpression(Expression expression,
String token)
Returns a tokenize expression which will tokenize the string with the given token |
static Predicate |
PredicateBuilder.toPredicate(Expression expression)
Converts the given expression into an Predicate |
Method parameters in org.apache.camel.builder with type arguments of type Expression | |
---|---|
static Expression |
ExpressionBuilder.concatExpression(Collection<Expression> expressions)
Returns an expression which returns the string concatenation value of the various expressions |
static Expression |
ExpressionBuilder.concatExpression(Collection<Expression> expressions,
String expression)
Returns an expression which returns the string concatenation value of the various expressions |
Constructors in org.apache.camel.builder with parameters of type Expression | |
---|---|
BinaryPredicateSupport(Expression left,
Expression right)
|
|
ValueBuilder(Expression expression)
|
Uses of Expression in org.apache.camel.builder.xml |
---|
Classes in org.apache.camel.builder.xml that implement Expression | |
---|---|
class |
XPathBuilder
Creates an XPath expression builder which creates a nodeset result by default. |
Uses of Expression in org.apache.camel.component.bean |
---|
Methods in org.apache.camel.component.bean that return Expression | |
---|---|
Expression |
XPathAnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class<?> expressionReturnType)
|
Expression |
DefaultAnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class<?> expressionReturnType)
|
Expression |
BeanAnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class<?> expressionReturnType)
|
Expression |
AnnotationExpressionFactory.createExpression(CamelContext camelContext,
Annotation annotation,
LanguageAnnotation languageAnnotation,
Class<?> expressionReturnType)
|
protected Expression |
MethodInfo.createParametersExpression()
|
Expression |
ParameterMappingStrategy.getDefaultParameterTypeExpression(Class<?> parameterType)
Gets an expression used for evaluation with the current Exchange and its result is used as parameter value for the given type |
Expression |
DefaultParameterMappingStrategy.getDefaultParameterTypeExpression(Class<?> parameterType)
|
Expression |
ParameterInfo.getExpression()
|
Expression |
MethodInfo.getParametersExpression()
|
Methods in org.apache.camel.component.bean with parameters of type Expression | |
---|---|
void |
DefaultParameterMappingStrategy.addParameterMapping(Class<?> parameterType,
Expression expression)
Adds a default parameter type mapping to an expression |
void |
ParameterInfo.setExpression(Expression expression)
|
Constructors in org.apache.camel.component.bean with parameters of type Expression | |
---|---|
ParameterInfo(int index,
Class<?> type,
Annotation[] annotations,
Expression expression)
|
Uses of Expression in org.apache.camel.component.file |
---|
Fields in org.apache.camel.component.file declared as Expression | |
---|---|
protected Expression |
GenericFileEndpoint.fileName
|
protected Expression |
GenericFileEndpoint.move
|
protected Expression |
GenericFileEndpoint.moveExisting
|
protected Expression |
GenericFileEndpoint.moveFailed
|
protected Expression |
GenericFileEndpoint.preMove
|
protected Expression |
GenericFileEndpoint.tempFileName
|
Methods in org.apache.camel.component.file that return Expression | |
---|---|
Expression |
GenericFileEndpoint.getFileName()
|
Expression |
GenericFileEndpoint.getMove()
|
Expression |
GenericFileEndpoint.getMoveExisting()
|
Expression |
GenericFileEndpoint.getMoveFailed()
|
Expression |
GenericFileEndpoint.getPreMove()
|
Expression |
GenericFileEndpoint.getTempFileName()
|
Methods in org.apache.camel.component.file with parameters of type Expression | |
---|---|
void |
GenericFileEndpoint.setFileName(Expression fileName)
|
void |
GenericFileEndpoint.setMove(Expression move)
|
void |
GenericFileEndpoint.setMoveExisting(Expression moveExisting)
|
void |
GenericFileEndpoint.setMoveFailed(Expression moveFailed)
|
void |
GenericFileEndpoint.setPreMove(Expression preMove)
|
void |
GenericFileEndpoint.setTempFileName(Expression tempFileName)
|
Uses of Expression in org.apache.camel.component.file.strategy |
---|
Methods in org.apache.camel.component.file.strategy that return Expression | |
---|---|
Expression |
GenericFileExpressionRenamer.getExpression()
|
Methods in org.apache.camel.component.file.strategy with parameters of type Expression | |
---|---|
void |
GenericFileExpressionRenamer.setExpression(Expression expression)
|
Constructors in org.apache.camel.component.file.strategy with parameters of type Expression | |
---|---|
GenericFileExpressionRenamer(Expression expression)
|
Uses of Expression in org.apache.camel.component.language |
---|
Methods in org.apache.camel.component.language that return Expression | |
---|---|
Expression |
LanguageEndpoint.getExpression()
|
Methods in org.apache.camel.component.language with parameters of type Expression | |
---|---|
void |
LanguageEndpoint.setExpression(Expression expression)
|
Constructors in org.apache.camel.component.language with parameters of type Expression | |
---|---|
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 | |
---|---|
class |
AssertionClause.PredicateValueBuilder
Public class needed for fluent builders |
Methods in org.apache.camel.component.mock with parameters of type Expression | |
---|---|
void |
MockEndpoint.assertMessagesAscending(Expression expression)
Asserts that the messages have ascending values of the given expression |
void |
MockEndpoint.assertMessagesDescending(Expression expression)
Asserts that the messages have descending values of the given expression |
protected void |
MockEndpoint.assertMessagesSorted(Expression expression,
boolean ascending)
|
void |
MockEndpoint.assertNoDuplicates(Expression expression)
|
void |
MockEndpoint.expectsAscending(Expression expression)
Adds an expectation that messages received should have ascending values of the given expression such as a user generated counter value |
void |
MockEndpoint.expectsDescending(Expression expression)
Adds an expectation that messages received should have descending values of the given expression such as a user generated counter value |
void |
MockEndpoint.expectsNoDuplicates(Expression expression)
Adds an expectation that no duplicate messages should be received using the expression to determine the message ID |
ValueBuilder |
AssertionClause.expression(Expression expression)
|
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 | |
---|---|
AssertionClause.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 | |
---|---|
static Processor |
CamelConverter.toProcessor(Expression expresion)
|
Uses of Expression in org.apache.camel.impl |
---|
Constructors in org.apache.camel.impl with parameters of type Expression | |
---|---|
DefaultRouteNode(ProcessorDefinition<?> processorDefinition,
Expression expression)
|
Uses of Expression in org.apache.camel.language.bean |
---|
Classes in org.apache.camel.language.bean that implement Expression | |
---|---|
class |
BeanExpression
Evaluates an expression using a bean method invocation |
Methods in org.apache.camel.language.bean that return Expression | |
---|---|
static Expression |
BeanLanguage.bean(Class<?> beanType,
String method)
Creates the expression for invoking the bean type. |
static Expression |
BeanLanguage.bean(Object bean,
String method)
Creates the expression for invoking the bean type. |
static Expression |
BeanLanguage.bean(String expression)
Creates the expression based on the string syntax. |
Expression |
BeanLanguage.createExpression(Object bean,
String method)
|
Expression |
BeanLanguage.createExpression(String expression)
|
Uses of Expression in org.apache.camel.language.constant |
---|
Methods in org.apache.camel.language.constant that return Expression | |
---|---|
static Expression |
ConstantLanguage.constant(Object value)
|
Expression |
ConstantLanguage.createExpression(String expression)
|
Uses of Expression in org.apache.camel.language.header |
---|
Methods in org.apache.camel.language.header that return Expression | |
---|---|
Expression |
HeaderLanguage.createExpression(String expression)
|
static Expression |
HeaderLanguage.header(String headerName)
|
Uses of Expression in org.apache.camel.language.property |
---|
Methods in org.apache.camel.language.property that return Expression | |
---|---|
Expression |
PropertyLanguage.createExpression(String expression)
|
static Expression |
PropertyLanguage.property(String propertyName)
|
Uses of Expression in org.apache.camel.language.ref |
---|
Methods in org.apache.camel.language.ref that return Expression | |
---|---|
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 | |
---|---|
Expression |
SimpleLanguage.createExpression(String expression)
|
protected Expression |
SimpleExpressionParser.doParseExpression()
|
Expression |
SimpleExpressionParser.parseExpression()
|
static Expression |
SimpleBackwardsCompatibleParser.parseExpression(String expression,
boolean allowEscape)
Deprecated. |
static Expression |
SimpleLanguage.simple(String expression)
|
static Expression |
SimpleLanguage.simple(String expression,
Class<?> resultType)
|
Uses of Expression in org.apache.camel.language.simple.ast |
---|
Methods in org.apache.camel.language.simple.ast that return Expression | |
---|---|
Expression |
UnaryExpression.createExpression(String expression)
|
Expression |
SingleQuoteStart.createExpression(String expression)
|
Expression |
SingleQuoteEnd.createExpression(String expression)
|
Expression |
SimpleNode.createExpression(String expression)
Creates a Camel Expression based on this model. |
Expression |
SimpleFunctionStart.createExpression(String expression)
|
Expression |
SimpleFunctionExpression.createExpression(String expression)
|
Expression |
SimpleFunctionEnd.createExpression(String expression)
|
Expression |
NullExpression.createExpression(String expression)
|
Expression |
LogicalExpression.createExpression(String expression)
|
Expression |
LiteralExpression.createExpression(String expression)
|
Expression |
DoubleQuoteStart.createExpression(String expression)
|
Expression |
DoubleQuoteEnd.createExpression(String expression)
|
Expression |
CompositeNodes.createExpression(String expression)
|
Expression |
BinaryExpression.createExpression(String expression)
|
Expression |
SimpleFunctionExpression.createExpression(String expression,
boolean strict)
Creates a Camel Expression based on this model. |
Uses of Expression in org.apache.camel.language.tokenizer |
---|
Methods in org.apache.camel.language.tokenizer that return Expression | |
---|---|
Expression |
TokenizeLanguage.createExpression()
Creates a tokenize expression. |
Expression |
TokenizeLanguage.createExpression(String expression)
|
static Expression |
TokenizeLanguage.tokenize(String token)
|
static Expression |
TokenizeLanguage.tokenize(String token,
boolean regex)
|
static Expression |
TokenizeLanguage.tokenize(String headerName,
String token)
|
static Expression |
TokenizeLanguage.tokenize(String headerName,
String token,
boolean regex)
|
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 | |
---|---|
Expression |
XPathLanguage.createExpression(String expression)
|
Uses of Expression in org.apache.camel.model |
---|
Methods in org.apache.camel.model that return Expression | |
---|---|
Expression |
ExpressionSubElementDefinition.createExpression(RouteContext routeContext)
|
Expression |
ExpressionSubElementDefinition.getExpression()
|
Methods in org.apache.camel.model with parameters of type Expression | ||
---|---|---|
AggregateDefinition |
ProcessorDefinition.aggregate(Expression correlationExpression)
Aggregator EIP: Creates an aggregator allowing you to combine a number of messages together into a single message. |
|
AggregateDefinition |
ProcessorDefinition.aggregate(Expression correlationExpression,
AggregationStrategy aggregationStrategy)
Aggregator EIP: Creates an aggregator allowing you to combine a number of messages together into a single message. |
|
AggregateDefinition |
AggregateDefinition.completionSize(Expression completionSize)
Sets the completion size, which is the number of aggregated exchanges which would cause the aggregate to consider the group as complete and send out the aggregated exchange. |
|
AggregateDefinition |
AggregateDefinition.completionTimeout(Expression completionTimeout)
Sets the completion timeout, which would cause the aggregate to consider the group as complete and send out the aggregated exchange. |
|
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. |
|
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) |
|
OnExceptionDefinition |
OnExceptionDefinition.handled(Expression handled)
Sets whether the exchange should be marked as handled or not. |
|
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) |
|
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 . |
|
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.setBody(Expression expression)
Message Translator EIP: Adds a processor which sets the body on the IN message |
|
void |
LoopDefinition.setExpression(Expression expr)
|
|
void |
ExpressionSubElementDefinition.setExpression(Expression expression)
|
|
Type |
ProcessorDefinition.setFaultBody(Expression expression)
Adds a processor which sets the body on the FAULT message |
|
Type |
ProcessorDefinition.setFaultHeader(String name,
Expression expression)
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 |
|
void |
WireTapDefinition.setNewExchangeExpression(Expression expression)
|
|
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. |
|
|
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 |
Uses of Expression in org.apache.camel.model.language |
---|
Classes in org.apache.camel.model.language that implement Expression | |
---|---|
class |
ConstantExpression
For expressions and predicates using a constant |
class |
ELExpression
For EL expressions and predicates |
class |
ExpressionDefinition
A useful base class for an expression |
class |
GroovyExpression
For Groovy expressions and predicates |
class |
HeaderExpression
An expression which extracts the named header |
class |
JavaScriptExpression
For JavaScript expressions and predicates |
class |
JXPathExpression
For JXPath expressions and predicates |
class |
LanguageExpression
Represents a parameterised language expression which can support any language at runtime using the language attribute. |
class |
MethodCallExpression
For expressions and predicates using the bean language |
class |
MvelExpression
For MVEL expressions and predicates |
class |
NamespaceAwareExpression
A useful base class for any expression which may be namespace or XML content aware such as XPathExpression or XQueryExpression |
class |
OgnlExpression
For OGNL expressions and predicates |
class |
PhpExpression
For PHP expressions and predicates |
class |
PropertyExpression
An expression which extracts the named exchange property |
class |
PythonExpression
For Python expressions and predicates |
class |
RefExpression
For expressions and predicates using a reference to an existing Expression or Predicate
to lookup from the Registry . |
class |
RubyExpression
For Ruby expressions and predicates |
class |
SimpleExpression
For expressions and predicates using the simple language |
class |
SpELExpression
For Spring Expression Language (SpEL) expressions and predicates |
class |
SqlExpression
For SQL expressions and predicates |
class |
TokenizerExpression
For expressions and predicates using a body or header tokenizer. |
class |
XPathExpression
For XPath expressions and predicates |
class |
XQueryExpression
For XQuery expressions and predicates |
Methods in org.apache.camel.model.language that return Expression | |
---|---|
Expression |
XQueryExpression.createExpression(CamelContext camelContext)
|
Expression |
XPathExpression.createExpression(CamelContext camelContext)
|
Expression |
TokenizerExpression.createExpression(CamelContext camelContext)
|
Expression |
SimpleExpression.createExpression(CamelContext camelContext)
|
Expression |
MethodCallExpression.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 | |
---|---|
protected void |
XQueryExpression.configureExpression(CamelContext camelContext,
Expression expression)
|
protected void |
XPathExpression.configureExpression(CamelContext camelContext,
Expression expression)
|
protected void |
NamespaceAwareExpression.configureExpression(CamelContext camelContext,
Expression expression)
|
protected void |
JXPathExpression.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 | |
---|---|
ExpressionDefinition(Expression expression)
|
|
SimpleExpression(Expression expression)
|
|
XPathExpression(Expression expression)
|
Uses of Expression in org.apache.camel.processor |
---|
Fields in org.apache.camel.processor declared as Expression | |
---|---|
protected Expression |
RoutingSlip.expression
|
Methods in org.apache.camel.processor that return Expression | |
---|---|
Expression |
Delayer.getDelay()
|
Expression |
Splitter.getExpression()
|
Expression |
LoopProcessor.getExpression()
|
Expression |
Throttler.getMaximumRequestsPerPeriodExpression()
|
Expression |
WireTapProcessor.getNewExchangeExpression()
|
Methods in org.apache.camel.processor with parameters of type 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 | |
---|---|
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)
|
|
EvaluateExpressionProcessor(Expression expression)
|
|
LogProcessor(Expression expression,
CamelLogger logger)
|
|
LoopProcessor(Processor processor,
Expression expression,
boolean copy)
|
|
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)
|
|
SetBodyProcessor(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)
|
|
Throttler(CamelContext camelContext,
Processor processor,
Expression maxRequestsPerPeriodExpression,
long timePeriodMillis,
ScheduledExecutorService executorService,
boolean shutdownExecutorService)
|
|
TransformProcessor(Expression expression)
|
Uses of Expression in org.apache.camel.processor.aggregate |
---|
Methods in org.apache.camel.processor.aggregate that return Expression | |
---|---|
Expression |
AggregateProcessor.getCompletionSizeExpression()
|
Expression |
AggregateProcessor.getCompletionTimeoutExpression()
|
Methods in org.apache.camel.processor.aggregate with parameters of type Expression | |
---|---|
void |
AggregateProcessor.setCompletionSizeExpression(Expression completionSizeExpression)
|
void |
AggregateProcessor.setCompletionTimeoutExpression(Expression completionTimeoutExpression)
|
Constructors in org.apache.camel.processor.aggregate with parameters of type Expression | |
---|---|
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 | |
---|---|
Expression |
NoMessageIdException.getExpression()
The expression which was used |
Expression |
IdempotentConsumer.getMessageIdExpression()
|
Constructors in org.apache.camel.processor.idempotent with parameters of type Expression | |
---|---|
IdempotentConsumer(Expression messageIdExpression,
IdempotentRepository<String> idempotentRepository,
boolean eager,
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 | |
---|---|
Expression |
StickyLoadBalancer.getCorrelationExpression()
|
Constructors in org.apache.camel.processor.loadbalancer with parameters of type Expression | |
---|---|
StickyLoadBalancer(Expression correlationExpression)
|
|
StickyLoadBalancer(Expression correlationExpression,
QueueLoadBalancer loadBalancer)
|
Uses of Expression in org.apache.camel.processor.resequencer |
---|
Methods in org.apache.camel.processor.resequencer with parameters of type Expression | |
---|---|
void |
ExpressionResultComparator.setExpression(Expression expression)
Set the expression sed for comparing Exchange s. |
void |
DefaultExchangeComparator.setExpression(Expression expression)
|
Uses of Expression in org.apache.camel.spi |
---|
Methods in org.apache.camel.spi that return Expression | |
---|---|
Expression |
Language.createExpression(String expression)
Creates an expression based on the given string input |
Uses of Expression in org.apache.camel.support |
---|
Classes in org.apache.camel.support that implement Expression | |
---|---|
class |
ExpressionAdapter
A helper class for developers wishing to implement an Expression
using Java code with a minimum amount of code to write so that the developer only needs
to implement one of the ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) or
ExpressionSupport.evaluate(org.apache.camel.Exchange) methods. |
class |
ExpressionSupport
A useful base class for Predicate and Expression implementations |
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. |
Uses of Expression in org.apache.camel.util |
---|
Classes in org.apache.camel.util that implement Expression | |
---|---|
class |
PredicateToExpressionAdapter
|
Methods in org.apache.camel.util that return Expression | |
---|---|
static Expression |
PredicateToExpressionAdapter.toExpression(Predicate predicate)
Converts the given predicate into an Expression |
Methods in org.apache.camel.util with parameters of type Expression | |
---|---|
static Predicate |
ExpressionToPredicateAdapter.toPredicate(Expression expression)
Converts the given expression into an Predicate |
Constructors in org.apache.camel.util with parameters of type Expression | |
---|---|
ExpressionComparator(Expression expression)
|
|
ExpressionToPredicateAdapter(Expression expression)
|
Constructor parameters in org.apache.camel.util with type arguments of type Expression | |
---|---|
ExpressionListComparator(List<Expression> expressions)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |