Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.mule.expression
Class DefaultExpressionManager

    java.lang.Object
      org.mule.expression.DefaultExpressionManager

All Implemented Interfaces:
  MuleContextAware, ExpressionManager

    public class DefaultExpressionManager

extends Object
implements ExpressionManager, MuleContextAware

Provides universal access for evaluating expressions embedded in Mule configurations, such as Xml, Java, scripting and annotations.

Users can register or unregister `ExpressionEvaluator` through this interface.

Field Summary
`protected static Log` | `logger` logger used by this class

Fields inherited from interface org.mule.api.expression.ExpressionManager
`DEFAULT_EXPRESSION_POSTFIX, DEFAULT_EXPRESSION_PREFIX`

Constructor Summary
`DefaultExpressionManager()`

Method Summary
`void` | `clearEvaluators()` Clears all registered evaluators from the manager.
`Object` | `evaluate(String expression, MuleMessage message)` Evaluates the given expression.
`Object` | `evaluate(String expression, MuleMessage message, boolean failIfNull)` Evaluates the given expression.
`Object` | `evaluate(String expression, String evaluator, MuleMessage message, boolean failIfNull)` Evaluates the given expression.
`boolean` | `isEvaluatorRegistered(String name)` Checks whether an evaluator is registered with the manager
`boolean` | `isExpression(String string)` Determines if the string is an expression.
`boolean` | `isValidExpression(String expression)` Determines if the expression is valid or not.
`String` | `parse(String expression, MuleMessage message)` Evaluates expressions in a given string.
`String` | `parse(String expression, MuleMessage message, boolean failIfNull)` Evaluates expressions in a given string.
`void` | `registerEvaluator(ExpressionEvaluator evaluator)`
`void` | `setMuleContext(MuleContext context)`
`ExpressionEvaluator` | `unregisterEvaluator(String name)` Removes the evaluator with the given name
`void` | `validateExpression(String expression)` Determines if the expression is valid or not.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### logger

    protected static final transient Log logger

  logger used by this class

Constructor Detail

### DefaultExpressionManager

    public DefaultExpressionManager()

Method Detail

### setMuleContext

    public void setMuleContext(MuleContext context)

  Specified by:
    `setMuleContext` in interface `MuleContextAware`

### registerEvaluator

    public void registerEvaluator(ExpressionEvaluator evaluator)

  Specified by:
    `registerEvaluator` in interface `ExpressionManager`

### isEvaluatorRegistered

    public boolean isEvaluatorRegistered(String name)

  Checks whether an evaluator is registered with the manager

  Specified by:
    `isEvaluatorRegistered` in interface `ExpressionManager`
  Parameters:
    `name` - the name of the expression evaluator
  Returns:
    true if the evaluator is registered with the manager, false otherwise

### unregisterEvaluator

    public ExpressionEvaluator unregisterEvaluator(String name)

  Removes the evaluator with the given name

  Specified by:
    `unregisterEvaluator` in interface `ExpressionManager`
  Parameters:
    `name` - the name of the evaluator to remove
  Returns:
    the evaluator that was removed. This will be null if the evaluator was not registered

### evaluate

    public Object evaluate(String expression,
                           MuleMessage message)
                    throws ExpressionRuntimeException

  Evaluates the given expression. The expression should be a single expression definition with or without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For situations where one or more expressions need to be parsed within a single text, the `ExpressionManager.parse(String,org.mule.api.MuleMessage,boolean)` method should be used since it will iterate through all expressions in a string.

  Specified by:
    `evaluate` in interface `ExpressionManager`
  Parameters:
    `expression` - a single expression i.e. xpath://foo
    `message` - the current message to process. The expression will evaluata on the message.
  Returns:
    the result of the evaluation. Expressions that return collection will return an empty collection, not null.
  Throws:
    `ExpressionRuntimeException` - if the expression is invalid, or a null is found for the expression and 'failIfNull is set to true.

### evaluate

    public Object evaluate(String expression,
                           MuleMessage message,
                           boolean failIfNull)
                    throws ExpressionRuntimeException

  Evaluates the given expression. The expression should be a single expression definition with or without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For situations where one or more expressions need to be parsed within a single text, the `ExpressionManager.parse(String,org.mule.api.MuleMessage,boolean)` method should be used since it will iterate through all expressions in a string.

  Specified by:
    `evaluate` in interface `ExpressionManager`
  Parameters:
    `expression` - a single expression i.e. xpath://foo
    `message` - the current message to process. The expression will evaluata on the message.
    `failIfNull` - determines if an exception should be thrown if expression could not be evaluated or returns null.
  Returns:
    the result of the evaluation. Expressions that return collection will return an empty collection, not null.
  Throws:
    `ExpressionRuntimeException` - if the expression is invalid, or a null is found for the expression and 'failIfNull is set to true.

