1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*******************************************************************************
* Copyright (c) 2009 - 2010 Cloudsmith Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Cloudsmith Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.equinox.p2.metadata.expression;
import java.util.List;
/**
* This inteface provides all the factory methods needed to create the
* nodes of the expression tree.
*/
public interface IExpressionFactory {
String FUNC_BOOLEAN = "boolean"; //$NON-NLS-1$
String FUNC_VERSION = "version"; //$NON-NLS-1$
String FUNC_CLASS = "class"; //$NON-NLS-1$
String FUNC_RANGE = "range"; //$NON-NLS-1$
String FUNC_FILTER = "filter"; //$NON-NLS-1$
IExpression[] NO_ARGS = new IExpression[0];
/**
* Create a collection filter that yields true if the <code>lambda</code> yields true for
* all of the elements of the <code>collection</code>
* @param collection The collection providing the elements to test
* @param lambda The lambda that performs the test
* @return A boolean expression
*/
IExpression all(IExpression collection, IExpression lambda);
/**
* Create a logical <i>and</i> of its <code>operands</code>.
* @param operands The boolean operands
* @return A boolean expression
*/
IExpression and(IExpression... operands);
/**
* Create an lookup of <code>key</code> in the <code>target</code>.
* The key expression should evaluate to a string or an integer.
* @param target The target for the lookup
* @param key The key to use for the lookup
* @return A lookup expression
*/
IExpression at(IExpression target, IExpression key);
/**
* Create an evaluation context with one single variable
* @param params Indexed parameters to use in the expression
* @return the context
*/
IEvaluationContext createContext(Object... params);
/**
* Create an evaluation context with one single variable
* @param params Indexed parameters to use in the expression
* @param variables The variables that will be maintained by the context
* @return the context
*/
IEvaluationContext createContext(IExpression[] variables, Object... params);
/**
* Creates an expression that evaluates to the constant <code>value</code>.
* @param value The constant
* @return A constant expression
*/
IExpression constant(Object value);
/**
* Create an expression that tests if <code>lhs</code> is equal to <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression equals(IExpression lhs, IExpression rhs);
/**
* Create a collection filter that yields true if the <code>lambda</code> yields true for
* at least one of the elements of the <code>collection</code>
* @param collection The collection providing the elements to test
* @param lambda The lambda that performs the test
* @return A boolean expression
*/
IExpression exists(IExpression collection, IExpression lambda);
/**
* Creates a top level expression suitable for predicate matching
* @param expression The boolean expression
* @return A top level predicate expression
*/
IFilterExpression filterExpression(IExpression expression);
/**
* Create an expression that tests if <code>lhs</code> is greater than <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression greater(IExpression lhs, IExpression rhs);
/**
* Create an expression that tests if <code>lhs</code> is greater than or equal to <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression greaterEqual(IExpression lhs, IExpression rhs);
/**
* Creates an indexed parameter expression
* @param index The index to use
* @return a parameter expression
*/
IExpression indexedParameter(int index);
/**
* Creates a lambda expression that takes exactly one variable. Suitable for use
* in most collection expressions.
* @param variable The element variable that the lambda uses
* @param body The body of the lambda
* @return A lambda expression
*/
IExpression lambda(IExpression variable, IExpression body);
/**
* Create an expression that tests if <code>lhs</code> is less than <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression less(IExpression lhs, IExpression rhs);
/**
* Create an expression that tests if <code>lhs</code> is less than or equal to <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression lessEqual(IExpression lhs, IExpression rhs);
/**
* Performs boolean normalizations on the expression to create a canonical form.
* @param operands The operands to normalize
* @param expressionType The type (must be either {@link IExpression#TYPE_AND}
* or {@link IExpression#TYPE_OR}.
* @return The normalized expression
*/
IExpression normalize(List<? extends IExpression> operands, int expressionType);
/**
* Create an expression that tests if <code>lhs</code> matches <code>rhs</code>.
* @param lhs The left hand side value.
* @param rhs The right hand side value.
* @return A boolean expression
*/
IExpression matches(IExpression lhs, IExpression rhs);
/**
* Creates a parameterized top level expression suitable for predicate matching
* @param expression The boolean expression
* @param parameters The parameters to use in the call
* @return A top level predicate expression
*/
<T> IMatchExpression<T> matchExpression(IExpression expression, Object... parameters);
/**
* Creates a member accessor expression.
* @param target The target for the member access
* @param name The name of the member
* @return A member expression
*/
IExpression member(IExpression target, String name);
/**
* Creates an expression that negates the result of evaluating its <code>operand</code>.
* @param operand The boolean expression to negate
* @return A boolean expression
*/
IExpression not(IExpression operand);
/**
* Create a logical <i>or</i> of its <code>operands</code>.
* @param operands The boolean operands
* @return A boolean expression
*/
IExpression or(IExpression... operands);
/**
* Returns the variable that represents <code>this</this> in an expression
* @return The <code>this</this> variable.
*/
IExpression thisVariable();
/**
* Creates an expression that represents a variable
* @param name The name of the variable
* @return A variable expression
*/
IExpression variable(String name);
}
|
