Uses of Class
org.apache.camel.builder.ExpressionClause

Packages that use ExpressionClause
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.component.mock The Mock Component which is used for testing of routing and mediation rules. 
org.apache.camel.model The JAXB POJOs for the XML Configuration of the routing rules. 
 

Uses of ExpressionClause in org.apache.camel.builder
 

Methods in org.apache.camel.builder that return ExpressionClause
static
<T extends ExpressionNode>
ExpressionClause<T>
ExpressionClause.createAndSetExpression(T result)
           
 

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

Methods in org.apache.camel.component.mock that return ExpressionClause
 ExpressionClause<AssertionClause> AssertionClause.predicate()
           
 

Uses of ExpressionClause in org.apache.camel.model
 

Methods in org.apache.camel.model that return ExpressionClause
 ExpressionClause<AggregatorType> ProcessorType.aggregator()
          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.
 ExpressionClause<AggregatorType> ProcessorType.aggregator(AggregationCollection aggregationCollection)
          Creates an Aggregator pattern using a custom aggregation collection implementation.
 ExpressionClause<AggregatorType> ProcessorType.aggregator(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.
 ExpressionClause<AggregatorType> AggregatorType.completedPredicate()
          Sets the predicate used to determine if the aggregation is completed
 ExpressionClause<DelayerType> ProcessorType.delayer()
          Creates the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on
 ExpressionClause<FilterType> ProcessorType.filter()
          Creates a predicate expression which only if it is true then the exchange is forwarded to the destination
 ExpressionClause<IdempotentConsumerType> ProcessorType.idempotentConsumer(MessageIdRepository messageIdRepository)
          Creates an IdempotentConsumer to avoid duplicate messages
 ExpressionClause<ProcessorType<Type>> ProcessorType.recipientList()
          Creates a dynamic Recipient List pattern.
 ExpressionClause<ResequencerType> ProcessorType.resequencer()
          Creates the Resequencer pattern where a list of expressions are evaluated to be able to compare the message exchanges to reorder them.
 ExpressionClause<ProcessorType<Type>> ProcessorType.setBody()
          Adds a processor which sets the body on the IN message
 ExpressionClause<ProcessorType<Type>> ProcessorType.setHeader(String name)
          Adds a processor which sets the header on the IN message
 ExpressionClause<ProcessorType<Type>> ProcessorType.setOutBody()
          Deprecated. Please use ProcessorType.transform() instead
 ExpressionClause<ProcessorType<Type>> ProcessorType.setOutHeader(String name)
          Adds a processor which sets the header on the OUT message
 ExpressionClause<ProcessorType<Type>> ProcessorType.setProperty(String name)
          Adds a processor which sets the exchange property
 ExpressionClause<SplitterType> ProcessorType.splitter()
          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.
 ExpressionClause<SplitterType> ProcessorType.splitter(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.
 ExpressionClause<SplitterType> ProcessorType.splitter(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.
 ExpressionClause<SplitterType> ProcessorType.splitter(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.
 ExpressionClause<ProcessorType<Type>> ProcessorType.transform()
          Adds a processor which sets the body on the OUT message
 ExpressionClause<ChoiceType> ChoiceType.when()
           
 



Copyright © 2008 IONA Open Source Community. All Rights Reserved.