### evaluate

    public Object evaluate(String expression,
                           String evaluator,
                           MuleMessage message,
                           boolean failIfNull)
                    throws ExpressionRuntimeException

  Evaluates the given expression. The expression should be a single expression definition with or without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For situations where one or more expressions need to be parsed within a single text, the `ExpressionManager.parse(String,org.mule.api.MuleMessage,boolean)` method should be used since it will iterate through all expressions in a string.

  Specified by:
    `evaluate` in interface `ExpressionManager`
  Parameters:
    `expression` - a single expression i.e. xpath://foo
    `evaluator` - the evaluator to use when executing the expression
    `message` - the current message to process. The expression will evaluata on the message.
    `failIfNull` - determines if an exception should be thrown if expression could not be evaluated or returns null or if an exception should be thrown if an empty collection is returned.
  Returns:
    the result of the evaluation. Expressions that return collection will return an empty collection, not null.
  Throws:
    `ExpressionRuntimeException` - if the expression is invalid, or a null is found for the expression and 'failIfNull is set to true.

### parse

    public String parse(String expression,
                        MuleMessage message)
                 throws ExpressionRuntimeException

  Evaluates expressions in a given string. This method will iterate through each expression and evaluate it. If a user needs to evaluate a single expression they can use `ExpressionManager.evaluate(String,org.mule.api.MuleMessage,boolean)`.

  Specified by:
    `parse` in interface `ExpressionManager`
  Parameters:
    `expression` - a single expression i.e. xpath://foo
    `message` - the current message to process. The expression will evaluata on the message.
  Returns:
    the result of the evaluation. Expressions that return collection will return an empty collection, not null.
  Throws:
    `ExpressionRuntimeException` - if the expression is invalid, or a null is found for the expression and 'failIfNull is set to true.

### parse

    public String parse(String expression,
                        MuleMessage message,
                        boolean failIfNull)
                 throws ExpressionRuntimeException

  Evaluates expressions in a given string. This method will iterate through each expression and evaluate it. If a user needs to evaluate a single expression they can use `ExpressionManager.evaluate(String,org.mule.api.MuleMessage,boolean)`.

  Specified by:
    `parse` in interface `ExpressionManager`
  Parameters:
    `expression` - a single expression i.e. xpath://foo
    `message` - the current message to process. The expression will evaluata on the message.
    `failIfNull` - determines if an exception should be thrown if expression could not be evaluated or returns null.
  Returns:
    the result of the evaluation. Expressions that return collection will return an empty collection, not null.
  Throws:
    `ExpressionRuntimeException` - if the expression is invalid, or a null is found for the expression and 'failIfNull is set to true.

### clearEvaluators

    public void clearEvaluators()

  Clears all registered evaluators from the manager.

  Specified by:
    `clearEvaluators` in interface `ExpressionManager`

### isExpression

    public boolean isExpression(String string)

  Description copied from interface: `ExpressionManager`
  Determines if the string is an expression. This method will validate that the string contains either the expression prefix (malformed) or a full expression. This isn't full proof but catches most error cases

  Specified by:
    `isExpression` in interface `ExpressionManager`
  Parameters:
    `string` - is this string an expression string
  Returns:
    true if the string contains an expression

### isValidExpression

    public boolean isValidExpression(String expression)

  Determines if the expression is valid or not. This method will validate a single expression or expressions embedded in a string. the expression must be well formed i.e. #[bean:user]

  Specified by:
    `isValidExpression` in interface `ExpressionManager`
  Parameters:
    `expression` - the expression to validate
  Returns:
    true if the expression evaluator is recognised

### validateExpression

    public void validateExpression(String expression)
                            throws InvalidExpressionException

  Description copied from interface: `ExpressionManager`
  Determines if the expression is valid or not. This method will validate a single expression or expressions embedded in a string. the expression must be well formed i.e. #[bean:user]

  Specified by:
    `validateExpression` in interface `ExpressionManager`
  Parameters:
    `expression` - the expression to validate
  Throws:
    `InvalidExpressionException` - if the expression is invalid, including information about the position and fault

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.