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
|
/*******************************************************************************
* Copyright (c) 2009, 2018 Cloudsmith Inc. and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* Cloudsmith Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.equinox.p2.query;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.equinox.internal.p2.metadata.expression.Expression;
import org.eclipse.equinox.internal.p2.metadata.expression.ExpressionFactory;
import org.eclipse.equinox.internal.p2.metadata.expression.MatchExpression;
import org.eclipse.equinox.internal.p2.metadata.expression.QueryResult;
import org.eclipse.equinox.internal.p2.metadata.expression.RepeatableIterator;
import org.eclipse.equinox.p2.metadata.expression.ExpressionUtil;
import org.eclipse.equinox.p2.metadata.expression.IEvaluationContext;
import org.eclipse.equinox.p2.metadata.expression.IExpression;
import org.eclipse.equinox.p2.metadata.expression.IMatchExpression;
import org.eclipse.equinox.p2.metadata.index.IIndex;
import org.eclipse.equinox.p2.metadata.index.IIndexProvider;
import org.eclipse.equinox.p2.metadata.index.IQueryWithIndex;
/**
* A query that matches candidates against an expression.
* @since 2.0
*/
public class ExpressionMatchQuery<T> implements IMatchQuery<T>, IQueryWithIndex<T> {
private final IMatchExpression<T> expression;
private final Class<? extends T> matchingClass;
private final IEvaluationContext context;
private final List<String> indexedMembers;
public ExpressionMatchQuery(Class<? extends T> matchingClass, IExpression expression, Object... parameters) {
this.matchingClass = matchingClass;
this.expression = ExpressionUtil.getFactory().matchExpression(expression, parameters);
this.context = this.expression.createContext();
this.indexedMembers = Expression.getIndexCandidateMembers(matchingClass, ExpressionFactory.THIS, (Expression) expression);
}
public ExpressionMatchQuery(Class<? extends T> matchingClass, String expression, Object... parameters) {
this(matchingClass, ExpressionUtil.parse(expression), parameters);
}
public IEvaluationContext getContext() {
return context;
}
public Class<? extends T> getMatchingClass() {
return matchingClass;
}
@Override
public IQueryResult<T> perform(IIndexProvider<T> indexProvider) {
if (((MatchExpression<T>) expression).operand == ExpressionUtil.TRUE_EXPRESSION)
return new QueryResult<>(RepeatableIterator.create(indexProvider));
Iterator<T> iterator = null;
int top = indexedMembers.size();
for (int idx = 0; idx < top; ++idx) {
IIndex<T> index = indexProvider.getIndex(indexedMembers.get(idx));
if (index != null) {
iterator = index.getCandidates(context, ExpressionFactory.THIS, expression);
if (iterator != null)
break;
}
}
if (iterator == null)
iterator = RepeatableIterator.create(indexProvider);
context.setIndexProvider(indexProvider);
return perform(iterator);
}
@Override
public IQueryResult<T> perform(Iterator<T> iterator) {
if (((MatchExpression<T>) expression).operand == ExpressionUtil.TRUE_EXPRESSION)
return new QueryResult<>(iterator);
HashSet<T> result = null;
while (iterator.hasNext()) {
T value = iterator.next();
if (isMatch(value)) {
if (result == null)
result = new HashSet<>();
result.add(value);
}
}
return result == null ? Collector.emptyCollector() : new CollectionResult<>(result);
}
@Override
public boolean isMatch(T candidate) {
if (!matchingClass.isInstance(candidate))
return false;
ExpressionFactory.THIS.setValue(context, candidate);
return Boolean.TRUE == expression.evaluate(context);
}
@Override
public IMatchExpression<T> getExpression() {
return expression;
}
public void setIndexProvider(IIndexProvider<T> indexProvider) {
context.setIndexProvider(indexProvider);
}
public void prePerform() { //
}
public void postPerform() { //
}
}
|
