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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
package org.eclipse.viatra.query.application.queries;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.apache.log4j.Logger;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.viatra.query.application.queries.EClassMatch;
import org.eclipse.viatra.query.application.queries.util.EClassQuerySpecification;
import org.eclipse.viatra.query.runtime.api.IMatchProcessor;
import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
/**
* Generated pattern matcher API of the org.eclipse.viatra.query.application.queries.eClass pattern,
* providing pattern-specific query methods.
*
* <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
* e.g. in conjunction with {@link ViatraQueryEngine#on(Notifier)}.
*
* <p>Matches of the pattern will be represented as {@link EClassMatch}.
*
* <p>Original source:
* <code><pre>
* {@literal @}Item(item = ec, label = "EC: $ec.name$")
* {@literal @}Format(color = "#e8da2c")
* pattern eClass(ec : EClass) { EClass(ec); }
* </pre></code>
*
* @see EClassMatch
* @see EClassProcessor
* @see EClassQuerySpecification
*
*/
@SuppressWarnings("all")
public class EClassMatcher extends BaseMatcher<EClassMatch> {
/**
* Initializes the pattern matcher within an existing VIATRA Query engine.
* If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
* The match set will be incrementally refreshed upon updates.
* @param engine the existing VIATRA Query engine in which this matcher will be created.
* @throws ViatraQueryException if an error occurs during pattern matcher creation
*
*/
public static EClassMatcher on(final ViatraQueryEngine engine) throws ViatraQueryException {
// check if matcher already exists
EClassMatcher matcher = engine.getExistingMatcher(querySpecification());
if (matcher == null) {
matcher = new EClassMatcher(engine);
// do not have to "put" it into engine.matchers, reportMatcherInitialized() will take care of it
}
return matcher;
}
private final static int POSITION_EC = 0;
private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(EClassMatcher.class);
/**
* Initializes the pattern matcher over a given EMF model root (recommended: Resource or ResourceSet).
* If a pattern matcher is already constructed with the same root, only a light-weight reference is returned.
* The scope of pattern matching will be the given EMF model root and below (see FAQ for more precise definition).
* The match set will be incrementally refreshed upon updates from this scope.
* <p>The matcher will be created within the managed {@link ViatraQueryEngine} belonging to the EMF model root, so
* multiple matchers will reuse the same engine and benefit from increased performance and reduced memory footprint.
* @param emfRoot the root of the EMF containment hierarchy where the pattern matcher will operate. Recommended: Resource or ResourceSet.
* @throws ViatraQueryException if an error occurs during pattern matcher creation
* @deprecated use {@link #on(ViatraQueryEngine)} instead, e.g. in conjunction with {@link ViatraQueryEngine#on(Notifier)}
*
*/
@Deprecated
public EClassMatcher(final Notifier emfRoot) throws ViatraQueryException {
this(ViatraQueryEngine.on(emfRoot));
}
/**
* Initializes the pattern matcher within an existing VIATRA Query engine.
* If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
* The match set will be incrementally refreshed upon updates.
* @param engine the existing VIATRA Query engine in which this matcher will be created.
* @throws ViatraQueryException if an error occurs during pattern matcher creation
* @deprecated use {@link #on(ViatraQueryEngine)} instead
*
*/
@Deprecated
public EClassMatcher(final ViatraQueryEngine engine) throws ViatraQueryException {
super(engine, querySpecification());
}
/**
* Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @return matches represented as a EClassMatch object.
*
*/
public Collection<EClassMatch> getAllMatches(final EClass pEc) {
return rawGetAllMatches(new Object[]{pEc});
}
/**
* Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
* Neither determinism nor randomness of selection is guaranteed.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @return a match represented as a EClassMatch object, or null if no match is found.
*
*/
public EClassMatch getOneArbitraryMatch(final EClass pEc) {
return rawGetOneArbitraryMatch(new Object[]{pEc});
}
/**
* Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
* under any possible substitution of the unspecified parameters (if any).
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @return true if the input is a valid (partial) match of the pattern.
*
*/
public boolean hasMatch(final EClass pEc) {
return rawHasMatch(new Object[]{pEc});
}
/**
* Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @return the number of pattern matches found.
*
*/
public int countMatches(final EClass pEc) {
return rawCountMatches(new Object[]{pEc});
}
/**
* Executes the given processor on each match of the pattern that conforms to the given fixed values of some parameters.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @param processor the action that will process each pattern match.
*
*/
public void forEachMatch(final EClass pEc, final IMatchProcessor<? super EClassMatch> processor) {
rawForEachMatch(new Object[]{pEc}, processor);
}
/**
* Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
* Neither determinism nor randomness of selection is guaranteed.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @param processor the action that will process the selected match.
* @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
*
*/
public boolean forOneArbitraryMatch(final EClass pEc, final IMatchProcessor<? super EClassMatch> processor) {
return rawForOneArbitraryMatch(new Object[]{pEc}, processor);
}
/**
* Returns a new (partial) match.
* This can be used e.g. to call the matcher with a partial match.
* <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
* @param pEc the fixed value of pattern parameter ec, or null if not bound.
* @return the (partial) match object.
*
*/
public EClassMatch newMatch(final EClass pEc) {
return EClassMatch.newMatch(pEc);
}
/**
* Retrieve the set of values that occur in matches for ec.
* @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches
*
*/
protected Set<EClass> rawAccumulateAllValuesOfec(final Object[] parameters) {
Set<EClass> results = new HashSet<EClass>();
rawAccumulateAllValues(POSITION_EC, parameters, results);
return results;
}
/**
* Retrieve the set of values that occur in matches for ec.
* @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches
*
*/
public Set<EClass> getAllValuesOfec() {
return rawAccumulateAllValuesOfec(emptyArray());
}
@Override
protected EClassMatch tupleToMatch(final Tuple t) {
try {
return EClassMatch.newMatch((EClass) t.get(POSITION_EC));
} catch(ClassCastException e) {
LOGGER.error("Element(s) in tuple not properly typed!",e);
return null;
}
}
@Override
protected EClassMatch arrayToMatch(final Object[] match) {
try {
return EClassMatch.newMatch((EClass) match[POSITION_EC]);
} catch(ClassCastException e) {
LOGGER.error("Element(s) in array not properly typed!",e);
return null;
}
}
@Override
protected EClassMatch arrayToMatchMutable(final Object[] match) {
try {
return EClassMatch.newMutableMatch((EClass) match[POSITION_EC]);
} catch(ClassCastException e) {
LOGGER.error("Element(s) in array not properly typed!",e);
return null;
}
}
/**
* @return the singleton instance of the query specification of this pattern
* @throws ViatraQueryException if the pattern definition could not be loaded
*
*/
public static IQuerySpecification<EClassMatcher> querySpecification() throws ViatraQueryException {
return EClassQuerySpecification.instance();
}
}
|
