Interface IExpressionFactory


  • public interface IExpressionFactory
    This interface provides all the factory methods needed to create the nodes of the expression tree.
    Since:
    2.0
    Restriction:
    This interface is not intended to be implemented directly by clients.
    Restriction:
    This interface is not intended to be extended directly by clients.
    • Method Detail

      • all

        IExpression all​(IExpression collection,
                        IExpression lambda)
        Create a collection filter that yields true if the lambda yields true for all of the elements of the collection
        Parameters:
        collection - The collection providing the elements to test
        lambda - The lambda that performs the test
        Returns:
        A boolean expression
      • and

        IExpression and​(IExpression... operands)
        Create a logical and of its operands.
        Parameters:
        operands - The boolean operands
        Returns:
        A boolean expression
      • assignment

        IExpression assignment​(IExpression variable,
                               IExpression expression)
        Creates an expression that represents a variable assignment
        Parameters:
        variable - The variable
        expression - The expression that yields the value to assign to the variable
        Returns:
        An assignment expression
      • collect

        IExpression collect​(IExpression collection,
                            IExpression lambda)
        Create an expression that collects the result of evaluating each element in a new collection.
        Parameters:
        collection - The collection providing the elements to evaluate
        lambda - The lambda that creates each new element
        Returns:
        A collection expression
      • condition

        IExpression condition​(IExpression test,
                              IExpression ifTrue,
                              IExpression ifFalse)
        Create an expression that first evaluates a test and then, depending on the outcome, evaluates either ifTrue or ifFalse. The expression yields the result of the ifTrue or ifFalse evaluation.
        Parameters:
        test - The test
        ifTrue - The code to evaluate when the test evaluates to true
        ifFalse - The code to evaluate when the test evaluates to false
        Returns:
        The conditional expression
      • first

        IExpression first​(IExpression collection,
                          IExpression lambda)
        Create an expression that yields the first element of the collection for which the lambda yields true.
        Parameters:
        collection - The collection providing the elements to test
        lambda - The lambda that performs the test
        Returns:
        An element expression
      • flatten

        IExpression flatten​(IExpression collection)
        Intended to be applied on collections of collections. Yields a single collection with all elements from the source collections, in the order they are evaluated.
        Parameters:
        collection - The collection providing the collections that provides all elements
        Returns:
        A collection expression
      • lambda

        IExpression lambda​(IExpression variable,
                           IExpression[] initialAssignments,
                           IExpression body)
        Creates a lambda expression that takes more then one variable (currying). Suitable for use in most collection expressions.
        Parameters:
        variable - The element variable that the lambda uses
        body - The body of the lambda
        initialAssignments - Assignments to evaluate once before calling the body for each element.
        Returns:
        A lambda expression with currying
      • memberCall

        IExpression memberCall​(IExpression target,
                               String name,
                               IExpression... args)
        Creates a member call expression.
        Parameters:
        target - The target for the member call
        name - The name of the member
        args - The arguments to use for the call
        Returns:
        A member expression
      • traverse

        IExpression traverse​(IExpression collection,
                             IExpression lambda)

        Recursively traverse and collect elements based on a condition

        A common scenario in p2 is that you want to start with a set of roots and then find all items that fulfill the root requirements. Those items in turn introduce new requirements so you want to find them too. The process continues until no more requirements can be satisfied. This type of query can be performed using the traverse function.

        The function will evaluate an expression, once for each element, collect elements for which the evaluation returned true, then then re-evaluate using the collected result as source of elements. No element is evaluated twice. This continues until no more elements are found.

        Parameters:
        collection - The collection providing the elements to test
        lambda - The lambda that collects the children for the next iteration
        Returns:
        A collection expression
      • unique

        IExpression unique​(IExpression collection,
                           IExpression cache)
        Create an expression that yields a new collection where each element is unique. An optional cache can be provided if the uniqueness should span a larger scope then just the source collection.
        Parameters:
        collection - The source collection
        cache - Optional cache to use when uniqueness should span over several invocations
        Returns:
        A collection expression
      • array

        IExpression array​(IExpression... elements)
        Create an array of elements.
        Parameters:
        elements - The elements of the array
        Returns:
        An array expression
      • at

        IExpression at​(IExpression target,
                       IExpression key)
        Create an lookup of key in the target. The key expression should evaluate to a string or an integer.
        Parameters:
        target - The target for the lookup
        key - The key to use for the lookup
        Returns:
        A lookup expression
      • createContext

        IEvaluationContext createContext​(Object... params)
        Create an evaluation context with one single variable
        Parameters:
        params - Indexed parameters to use in the expression
        Returns:
        the context
      • createContext

        IEvaluationContext createContext​(IExpression[] variables,
                                         Object... params)
        Create an evaluation context with one single variable
        Parameters:
        params - Indexed parameters to use in the expression
        variables - The variables that will be maintained by the context
        Returns:
        the context
      • constant

        IExpression constant​(Object value)
        Creates an expression that evaluates to the constant value.
        Parameters:
        value - The constant
        Returns:
        A constant expression
      • contextExpression

        <T> IContextExpression<T> contextExpression​(IExpression expr,
                                                    Object... parameters)
        Creates a top level expression that represents a full query.
        Parameters:
        expr - The query
        parameters - The parameters of the query
        Returns:
        A top level query expression
      • equals

        IExpression equals​(IExpression lhs,
                           IExpression rhs)
        Create an expression that tests if lhs is equal to rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • exists

        IExpression exists​(IExpression collection,
                           IExpression lambda)
        Create a collection filter that yields true if the lambda yields true for at least one of the elements of the collection
        Parameters:
        collection - The collection providing the elements to test
        lambda - The lambda that performs the test
        Returns:
        A boolean expression
      • filterExpression

        IFilterExpression filterExpression​(IExpression expression)
        Creates a top level expression suitable for predicate matching
        Parameters:
        expression - The boolean expression
        Returns:
        A top level predicate expression
      • function

        IExpression function​(Object function,
                             IExpression... args)
        Given one of the values in the map returned by getFunctionMap(), this method returns a function expression.
        Parameters:
        function - The value obtained from the map.
        args - The arguments to evaluate and pass when evaluating the function.
        Returns:
        A function expression
      • getFunctionMap

        Map<String,​? extends Object> getFunctionMap()
        Returns a map of functions supported by this factory. The map is keyed by function names and the value is an object suitable to pass to the function(Object, IExpression[]) method.
        Returns:
        A key/function map.
      • greater

        IExpression greater​(IExpression lhs,
                            IExpression rhs)
        Create an expression that tests if lhs is greater than rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • greaterEqual

        IExpression greaterEqual​(IExpression lhs,
                                 IExpression rhs)
        Create an expression that tests if lhs is greater than or equal to rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • indexedParameter

        IExpression indexedParameter​(int index)
        Creates an indexed parameter expression
        Parameters:
        index - The index to use
        Returns:
        a parameter expression
      • intersect

        IExpression intersect​(IExpression c1,
                              IExpression c2)
        Create an intersection of c1 and c2
        Parameters:
        c1 - first collection
        c2 - second collection
        Returns:
        An intersect expression
      • lambda

        IExpression lambda​(IExpression variable,
                           IExpression body)
        Creates a lambda expression that takes exactly one variable. Suitable for use in most collection expressions.
        Parameters:
        variable - The element variable that the lambda uses
        body - The body of the lambda
        Returns:
        A lambda expression
      • latest

        IExpression latest​(IExpression collection)
        Create an expression that yields a new collection consisting of the latest version of the elements of the collection. Each element in collection must implement the IVersionedId interface.
        Parameters:
        collection - The collection providing the versioned elements
        Returns:
        A collection expression
      • less

        IExpression less​(IExpression lhs,
                         IExpression rhs)
        Create an expression that tests if lhs is less than rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • lessEqual

        IExpression lessEqual​(IExpression lhs,
                              IExpression rhs)
        Create an expression that tests if lhs is less than or equal to rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • limit

        IExpression limit​(IExpression collection,
                          int count)
        Create an expression that yields a new collection consisting of the count first elements of the source collection.
        Parameters:
        collection - The source collection
        count - The element count limit
        Returns:
        A collection expression
      • limit

        IExpression limit​(IExpression collection,
                          IExpression limit)
        Create an expression that yields a new collection consisting of the n first elements of the source collection where n is determined by limit.
        Parameters:
        collection - The source collection
        limit - The expression that evaluates to the element count limit
        Returns:
        A collection expression
      • normalize

        IExpression normalize​(List<? extends IExpression> operands,
                              int expressionType)
        Performs boolean normalization on the expression to create a canonical form.
        Parameters:
        operands - The operands to normalize
        expressionType - The type (must be either IExpression.TYPE_AND or IExpression.TYPE_OR.
        Returns:
        The normalized expression
      • matches

        IExpression matches​(IExpression lhs,
                            IExpression rhs)
        Create an expression that tests if lhs matches rhs.
        Parameters:
        lhs - The left hand side value.
        rhs - The right hand side value.
        Returns:
        A boolean expression
      • matchExpression

        <T> IMatchExpression<T> matchExpression​(IExpression expression,
                                                Object... parameters)
        Creates a parameterized top level expression suitable for predicate matching
        Parameters:
        expression - The boolean expression
        parameters - The parameters to use in the call
        Returns:
        A top level predicate expression
      • member

        IExpression member​(IExpression target,
                           String name)
        Creates a member accessor expression.
        Parameters:
        target - The target for the member access
        name - The name of the member
        Returns:
        A member expression
      • not

        IExpression not​(IExpression operand)
        Creates an expression that negates the result of evaluating its operand.
        Parameters:
        operand - The boolean expression to negate
        Returns:
        A boolean expression
      • or

        IExpression or​(IExpression... operands)
        Create a logical or of its operands.
        Parameters:
        operands - The boolean operands
        Returns:
        A boolean expression
      • pipe

        IExpression pipe​(IExpression... expressions)
        Create a pipe of expressions.
        Parameters:
        expressions - The expressions that make out the pipe
        Returns:
        A pipe expression
      • select

        IExpression select​(IExpression collection,
                           IExpression lambda)
        Create an expression that yields a new collection consisting of all elements of the collection for which the lambda yields true.
        Parameters:
        collection - The collection providing the elements to test
        lambda - The lambda that performs the test
        Returns:
        A collection expression
      • thisVariable

        IExpression thisVariable()
        Returns the variable that represents this in an expression
        Returns:
        The this variable.
      • toExpression

        IExpression toExpression​(IQuery<?> query)
        Wrap an IQuery as an expression.
        Parameters:
        query - The query to wrap.
        Returns:
        An expression that wraps the query
      • union

        IExpression union​(IExpression c1,
                          IExpression c2)
        Create a union of c1 and c2
        Parameters:
        c1 - first collection
        c2 - second collection
        Returns:
        A union expression
      • variable

        IExpression variable​(String name)
        Creates an expression that represents a variable
        Parameters:
        name - The name of the variable
        Returns:
        A variable expression